 | This articleis missing information about prominent features of versions after 3.0. Please expand the article to include this information. Further details may exist on thetalk page.(March 2024) |
Theprogramming languagePython was conceived in the late 1980s,[1] and its implementation was started in December 1989[2] byGuido van Rossum atCWI inthe Netherlands as a successor toABC capable ofexception handling and interfacing with theAmoeba operating system.[3] Van Rossum was Python's principal author and had a central role in deciding the direction of Python (as reflected in the title given to him by the Python community,Benevolent Dictator for Life (BDFL)[4][5]) until stepping down as leader on July 12, 2018.[6] Python was named after theBBC TV showMonty Python's Flying Circus.[7]
Python 2.0 was released on October 16, 2000, with many major new features, such aslist comprehensions,cycle-detectinggarbage collector,reference counting,memory management and support forUnicode, along with a change to the development process itself, with a shift to a more transparent and community-backed process.[8]
Python 3.0, a major, backwards-incompatible release, was released on December 3, 2008[9] after a long period of testing. Many of its major features were alsobackported to the backwards-compatible Python versions 2.6 and 2.7[10] until support for Python 2 finally ceased at the beginning of 2020. Releases of Python 3 include the2to3 utility, which automates the translation of Python 2 code to Python 3.[11]
As of 24 October 2025[update], Python 3.14.0 is the latest stable release. This version currently receives full bug-fix and security updates, while Python 3.13—released in October 2024—will continue to receive bug-fixes until October 2026, and after that will only receive security fixes until its end-of-life in 2029. Python 3.10 is the oldest supported version of Python (albeit in the 'security support' phase).[12][13]
Van Rossum first published the code (for Python version 0.9.1) to alt.sources in February 1991.[14][15] Several features of the language were already present at this stage, among themclasses with inheritance, exception handling, functions, and various coredatatypes such aslist,dict, andstr. The initial release also contained amodule system borrowed fromModula-3; Van Rossum describes the module as "one of Python's major programming units".[1] Python's exception model also resembled Modula-3's, with the addition of anelse clause.[3] In 1994comp.lang.python, the primarydiscussion forum for Python, was formed.[1]
Python reached version 1.0 in January 1994. The major new features included in this release were the functional programming toolslambda,map,filter andreduce. Van Rossum stated that "Python acquired lambda, reduce(), filter() and map(), courtesy of aLisp hacker who missed them and submitted workingpatches".[16]
The last version released while Van Rossum was at CWI was Python 1.2. In 1995, Van Rossum continued his work on Python at theCorporation for National Research Initiatives (CNRI) inReston,Virginia from where he released several versions.
By version 1.4, Python had acquired several new features. Notable among these are the Modula-3 inspiredkeyword arguments (which are also similar toCommon Lisp's keyword arguments) and built-in support forcomplex numbers. Also included is a basic form ofdata hiding byname mangling, though this is easily bypassed.[17]
During Van Rossum's stay at CNRI, he launched the Computer Programming for Everybody (CP4E) initiative, intending to make programming more accessible to more people, with a basic "literacy" in programming languages, similar to the basic English literacy and mathematics skills required by most employers. Python served a central role in this: because of its focus on clean syntax, it was already suitable, and CP4E's goals bore similarities to its predecessor, ABC. The project was funded byDARPA.[18] As of 2007[update], the CP4E project is inactive, and while Python attempts to be easily learnable and not too arcane in its syntax and semantics, outreach to non-programmers is not an active concern.[19]
In 2000, the Python core development team moved to BeOpen.com[20] to form the BeOpen PythonLabs team.[21][22] CNRI requested that a version 1.6 be released, summarizing Python's development up to the point at which the development team left CNRI. Consequently, the release schedules for 1.6 and 2.0 had a significant amount of overlap.[8] Python 2.0 was the only release from BeOpen.com. After Python 2.0 was released by BeOpen.com, Guido van Rossum and the other PythonLabs developers joinedDigital Creations.
The Python 1.6 release included a new CNRI license that was substantially longer than the CWI license that had been used for earlier releases. The new license included a clause stating that the license was governed by thelaws of theState of Virginia. TheFree Software Foundation argued that the choice-of-law clause was incompatible with theGNU General Public License. BeOpen, CNRI and the FSF negotiated a change to Python'sfree-software license that would make it GPL-compatible. Python 1.6.1 is essentially the same as Python 1.6, with a few minor bug fixes, and with the new GPL-compatible license.[23]
Python 2.0, released October 2000,[8] introducedlist comprehensions, a feature borrowed from thefunctional programming languagesSETL andHaskell. Python's syntax for this construct is very similar to Haskell's, apart from Haskell's preference forpunctuation characters and Python's preference for alphabetic keywords. Python 2.0 also introduced a garbage collector able to collect reference cycles.[8]
Python 2.1 was close to Python 1.6.1, as well as Python 2.0. Its license was renamedPython Software Foundation License. All code, documentation and specifications added, from the time of Python 2.1's alpha release on, is owned by thePython Software Foundation (PSF), anonprofit organization formed in 2001, modeled after theApache Software Foundation.[23] The release included a change to the language specification to support nested scopes, like otherstatically scoped languages.[24] (The feature was turned off by default, and not required, until Python 2.2.)
Python 2.2 was released in December 2001;[25] a major innovation was the unification of Python's types (types written inC) and classes (types written in Python) into one hierarchy. This single unification made Python's object model purely and consistently object oriented.[26] Also added weregenerators which were inspired byIcon.[27]
Python 2.5 was released in September 2006[28] and introduced thewith statement, which encloses a code block within a context manager (for example, acquiring alock before the block of code is run and releasing the lock afterwards, or opening afile and then closing it), allowingresource acquisition is initialization (RAII)-like behavior and replacing a common try/finally idiom.[29]
Python 2.6 was released to coincide with Python 3.0, and included some features from that release, as well as a "warnings" mode that highlighted the use of features that were removed in Python 3.0.[30][10] Similarly, Python 2.7 coincided with and included features from Python 3.1,[31] which was released on June 26, 2009.Parallel 2.x and 3.x releases then ceased, and Python 2.7 was the last release in the 2.x series.[32] In November 2014, it was announced that Python 2.7 would be supported until 2020, but users were encouraged to move to Python 3 as soon as possible.[33] Python 2.7 support ended on January 1, 2020, along withcode freeze of 2.7 development branch. A final release, 2.7.18, occurred on April 20, 2020, and included fixes for critical bugs and release blockers.[34] This marked theend-of-life of Python 2.[35]
Python 3.0 (also called "Python 3000" or "Py3K") was released on December 3, 2008.[9] It was designed to rectify fundamental design flaws in the language – the changes required could not be implemented while retaining full backwards compatibility with the 2.x series, which necessitated a new major version number. The guiding principle of Python 3 was: "reduce feature duplication by removing old ways of doing things".[36]
Python 3.0 was developed with the same philosophy as in prior versions. However, as Python had accumulated new and redundant ways to program the same task, Python 3.0 had an emphasis on removing duplicative constructs and modules, in keeping with theZen of Python: "There should be one— and preferably only one —obvious way to do it".
Nonetheless, Python 3.0 remained amulti-paradigm language. Coders could still followobject-oriented,structured, andfunctional programming paradigms, among others, but within such broad choices, the details were intended to be more obvious in Python 3.0 than they were in Python 2.x.
Python 3.0 broke backward compatibility, and much Python 2 code does not run unmodified on Python 3.[37] Python'sdynamic typing combined with the plans to change the semantics of certain methods of dictionaries, for example, made perfectmechanical translation from Python 2.x to Python 3.0 very difficult. A tool called "2to3" does the parts of translation that can be done automatically. At this,2to3 appeared to be fairly successful, though an early review noted that there were aspects of translation that such a tool would never be able to handle.[38] Prior to the roll-out of Python 3, projects requiring compatibility with both the 2.x and 3.x series were recommended to have one source (for the 2.x series), and produce releases for the Python 3.x platform using2to3. Edits to the Python 3.x code were discouraged for so long as the code needed to run on Python 2.x.[10] This is no longer recommended; as of 2012 the preferred approach was to create a single code base that can run under both Python 2 and 3 using compatibility modules.[39]
Some of the major changes included for Python 3.0 were:
print so that it is abuilt-in function, not a statement. This made it easier to change a module to use a different print function, as well as making the syntax more regular. In Python 2.6 and 2.7print() is available as a built-in but is masked by the print statement syntax, which can be disabled by enteringfrom __future__ import print_function at the top of the file[40]input function, and the renaming of theraw_input function toinput. Python 3'sinput function behaves like Python 2'sraw_input function, in that the input is always returned as a string rather than being evaluated as an expressionreduce (but notmap orfilter) out of the built-in namespace and intofunctools (the rationale being code that usesreduce is less readable than code that uses a for loop and accumulator variable)[41][42]str/unicode types, representing text, and introducing a separate immutablebytes type; and a mostly corresponding mutablebytearray type, both of which represent arrays ofbytes[44]5 / 2 is2; whereas in Python 3,5 / 2 is2.5. (In both Python 2 – 2.2 onwards – and Python 3, a separate operator exists to provide the old behavior:5 // 2 is2)smörgåsbordintlongintint-21474836482147483647L orl suffix such as-100000000000000L0lPython 3.2 defined a stableABI, allowing extension modules to rely on functions across different Python versions.
Python 3.5 added the typing module, which allows fortype hints andfunction signature annotation. It additionally added theasync/await syntax. Furthermore,.pyo files were removed, with.pyc files representing both unoptimized and optimizedbytecode.
Python 3.6 followed with asyncgenerators and async comprehensions (for lists as well as dicts and sets), as well as formattedstring literals (f-strings).[47]
Python 3.10 introducedstructural pattern matching via match/case statements. Additionally it provided improved error messages which "were inspired by previous work in the PyPy interpreter" and added the|union type operator.[48]
Python 3.11 expandedexception handling functionality. Around this version, there has been a focus on making Python faster; 3.11 is claimed to be 10–60% faster than 3.10,[49] and 3.12 increases by an additional 5%.
Python 3.12 added the new keywordtype and improved error messages.
Python 3.13 added an experimentaljust-in-time (JIT) compiler, the ability to disable theglobal interpreter lock, a new and improved interactive interpreter (REPL), and an incrementalgarbage collector.[50]
Starting with Python 3.13, it and later versions receive two years of full support (increased from one and a half years), followed by three years of security support; this is the same total duration of support as previously.
Python 3.14.0 introduces e.g. a new opt-in interpreter, which is 3-5% faster.[51]
Python 3.15 will "MakeUTF-8 mode default";[52] This mode is supported in all current Python versions, but it currently must be opted into. UTF-8 is already used by default onWindows (and otheroperating systems) for most purposes, but an exception is opening files. Enabling UTF-8 also makes code fullycross-platform.
Security updates were expedited in 2021 and again twice in 2022. More issues were fixed in 2023 and in September 2024 (for Python versions 3.8.20 through 3.12.6)—all versions (including 2.7)[53] had been insecure because of issues leading to possibleremote code execution[54] andweb-cache poisoning.[55]
Releases before numbered versions:
| Version | Latest micro version | Release date | End of full support | End of security fixes |
|---|---|---|---|---|
| Unsupported: 0.9 | 0.9.9[2] | 1991-02-20[2] | 1993-07-29[a][2] | |
| Unsupported: 1.0 | 1.0.4[2] | 1994-01-26[2] | 1994-07-14[a][2] | |
| Unsupported: 1.1 | 1.1.1[2] | 1994-10-11[2] | 1994-11-10[a][2] | |
| Unsupported: 1.2 | 1995-04-13[2] | Unsupported | ||
| Unsupported: 1.3 | 1995-10-13[2] | Unsupported | ||
| Unsupported: 1.4 | 1996-10-25[2] | Unsupported | ||
| Unsupported: 1.5 | 1.5.2[56] | 1998-01-03[2] | 1999-04-13[a][2] | |
| Unsupported: 1.6 | 1.6.1[56] | 2000-09-05[57] | 2000–09[a][56] | |
| Unsupported: 2.0 | 2.0.1[58] | 2000-10-16[59] | 2001-06-22[a][58] | |
| Unsupported: 2.1 | 2.1.3[58] | 2001-04-15[60] | 2002-04-09[a][58] | |
| Unsupported: 2.2 | 2.2.3[58] | 2001-12-21[61] | 2003-05-30[a][58] | |
| Unsupported: 2.3 | 2.3.7[58] | 2003-06-29[62] | 2008-03-11[a][58] | |
| Unsupported: 2.4 | 2.4.6[58] | 2004-11-30[63] | 2008-12-19[a][58] | |
| Unsupported: 2.5 | 2.5.6[58] | 2006-09-19[64] | 2011-05-26[a][58] | |
| Unsupported: 2.6 | 2.6.9[30] | 2008-10-01[30] | 2010-08-24[b][30] | 2013-10-29[30] |
| Unsupported: 2.7 | 2.7.18[35] | 2010-07-03[35] | 2020-01-01[c][35] | |
| Unsupported: 3.0 | 3.0.1[58] | 2008-12-03[30] | 2009-06-27[65] | |
| Unsupported: 3.1 | 3.1.5[66] | 2009-06-27[66] | 2011-06-12[67] | 2012-04-06[66] |
| Unsupported: 3.2 | 3.2.6[68] | 2011-02-20[68] | 2013-05-13[b][68] | 2016-02-20[68] |
| Unsupported: 3.3 | 3.3.7[69] | 2012-09-29[69] | 2014-03-08[b][69] | 2017-09-29[69] |
| Unsupported: 3.4 | 3.4.10[70] | 2014-03-16[70] | 2017-08-09[71] | 2019-03-18[a][70] |
| Unsupported: 3.5 | 3.5.10[72] | 2015-09-13[72] | 2017-08-08[73] | 2020-09-30[72] |
| Unsupported: 3.6 | 3.6.15[74] | 2016-12-23[74] | 2018-12-24[b][74] | 2021-12-23[74] |
| Unsupported: 3.7 | 3.7.17[75] | 2018-06-27[75] | 2020-06-27[b][75] | 2023-06-27[75] |
| Unsupported: 3.8 | 3.8.20[76] | 2019-10-14[76] | 2021-05-03[b][76] | 2024-10-07[76] |
| Unsupported: 3.9 | 3.9.25[77] | 2020-10-05[77] | 2022-05-17[b][77] | 2025-10-31[77][78] |
| Supported: 3.10 | 3.10.19[79] | 2021-10-04[79] | 2023-04-05[b][79] | 2026-10[79] |
| Supported: 3.11 | 3.11.14[80] | 2022-10-24[80] | 2024-04-02[b][80] | 2027-10[80] |
| Supported: 3.12 | 3.12.12[81] | 2023-10-02[81] | 2025-04-08[b][81] | 2028-10[81] |
| Supported: 3.13 | 3.13.9[82] | 2024-10-07[82] | 2026-10[82] | 2029-10[82] |
| Latest version:3.14 | 3.14.0[83] | 2025-10-07[83] | 2027-05[83] | 2030-10[83] |
| Future version: 3.15 | 3.15.0a2[84] | 2026-10-01[84] | 2028-05[84] | 2031-10[84] |
Table notes:
Much as Python 2.6 incorporated features from Python 3.0, version 2.7 incorporates some of the new features in Python 3.1. The 2.x series continues to provide tools for migrating to the 3.x series.