Python

A dynamically typed language with a large standard library, run by CPython, an interpreter that is finally learning to use many cores at once.

What it is: Programming languages (interpreted)
Type: Open source
Made by: Python Software Foundation
License: PSF License 2.0
Facts checked: 8 October 2026

What it is

CPython, the reference implementation, compiles each source file to bytecode (cached in .pyc files) and runs that bytecode in an interpreter loop. Types belong to values, not variables, so a name can hold an int now and a str later, and mistakes surface when the line runs. Type hints, added by PEP 484 in Python 3.5, let you annotate functions and variables, but the interpreter doesn’t check them: a separate checker such as mypy reads them like a very strong linter.

For most of its life CPython has had a global interpreter lock (GIL): only one thread executes Python bytecode at a time. That keeps the object model simple and safe, but a CPU-bound program needs several processes, or native extensions that release the lock, to use more than one core. PEP 703 made the GIL optional. Python 3.13 (October 2024) shipped an experimental free-threaded build as a separate executable, python3.13t, and Python 3.14 (October 2025) made it officially supported, though still optional. On the pyperformance suite the free-threaded build runs single-threaded code about 1% (macOS on ARM) to 8% (x86-64 Linux) slower.

A new version comes out every October, and each gets bug fixes and then security fixes for five years in total.

Why teams pick it

A large standard library and a compact syntax in which indentation, not braces, groups statements
Gradual typing: start without types, then add hints and run a checker as the codebase grows
Extensible in C or C++, so a library can put fast native code behind a plain Python API
A predictable yearly release in October, each supported for five years

Watch out for

On the default build, threads don’t run Python code in parallel; CPU-bound work needs multiprocessing or native extensions
The free-threaded build costs some single-threaded speed, and importing an extension module that isn’t marked as safe turns the GIL back on
Type hints are never checked at runtime, so a wrong type still fails only when that line runs, unless you run a checker in CI
Dynamic typing means a typo in a rarely used branch can sit unnoticed until production reaches it

How it fits with other technologies

What uses Python

A dataclass and type hints that a checker reads but the interpreter ignores · python

from dataclasses import dataclass


@dataclass
class Order:
    customer: str
    total: float


# Type hints document intent; tools like mypy check them, the interpreter doesn't.
def totals(orders: list[Order]) -> dict[str, float]:
    result: dict[str, float] = {}
    for order in orders:
        result[order.customer] = result.get(order.customer, 0) + order.total
    return result


orders = [Order("ana", 30.0), Order("bo", 12.5), Order("ana", 7.5)]
print(totals(orders))  # {'ana': 37.5, 'bo': 12.5}

See it in a real stack

No architecture uses Python yet. Drop it into the playground and wire it up yourself.Open playground →

Where it came from1989–2025

In the late 1980s Guido van Rossum worked at CWI in Amsterdam, first on ABC, a teaching language, and then in the group building Amoeba, a distributed operating system. Writing Amoeba’s admin tools in C took too long, and the Bourne shell couldn’t reach Amoeba’s own system calls. He wanted a scripting language with ABC’s clean syntax but, unlike ABC, one that could be extended.

He started over the 1989 Christmas holidays, and the language was soon used across the Amoeba project. In February 1991 he posted version 0.9.0 to the alt.sources newsgroup. He named it after Monty Python’s Flying Circus, because the name felt suitably irreverent for a skunkworks project.

Python 3.0, in December 2008, broke compatibility with 2.x to fix old design mistakes. The migration took more than a decade: Python 2 was first due to retire in 2015, then in 2020. Since 2023 the biggest change has been removing the GIL so threads can use many cores.

Why it’s built this way

Indentation groups statements: Taken from ABC, along with very-high-level data types such as lists and dictionaries. Van Rossum had spent four years on ABC and liked its readability.
Built to be extended: ABC couldn’t be extended, which van Rossum saw as one of its biggest problems. An Amoeba-only language would have been foolish, so Python was designed to grow through modules, including ones written in C.
Exceptions for error handling: Error handling in Amoeba had convinced him exceptions mattered; their syntax and meaning came from Modula-3.
A global interpreter lock: One lock around the interpreter made the object model, including built-in types such as dict, safe against concurrent access without fine-grained locking. The cost, threads that can’t run Python code in parallel, is what PEP 703 now removes.

Timeline

1989
Implementation starts at CWI in December
1991
Version 0.9.0 posted to alt.sources in February
1994
Python 1.0 released in January
2008
Python 3.0 breaks compatibility with 2.x to fix its design
2020
Python 2 reaches end of life on January 1
2024
Python 3.13 ships an experimental build without the GIL
2025
Python 3.14 makes the free-threaded build officially supported

Sources12 · facts checked 8 October 2026

Improve this page on GitHub