Sign in Get started

Python Tutorial · Python Basics · Lesson 13 of 42

Python History & Versions

Where Python came from, how it grew from a hobby project into one of the most used languages, every major release on one timeline, what changed between Python 2 and 3, and which version to use today.

How Python started

Python began as a hobby project. Over the Christmas holidays of 1989, Guido van Rossum, a programmer at CWI (the national research institute for mathematics and computer science in the Netherlands), started writing an interpreter for a new scripting language. He wanted something as readable as ABC, a teaching language he had worked on, but practical enough for everyday system tasks. The name comes from the comedy series Monty Python's Flying Circus, not the snake.

The first public release, 0.9.0, appeared in February 1991. It already had classes, exceptions, functions and the core types list, dict and str. Python's guiding ideas, "readability counts" and "there should be one obvious way to do it", were later written down by Tim Peters as The Zen of Python (PEP 20).

Van Rossum led the language as its "Benevolent Dictator For Life" until he stepped down in July 2018. Since 2019 an elected five-person Steering Council decides on changes, which are proposed and discussed as PEPs (Python Enhancement Proposals). The Python Software Foundation (PSF), founded in 2001, owns the trademark and supports the community.

Timeline of major versions

  1. Python 3.15Current
    • Explicit lazy imports: lazy import json loads a module only when first used (PEP 810)
    • New built-ins frozendict (PEP 814) and sentinel (PEP 661)
    • UTF-8 is the default text encoding everywhere (PEP 686)
    • Unpacking in comprehensions, e.g. [*row for row in rows] (PEP 798), and a new profiling package (PEP 799)
  2. Python 3.14Supported
    • Template strings t"..." for safe string processing (PEP 750)
    • Annotations are evaluated lazily (PEP 649/749)
    • The free-threaded (no-GIL) build becomes officially supported (PEP 779)
    • concurrent.interpreters and compression.zstd in the standard library (PEP 734, PEP 784)
  3. Python 3.13Security fixes until Oct 2029
    • A new interactive REPL with colours and multi-line editing
    • Experimental free-threaded build without the GIL (PEP 703) and an experimental JIT compiler (PEP 744)
  4. Python 3.12Security fixes until Oct 2028
    • New type-parameter syntax def first[T](items: list[T]) -> T and type aliases (PEP 695)
    • f-strings can contain any expression, including nested quotes (PEP 701)
  5. Python 3.11Security fixes until Oct 2027
    • 10–60% faster than 3.10 thanks to the Faster CPython project
    • Exception groups and except* (PEP 654), tomllib, much more precise error locations
  6. Python 3.10End of life · Oct 2026
    • Structural pattern matching with match / case (PEP 634)
    • Union types written as int | str (PEP 604)
  7. Python 3.9End of life · Oct 2025
    • Dictionary merge operators | and |=; generic types such as list[int] in annotations
    • First release on the yearly October schedule (PEP 602)
  8. Python 3.8End of life · Oct 2024
    • The walrus operator := and positional-only parameters /
  9. Python 3.7End of life · Jun 2023
    • dataclasses, breakpoint(), and dictionaries officially keep insertion order
  10. Python 3.6End of life · Dec 2021
    • f-strings f"{name}" (PEP 498) and variable annotations
  11. Python 3.5End of life · Sep 2020
    • async / await syntax (PEP 492) and type hints with the typing module (PEP 484)
  12. Python 2.7End of life · Jan 2020
    • The last Python 2 release; supported for almost ten years to give projects time to move to Python 3
  13. Python 3.0Historic
    • The deliberate clean break: print() became a function and str became Unicode text
  14. Python 2.0Historic
    • List comprehensions, a cycle-detecting garbage collector and Unicode strings; development moved to an open, community process
  15. Python 1.0Historic
    • Functional tools lambda, map, filter and reduce
  16. Python 0.9.0Historic
    • First public release, posted to the alt.sources newsgroup

How Python modernized

  • The Python 3 transition (2008–2020). Python 3 fixed long-standing design problems, most importantly the confusion between bytes and text, at the cost of backward compatibility. The move took more than a decade; Python 2.7 finally reached end of life on 1 January 2020.
  • A predictable release cadence. Since 3.9, a new version ships every October (PEP 602). Each one gets about two years of bug fixes, then security fixes only, for five years in total.
  • Typing went mainstream. Optional type hints (3.5), variable annotations (3.6), list[int] (3.9), int | str (3.10) and the new generic syntax (3.12) let tools such as mypy and Pyright catch bugs before the code runs, without changing how Python executes.
  • Speed became a priority. The Faster CPython work made 3.11 much faster, followed by an experimental JIT in 3.13.
  • Removing the GIL. The Global Interpreter Lock let only one thread run Python code at a time. 3.13 shipped an experimental build without it, 3.14 made it officially supported, and 3.15 added a stable ABI for it, so threads can finally use several CPU cores.

Python 2 vs Python 3

Topic Python 2 Python 3
Printing print "hi" (statement) print("hi") (function)
Text str is bytes; unicode is text str is Unicode text; bytes is separate
Division 7 / 2 → 3 7 / 2 → 3.5 (use // for 3)
range() Builds a full list (xrange is lazy) Lazy object, like the old xrange
User input raw_input() input()
Catching errors except ValueError, e: except ValueError as e:
Dictionary views d.keys() returns a list d.keys() returns a live view
Status End of life since January 2020 Actively developed

Modern Python features by version

Feature Example Since
f-strings f"{name!r} is {age}" 3.6
Data classes @dataclass class Point: ... 3.7
Walrus operator if (n := len(items)) > 10: 3.8
Dict merge merged = defaults | overrides 3.9
Pattern matching match command: case ["go", direction]: 3.10
Exception groups except* ValueError: 3.11
Generic syntax def first[T](items: list[T]) -> T: 3.12
Template strings t"Hello {name}" 3.14
Lazy imports lazy import pandas 3.15

Which version should you use?

  • New projects: Python 3.14 or 3.15. Some third-party packages publish wheels for a new release a few weeks or months after it ships, so 3.14 is the safest choice in the first months after an October release.
  • Existing projects: any version that still receives security fixes (3.11 or newer today). Plan an upgrade before your version reaches end of life.
  • This tutorial: the examples run on Python 3.14 in your browser (Pyodide). Anything that needs 3.15 says so.

Official resources

Last reviewed 21 October 2026. Release and support dates come from the official release pages linked above.