History of Python

Python is one of the most widely used programming languages in the world today, powering everything from web backends and data science pipelines to automation scripts and machine learning research. But it started as a personal side project — one person's attempt to build a better scripting language during a holiday break. Understanding where Python came from, why it was named the way it was, and how it evolved through its two major eras helps explain many of the design decisions you'll encounter as you learn the language.

Origins: A Christmas Project at CWI

Python was created by Guido van Rossum, a Dutch programmer working at the Centrum Wiskunde & Informatica (CWI), a national research institute for mathematics and computer science in the Netherlands. In December 1989, van Rossum began working on Python as a hobby project to keep himself occupied during the Christmas holidays, when his office was closed.

At the time, van Rossum had been working on a language called ABC, and while he admired its clean, readable design, he wanted to fix several of its limitations — particularly around extensibility and exception handling. Python was conceived as a successor that combined ABC's readability with better support for modules, classes, and integration with the Amoeba distributed operating system that CWI was developing.

The first public release, Python 0.9.0, came out in February 1991. It already included core features that are still recognizable today: functions, exception handling, classes with inheritance, and core data types like lists, dicts, and strings. From these humble beginnings, Python grew steadily through the 1990s, with van Rossum earning the affectionate title "Benevolent Dictator For Life" (BDFL) from the community — a role he held until stepping back from that position in 2018.

Why "Python"? (Hint: It's Not the Snake)

One of the most persistent misconceptions about Python is that it was named after the snake. It wasn't — at least, not originally. Guido van Rossum named the language after Monty Python's Flying Circus, the British sketch comedy show he enjoyed, because he wanted a name that was "short, unique, and slightly mysterious."

This is why Python's official documentation and community culture are peppered with Monty Python references. The placeholder variable names spam and eggs (used constantly in tutorials, including Python's own official docs) come directly from the show's famous "Spam" sketch. The snake logo and snake-themed branding came later, as the community and PyPI's packaging ecosystem (and plenty of marketing) leaned into the more visually distinctive reptile — but the name itself is a comedy reference, not a zoological one.

Note

Next time someone tells you Python is named after the snake, you now know the real story — and can drop a Monty Python reference like `spam = eggs` to prove it.

The Python 2 vs Python 3 Split

As Python matured through the 1990s and 2000s, small design mistakes and inconsistencies accumulated — the kind that are hard to fix without breaking existing code. Rather than keep patching around them forever, the Python core team made a deliberate decision: create a new major version that was allowed to break backwards compatibility in order to clean things up properly.

That version was Python 3.0, released in December 2008. It intentionally introduced changes that were incompatible with Python 2, including:

True division by default — in Python 2, 5 / 2 returned 2 (integer division); in Python 3, 5 / 2 returns 2.5, and 5 // 2 is used for integer (floor) division.
print became a function, not a statement — you write print("hello") instead of print "hello".
Strings are Unicode by default, rather than requiring a separate unicode type — a huge simplification for handling text and internationalization.

These changes were small individually but pervasive, meaning almost no nontrivial Python 2 program would run unmodified on Python 3.

Python

# Python 2 style (will not run correctly on Python 3)
print "Hello, World!"
result = 5 / 2          # result is 2 (integer division)

# Python 3 style
print("Hello, World!")
result = 5 / 2          # result is 2.5 (true division)
result_floor = 5 // 2   # result_floor is 2 (explicit floor division)

Warning

Python 2 code will not run unmodified on Python 3, and the reverse is also true. If you inherit an older codebase that starts with `print "something"` (no parentheses) or imports modules like `urllib2`, it's written for Python 2 and will raise a `SyntaxError` or `ModuleNotFoundError` under Python 3. Tools like `2to3` and `six` were built to help ease that migration, but a full rewrite/audit is often the safer path today.

Because the transition was so disruptive, Python 2 and Python 3 coexisted for over a decade, with many libraries and companies slow to migrate. To give the ecosystem time to adapt, the Python Software Foundation committed to supporting Python 2 with security and bug fixes for years after Python 3's release. That support officially ended on January 1, 2020 — the Python 2 "sunset" date — after which no further official updates, including security patches, were released for Python 2. Today, all actively maintained Python code, libraries, and tooling target Python 3.

Major Version Milestones

Beyond the 2-vs-3 split, Python's evolution can be traced through a handful of landmark releases that each introduced features widely used in modern code.

Year	Version	Key Feature(s)
1991	0.9.0	First public release
2000	2.0	Automatic garbage collection, list comprehensions
2008	3.0	Intentional break from Python 2; print() function, true division, Unicode strings
2016	3.6	Formatted string literals (f-strings)
2019	3.8	Assignment expressions (the walrus operator :=)
2020	Python 2 EOL	Official end-of-life / sunset date for Python 2 (Jan 1, 2020)
2021	3.10	Structural pattern matching (the match statement)
2023	3.12	Major performance improvements, clearer error messages

A few of these are worth seeing in code, since they changed how idiomatic Python looks.

Python 3.6 — f-strings replaced clunkier %-formatting and .format() calls with a concise, readable syntax for embedding expressions directly inside string literals.

Python

name = "Guido"
year = 1991

# Before f-strings (Python 2 / early Python 3)
greeting = "Hello, %s! Python was released in %d." % (name, year)

# With f-strings (Python 3.6+)
greeting = f"Hello, {name}! Python was released in {year}."

Python 3.8 — the walrus operator (:=) allows assignment as part of a larger expression, which is especially handy inside while loops and comprehensions where you'd otherwise compute a value twice.

Python

# Before the walrus operator
data = input("Enter a value: ")
while data != "quit":
    print(f"You entered: {data}")
    data = input("Enter a value: ")

# With the walrus operator (Python 3.8+)
while (data := input("Enter a value: ")) != "quit":
    print(f"You entered: {data}")

Python 3.10 — structural pattern matching introduced the match statement, giving Python a switch-like construct that can also destructure data structures, similar to pattern matching in languages like Rust or Haskell.

Python

# Before match (Python < 3.10) - chained if/elif
def handle_command(command):
    if command == "start":
        return "Starting..."
    elif command == "stop":
        return "Stopping..."
    else:
        return "Unknown command"

# With match (Python 3.10+)
def handle_command(command):
    match command:
        case "start":
            return "Starting..."
        case "stop":
            return "Stopping..."
        case _:
            return "Unknown command"

Where Python Is Headed

Python's development didn't stop once the Python 2-to-3 transition was complete — if anything, the pace of improvement has accelerated. Since Python 3.9, the language has settled into a predictable yearly release cadence, with a new minor version (3.11, 3.12, 3.13, and beyond) shipping every October. This regular schedule makes it far easier for library maintainers and teams to plan upgrades.

Much of the recent focus has shifted from syntax additions toward raw performance. The "Faster CPython" initiative — backed significantly by Microsoft and core developers including former BDFL Guido van Rossum — has driven substantial speedups in the reference CPython interpreter starting with Python 3.11 and continuing through 3.12 and beyond, including reduced function-call overhead, more efficient bytecode, and steps toward removing the Global Interpreter Lock (GIL) as an optional mode in newer releases. Combined with better, more precise error messages (also introduced in 3.11+) that point exactly at the problematic sub-expression, Python's trajectory is less about reinventing the language and more about making the existing language faster and friendlier to use — a sign of a mature, widely adopted language investing in the details that matter to millions of developers.