Python terms in plain English

Declares a coroutine. Can be awaited; runs cooperatively on an event loop.

Run multiple coroutines concurrently and wait for all of them. The bread-and-butter of fan-out.

Structured concurrency primitive (Python 3.11+). `async with TaskGroup()` ensures every spawned task is awaited and any exception cancels the whole group — safer than bare `gather`.

Cap any awaitable with a timeout: `await asyncio.wait_for(coro, timeout=5)`. Raises `TimeoutError` on expiry and cancels the inner task. Essential for any external call.

Pauses a coroutine until another coroutine/Future finishes. Only legal inside `async def`.

Scheduler that drives async code — runs ready coroutines, parks blocked ones. `asyncio.run(main())` starts one.

Global Interpreter Lock — CPython's mutex that lets only one thread run Python bytecode at a time. Threads still help for I/O; for CPU, use processes.

Same as list comp, but builds a dict: `{k: v for k, v in pairs}`.

Hash map from keys to values. Insertion order preserved since Python 3.7.

A function with `yield`. Produces values lazily, one at a time — uses constant memory for streams.

Anything you can loop over with `for`. Lists, tuples, sets, dicts, strings, files, generators — all iterables.

Inline syntax for building a list from another iterable, with optional filter: `[f(x) for x in xs if cond(x)]`. Beats `map+filter+lambda`.

Tuple with named fields — accessed by `t.x` instead of `t[0]`. `typing.NamedTuple` is the modern form; gives you type hints + immutability for free.

Unordered collection of unique hashable values. O(1) membership check.

Ordered immutable sequence. Use for fixed-size records and as dict keys.

An object usable with `with`. Guarantees cleanup even on exception — `open()`, locks, DB sessions.

“Easier to Ask Forgiveness than Permission”. Idiomatic Python: try the operation, catch the exception, rather than pre-checking.

An object that signals something went wrong. Raised with `raise`, caught with `try/except`.

Handle exceptions. `finally` always runs (cleanup). Catching `Exception` is usually too broad — be specific.

Capture variable positional and keyword arguments. Lets a function accept any signature.

An inner function that captures variables from its enclosing scope. The captured value is by reference, not by value.

A higher-order function that wraps another to add behavior — logging, caching, auth. `@cache` is one.

Parameter with a fallback value: `def f(x=10)`. Beware mutable defaults — `def f(xs=[])` is a classic trap.

Named reusable block of code. Defined with `def`. First-class — you can pass functions like any other value.

Pre-bind some arguments of a function — produces a new callable with fewer parameters. Cleaner than a wrapping lambda for currying-style use.

An anonymous one-line function: `lambda x: x*2`. Use for short callbacks; prefer `def` when readable.

The constructor — runs when you call the class. Used to set instance attributes.

Inheriting `abc.ABC` + decorating with `@abstractmethod` prevents instantiation until subclasses override every abstract method. Documentation the language enforces.

A blueprint for objects. Created with `class Foo:`. Defines attributes + methods.

`@classmethod` receives the class as `cls` (alternative constructors, class-level state). `@staticmethod` gets neither `self` nor `cls` — a function namespaced inside the class.

Decorator (`@dataclass`) that auto-generates `__init__`, `__repr__`, and `__eq__` from typed attributes.

Double-underscore methods that hook into Python syntax: `__add__`, `__len__`, `__repr__`. Make your objects feel native.

A class can inherit attributes and methods from a parent class: `class Dog(Animal):`.

A specific object built from a class. `dog = Dog()` makes one instance of `Dog`.

`@property` turns a method into a read-only attribute. Accessed without parentheses; computed on demand. Common when the value derives from other state.

The current instance, passed implicitly as the first argument to methods. By convention named `self`, but the name isn't magic.

Dict subclass that counts hashable items: `Counter("hello")` → `{'l': 2, ...}`.

Dict that auto-creates missing keys with a factory: `defaultdict(list)` returns `[]` for any new key. Replaces `if k not in d: d[k] = []`-style code in counters and grouping.

Configure a dataclass attribute — mutable defaults, init/repr behavior. Use `field(default_factory=list)` to avoid the mutable-default trap.

Memoize a pure function with `@functools.cache`. Replaces hand-rolled dict caching.

Iterator building blocks — `chain`, `groupby`, `combinations`, `accumulate`. Lazy, memory-friendly.

Object-oriented filesystem paths. `Path(".").rglob("*.py")` beats `os.walk + os.path.join`.

An f-prefixed string literal that lets you inline expressions: `f"x={x}"`. Introduced in Python 3.6, now the default formatter.

Structural pattern matching (PEP 634, Python 3.10+). `match val: case Point(x, y): ...`. Matches on shape, not just value — closer to Rust/Scala match than C switch.

Substring/sublist via `s[start:stop:step]`. Negative indices count from the end.

Values that act as True / False in `if` statements. Empty containers, `0`, `None`, `""` are falsy; everything else is truthy.

Annotations that describe expected types: `def f(x: int) -> str:`. Not enforced at runtime — used by tools like mypy.

`:=` assigns inside an expression. Useful when you'd otherwise compute the same value twice.

Measures which lines your tests execute. 100% is rarely the goal — 'every important path covered once' is.

Reusable test setup. Declared with `@pytest.fixture`, injected by parameter name.

Run the same test against multiple inputs: `@pytest.mark.parametrize("x,y", [(1,2), (3,4)])`. Replaces copy-paste tests.

De facto Python test framework. `def test_x():` and `assert` — that's the whole API.

Opinionated Python formatter. Stops bike-shedding about style — one command, one canonical form.

Static type checker for Python. Catches type errors before runtime. Works best when you adopt incrementally.

Python's package manager. `pip install requests` fetches from PyPI.

Modern Python project config. Replaces setup.py + setup.cfg + (eventually) requirements.txt.

Plain text list of dependencies, optionally pinned: `requests==2.31.0`. `pip install -r requirements.txt` recreates the env.

Fast Rust-based Python linter. Replaces flake8 + isort + several plugins, ~100× faster.

Fast Rust-based Python package + project manager. Drop-in replacement for pip + venv with much faster installs.

Per-project Python environment. Isolates dependencies so two projects can use different package versions.

Cross-Origin Resource Sharing — browser security check on which origins may call your API. Set with response headers, not in the client.

Modern Python web framework. Type-driven, async-first, autogenerates OpenAPI docs.

Test transport that calls your FastAPI/Starlette app in-process — no real TCP, no port conflict, deterministic, 10-100× faster than spinning up a real server.

JSON Web Token — a signed, base64-encoded payload used for stateless auth. Verify, don't trust.

Spec for describing REST APIs as JSON/YAML. FastAPI emits one automatically; tools generate clients + docs from it.

Data validation library. Define a model, get parsing + validation + JSON serialization for free.

Architectural style for HTTP APIs — resources at URLs, verbs in the HTTP method, stateless requests.

Server-application interfaces. WSGI (PEP 3333) is sync — Flask, Django until 3.0. ASGI extends it for async + WebSockets — FastAPI, Starlette, modern Django. uvicorn / hypercorn speak ASGI; gunicorn speaks WSGI.