57 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.

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`.

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.

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.

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

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`.

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, ...}`.

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.

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.

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.