Python 1991
Executable pseudocode — readable, batteries-included, the glue language of the world.
Influenced by: Perl Go
Python is a high-level, dynamically typed language built around one overriding value: that code is read far more often than it is written. Its clean, indentation-defined syntax reads almost like pseudocode, while a famously batteries-included standard library and the largest third-party ecosystem in computing (PyPI) make it the default glue for everything from quick scripts to web backends. It is the lingua franca of data science, machine learning, scientific computing, automation, and teaching — a general-purpose language that optimizes relentlessly for programmer productivity and readability.
What makes it distinctive
- Significant indentation defines blocks — whitespace is the syntax. There are no curly braces; the visual structure of the code and its logical structure are forced to agree, an idea inherited directly from ABC.
- Readability as the prime directive — codified in The Zen of Python (
import this): "Explicit is better than implicit," "Readability counts," and the search for the one obvious way to do something. The language is often called executable pseudocode. - Dynamic, strong, duck typing —
if it walks like a duck...; objects are used by what they can do, not what they are declared to be, with no implicit coercions between, say, strings and integers. - Optional gradual type hints —
def f(x: int) -> str:annotations (PEP 484) are ignored by the interpreter but checked by tools like mypy/Pyright, letting one codebase span quick scripts and large typed systems. - Everything is an object — functions, classes, and modules are first-class values you can pass around, and a uniform data model (dunder methods like
__len__,__iter__,__enter__) lets your own types plug into every language operator and protocol. - Comprehensions and generators —
[n*n for n in xs if n%2], dict/set comprehensions, and lazyyield-based generators make data transformation concise and memory-efficient. - "Batteries included" + the largest ecosystem alive — a rich standard library (
itertools,collections,asyncio,json,dataclasses) plus PyPI, the biggest third-party package index in software, covering web, data, ML, and automation. - Expressive sugar that became standard — f-strings for interpolation, the walrus operator
:=, decorators (@wraps),with-statement context managers, and structuralmatch/casepattern matching. - The glue language — designed to embed and be embedded; a thin, friendly layer over fast C/C++/Rust extensions (NumPy, PyTorch), which is exactly why it became the cockpit of scientific computing and AI.
History
Python's story begins in the late 1980s at Centrum Wiskunde & Informatica (CWI) in Amsterdam, where Guido van Rossum had worked on the teaching language ABC. ABC was elegant but a closed, monolithic system that was hard to extend; Van Rossum admired its readability and clean block structure (including significant indentation) but was frustrated by its limitations. In December 1989, looking for a hobby project to occupy himself over the Christmas holidays, he began building a new scripting language that would keep ABC's clarity while adding the extensibility, exception handling, and interoperability with the operating system that ABC lacked. He named it Python — not after the snake, but after the British comedy troupe Monty Python's Flying Circus, signalling from the start that the language was meant to be approachable and fun.
The first public release, Python 0.9.0, was posted to the Usenet group alt.sources in February 1991. Even this earliest version already had the bones of the modern language: classes with inheritance, exception handling, functions, and the core built-in types str, list, and dict. Python 1.0 followed in January 1994, adding functional tools like map, filter, reduce, and lambda. Over these years Van Rossum became known in the community as the BDFL — Benevolent Dictator For Life — the final arbiter of language design decisions, a role he held for nearly three decades.
Python 2.0, released on 16 October 2000, was a landmark: it introduced list comprehensions, full garbage collection with cycle detection, and Unicode support, and — just as importantly — moved development to a more open, community-driven process. The Python Enhancement Proposal (PEP) system was established around this time as the formal mechanism for proposing and debating changes, and PEP 20, the Zen of Python (by Tim Peters), distilled the language's guiding aphorisms: Beautiful is better than ugly. Explicit is better than implicit. Readability counts. There should be one — and preferably only one — obvious way to do it.
Python 3.0, released in December 2008, was a deliberate, backwards-incompatible cleanup that fixed long-standing design warts: print became a function, integer division and Unicode/bytes handling were rationalized, and many APIs returned lazy iterators instead of lists. The decision to break compatibility triggered one of the longest migrations in software history. Python 2.7 (2010) became the final 2.x release and was kept on life support for a full decade; its end-of-life on 1 January 2020 finally closed the chapter and consolidated the world on Python 3.
Through the 2010s the language steadily modernized. Generators and the yield expression matured into coroutines; PEP 484 (2015) introduced type hints, ushering in optional gradual typing checked by external tools like mypy and Pyright (the interpreter itself ignores them at runtime); f-strings (PEP 498, Python 3.6, 2016) made string interpolation concise; the walrus operator := (PEP 572) landed in 3.8; and structural pattern matching (match/case, PEP 634) arrived in Python 3.10 (2021). In July 2018, weary of a contentious debate over the walrus operator, Van Rossum stepped down as BDFL; governance passed to an elected Steering Council, the model that runs the language today.
The long-standing performance criticism — and the Global Interpreter Lock (GIL) that serializes Python threads — became the focus of the 2020s. A multi-year Faster CPython effort (with sponsorship from Microsoft and others) delivered substantial speedups beginning in Python 3.11 (2022). Python 3.13 (7 October 2024) shipped the first official experimental free-threaded build that can run with the GIL disabled (PEP 703) alongside an experimental JIT compiler (PEP 744). Python 3.14 (7 October 2025) advanced free-threading to officially supported status (PEP 779, shipped as a separate python3.14t binary), and added template string literals (t-strings, PEP 750), multiple interpreters in the standard library (PEP 734), and built-in Zstandard compression.
More than any single feature, Python's dominance was built on its ecosystem. Tools like NumPy, pandas, SciPy, scikit-learn, TensorFlow, and PyTorch made it the undisputed language of data science and the AI revolution, while Django, Flask, and FastAPI anchor a huge share of web backends. Backed by the Python Software Foundation and the vast PyPI package index, Python has for years sat at or near the very top of the TIOBE, IEEE Spectrum, and Stack Overflow popularity rankings — the closest thing the industry has to a universal general-purpose language.