Python, step by step

print(a, b, sep='') changes the separator, print(x, end='') drops the newline. print(*items) spreads a list into arguments. print(x, file=sys.stderr) writes to stderr. When a value prints unhelpfully, try print(repr(x)) — that is the debug form, and it is what you see in a list or a traceback.

# type: ignore and # noqa: E501 on the end of a line silence a type checker or ruff for that line. # ruff: noqa at the top does the whole file. You will need these occasionally; both take specific codes so you can silence one rule rather than all.

Use r"..." for regular expressions and Windows paths so backslashes stay literal. b"..." makes bytes rather than text — you will meet those reading files in binary mode or handling HTTP bodies. Adjacent literals concatenate: ("long " "message") is one string, which is how long text gets wrapped across lines.

Assign several at once with a, b = 1, 2, and swap with a, b = b, a. _ is the conventional name for a value you are deliberately ignoring, as in for _ in range(3). Underscores are legal in numbers: 1_000_000 reads better and means the same thing.

The format spec after : is worth learning: {x:.2f} two decimals, {x:,} thousands separators, {x:>8} right-align in 8 columns, {x:<8} left, {x:^8} centre, {x:08.2f} zero-padded. {x!r} gives the repr instead of the str. For debugging, f"{x=}" prints both the expression and its value.

Doubling the braces escapes them: f"{{literal}}" prints {literal}. That is how you build JSON or CSS in an f-string. If you want a template filled in later rather than now, use "{name}".format(name=x) or string.Template — those take the values at call time, where an f-string takes them immediately.

round(x, 2) rounds to a number, f"{x:.2f}" formats to a string — different jobs. int("12") and float("1.5") parse, raising ValueError on rubbish rather than giving you NaN. divmod(a, b) gives quotient and remainder together. For money, use decimal.Decimal rather than float.

The ones you will use constantly: .strip() / .lstrip() / .rstrip(), .split(",") and .rsplit, "-".join(parts), .startswith() / .endswith() (both accept a tuple of options), .removeprefix() / .removesuffix(), and .splitlines(). .casefold() beats .lower() for case-insensitive comparison.

For anything beyond a literal swap, re.sub(pattern, replacement, s) does regex replacement, also replacing all by default — pass count=1 to limit it. .translate() is the fast path for single-character mappings.

Indenting a triple-quoted string inside a function puts that whitespace in the value. textwrap.dedent(text) strips the common leading indent, and a \ at the end of the first line drops the leading newline. Both are standard when embedding a prompt or a SQL query in a function.

There is no one-line if (x) doThing(); with braces, but if x: do_thing() on a single line is legal for short bodies. pass is the do-nothing statement when you need a body you have not written yet — Python has no empty block.

For dispatch on a value, a dict of functions usually beats a long chain: handlers.get(kind, default_handler)(). match handles shape as well as value — you can destructure with case {"type": "a", "id": id}: or case [first, *rest]:, which is where it earns its place over elif.

and and or return an operand rather than a boolean, so name or 'anon' is the common default idiom — but it also replaces 0 and "", so use x if x is not None else default when those are legitimate values. not binds tighter than and/or; when in doubt, bracket it.

Because it is an expression it works as a default argument, inside an f-string, or as the output half of a comprehension: [x if x > 0 else 0 for x in xs]. Nesting more than one is where readability dies — reach for a small function instead.

Write if items: rather than if len(items) > 0: — the first is idiomatic and the second reads as noise. The exception is when None and empty mean different things: if items is None: distinguishes 'not supplied' from 'supplied but empty', which matters constantly in API code.

Works with any comparison operators and mixes them freely: 0 <= i < len(xs) is the standard bounds check. It also chains is and in, though that reads badly. The one trap is that a == b == c tests all three are equal, not (a == b) == c.

not in is a single operator and reads better than not (x in y). Cost matters: in on a list scans it, on a set or dict it is a hash lookup. If you are membership-testing inside a loop, build a set() first. For dicts, in tests keys — use value in d.values() if you meant the other thing.

list(x) converts anything iterable — a string, a set, a generator, dict.keys(). Other things you will want: xs.count(v), xs.index(v), xs.remove(v) (by value, raises if absent), xs.clear(), and reversed(xs). a + b concatenates and a * 3 repeats — watch the trap in part 9.

Guard with if xs: before xs[-1], because an empty list raises IndexError. When you want a safe fetch, slicing does not raise: xs[-1:] gives [] rather than blowing up, and next(iter(xs), None) gets the first item or None.

Slices assign as well as read: xs[1:3] = [9] replaces that span with a different number of items, and del xs[1:3] removes it. xs[:] is the shallow-copy idiom and xs[::2] takes every other. All of it works on strings and tuples too, returning the same type.

xs.insert(0, v) puts one at the front, but it is O(n) — if you are queueing, collections.deque has appendleft and popleft in constant time. xs.pop() takes from the end, xs.pop(0) from the front, and both return the item.

Never mutate a list while looping over it — iterate list(xs) or build a new list instead. To loop over several things at once use zip; to loop with an index use enumerate; to loop over a dict's pairs use .items(). itertools has the rest: chain, islice, groupby, product.

range(len(xs)) is almost always the wrong call — enumerate(xs) says what you mean. range counts backwards with a negative step: range(10, 0, -1). It supports in, so x in range(0, 100, 5) is a cheap membership test rather than a scan.

enumerate(xs, start=1) numbers from one for human-facing output. It works on anything iterable, including a file object, which makes for lineno, line in enumerate(f, 1) the standard way to report errors with a line number.

zip(a, b, strict=True) raises if the lengths differ — use it whenever they are supposed to match, because the default silently truncates. zip(*rows) transposes. itertools.zip_longest pads the short one instead of stopping.

map(f, xs) and filter(p, xs) exist but are considered less readable and return lazy iterators, so you would need list(...) anyway. The one place map still wins is with an existing function and no lambda: map(str.upper, names).

Two ifs in a row means AND: [x for x in xs if x > 0 if x < 10]. The if BEFORE the for is a different thing — it transforms rather than filters, and needs the full x if cond else other form. Swap the brackets for {} to build a set or dict, or () for a lazy generator.

key= takes any function: key=len, key=str.lower, key=lambda r: r["name"]. For several fields, return a tuple: key=lambda r: (r["team"], -r["score"]) — and note the minus for descending on one field only. operator.itemgetter("name") is the faster form of the common lambda.

The same rule holds across the library: mutating methods return None. So xs = xs.sort() silently gives you None, xs = xs.append(1) too. If you see a mysterious NoneType error one line later, this is usually why. Use sorted(), reversed() or xs[:] when you want a value back.

Pass a generator expression, not a list comprehension — any(x > 2 for x in xs) stops at the first match, the list version evaluates everything first. To find out WHICH one matched rather than whether any did, use the next(...) idiom from the next step.

Without a default, next() raises StopIteration when nothing matches, so always pass the second argument. To get all matches instead of the first, use a comprehension. xs.index(v) finds a position but only by equality and raises ValueError if absent.

max(rows, key=lambda r: r["size"]) gets the biggest by a field rather than the biggest value. max(xs, default=0) avoids the empty-sequence error. sum(xs, start=0), sorted, min and max all accept the same key. For counting, collections.Counter(xs).most_common(3).

while True: with an inner break is the normal way to write a loop that exits from the middle — there is no do...while. There are no labelled breaks either, so to leave nested loops either set a flag, or put the loops in a function and return. The second is usually cleaner.

The same else works on while. It is only worth using for search loops; most people find a helper function that returns early clearer. Know it mainly so it does not confuse you in someone else's code — else here means 'no break', not 'if empty'.

Once you need two for clauses in a comprehension, consider whether a real loop reads better. itertools.product(a, b) replaces a nested loop over two collections, and itertools.chain.from_iterable(rows) flattens one level without a comprehension at all.

Practical upshot: do not rely on a loop variable after the loop unless you meant to, and do not expect a comprehension's variable to exist at all. If you need the last value, assign it explicitly inside the loop.

Write your own with yield inside a def. Use them when the source is large or infinite, or when you are piping through several stages. itertools.islice(gen, 10) takes the first ten without consuming the rest. The catch — single use — is in part 9.

Keys can be any hashable value: strings, numbers, tuples, enums — but not lists or dicts. dict(name="x", size=8) is an alternative constructor when the keys are valid identifiers. dict.fromkeys(keys, 0) builds one with a shared default, but be careful if that default is mutable.

Three tools beyond .get(): d.setdefault(k, []) inserts and returns in one step; collections.defaultdict(list) makes missing keys spring into existence, which is the usual way to group things; collections.Counter does counting. Use .get() for reads and defaultdict when you are accumulating.

d.pop(k, default) removes and returns without risk of raising. d.update(other) merges in place. d.clear() empties it. If you need to delete while iterating, loop over list(d.keys()) — mutating during iteration raises.

.items() is the one you want most of the time. Sort as you go with sorted(d.items(), key=lambda kv: kv[1]) to order by value. The views are live, so wrap in list() if you plan to modify the dict inside the loop.

Because insertion order holds, list(d)[0] is the first key inserted and d.popitem() removes the last. Sets have no order, so always sorted(s) before printing, comparing output or writing a test. Two sets still compare equal regardless of order.

Invert a dict with {v: k for k, v in d.items()}. Filter one with {k: v for k, v in d.items() if v}. The empty set has no literal — {} is a dict, so use set().

Right-hand side wins, so defaults | overrides is the config idiom. |= merges in place. The same ** expands a dict into keyword arguments at a call site: f(**options) — handy for passing settings through.

A function with no return gives back None. Functions are values — pass them, store them in a dict, return them. Nest one inside another when it is only used there. Add a docstring as the first line and help(f) will show it.

Defaults are evaluated once at definition, which is fine for numbers and strings and dangerous for lists and dicts — see the trap two steps down. A default can reference earlier parameters only at call time inside the body, not in the signature.

Named arguments mean you can reorder freely and skip middle ones with defaults. When a call site has more than two or three arguments, naming them is the difference between readable and not. You will see this everywhere in FastAPI and Pydantic code.

Useful for wrappers that pass everything through: def wrapper(*args, **kwargs): return inner(*args, **kwargs). That is how decorators are written. You can combine them with normal parameters — def f(first, *rest, **options) — as long as the order is positional, *, then **.

Use it whenever a function takes flags or options, so nobody can write run(prompt, True, False). You can also force the opposite with /: parameters before it are positional-only. Both let you rename or reorder later without breaking callers.

The fix is always def f(items=None): then items = [] if items is None else items. It applies to dicts, sets and any object you mutate — and to class attributes, which is the same bug in a different place (part 8). Ruff's B006 rule catches it if you enable the bugbear rules.

nonlocal for an enclosing function's variable, global for a module-level one. Needing either is often a sign that a small class or a returned value would be clearer. The one place closures genuinely shine is decorators and callbacks.

Always is None / is not None, never == None. Use Optional[str] or the newer str | None in annotations to say a value may be missing. A common shape is def f(x: str | None = None) — optional in both the type and the default.

For nested dicts, chain .get() with a {} default: d.get("a", {}).get("b"). For objects, getattr(obj, "name", None) is the safe attribute read. If the whole chain is speculative, a try/except AttributeError block is idiomatic here in a way it would not be in TypeScript.

Annotations become real in two places worth knowing: Pydantic and FastAPI read them to validate and to generate OpenAPI, and a checker like mypy or pyright will flag mistakes before you run. Adding mypy or pyright to a project is the closest you get to the TypeScript experience.

is for None, True, False and enum members. == for everything else. Never use is on numbers or strings even when it appears to work — small values are cached, so it succeeds by accident and fails on the one input that matters.

Add __repr__ early — it is what you see in logs, lists and the debugger, and the default is useless. __eq__ gives you value equality. If the class is only holding data, @dataclass writes both for you and is usually the better starting point.

@staticmethod takes no self and is just a function living on the class. @classmethod takes cls instead and is the standard way to write alternative constructors: Model.from_json(text). Both are worth knowing because you will read them constantly.

Add a setter with @url.setter under a matching method name if it should be writable. Use a property for something cheap and derived; if it does real work, make it a normal method so the call site shows the cost. functools.cached_property computes once and remembers.

Call super().__init__(...) first in a subclass __init__ or the base's setup never runs. Prefer composition for reuse and inheritance for genuine is-a relationships. For an interface, typing.Protocol gives you structural typing without a base class at all.

Anything mutable belongs in __init__ as self.x = []. A class attribute is fine and useful for constants and defaults that never change: MAX_RETRIES = 3. @dataclass refuses a mutable default outright and makes you write field(default_factory=list) — worth copying that discipline.

field(default_factory=list) for mutable defaults. frozen=True makes it immutable and hashable, so it can go in a set or be a dict key. dataclasses.asdict(obj) converts to a plain dict, and replace(obj, x=2) copies with a change. Reach for Pydantic instead when the data comes from outside and needs validating.

Use [[] for _ in range(n)] whenever the element is mutable. [0] * n and [None] * n are safe and are the normal way to preallocate. The same trap applies to dict.fromkeys(keys, []) — every key shares one list.

list(a) or a[:] for a shallow copy, copy.deepcopy(a) when the contents are nested and you need them independent too. Deep copies are slow, so prefer building new data over copying and mutating. Passing a list to a function that mutates it changes yours — there is no readonly.

The i=i default-argument trick is the standard fix. functools.partial(f, i) does the same thing more explicitly. It matters most when building callbacks or handlers in a loop — the exact situation where the bug is hardest to spot.

If you need it twice, items = list(gen) first. Watch for it when passing a generator to two functions, or calling sum() then looping. itertools.tee splits one into several, but it buffers, so list() is usually simpler and clearer.

Copy what you need inside the block: message = str(e). You get str(e) for the message, e.args for the raw arguments, and type(e).__name__ for the class name. traceback.format_exc() gives the whole formatted traceback as a string, which is what you usually want in a log.

Tuples are hashable, so use one as a dict key or set member when you need a composite. They are also what a function returns for multiple values. namedtuple or a frozen dataclass is better once the fields have meaning — point.x beats point[0].

Most useful in a while reading loop — while (chunk := f.read(8192)): — and in comprehensions to avoid computing twice: [y for x in xs if (y := f(x)) is not None]. Keep it to those; a walrus in ordinary code usually just hides an assignment.

Field(default=..., description=..., ge=0, max_length=100) adds constraints and docs. model_validate(some_dict) builds from a dict, model_validate_json(text) from JSON. Nested models just work — declare a field as another model and it validates all the way down. This is the whole reason annotations are worth writing.

e.errors() gives a structured list — field location, message, input value — which is what you turn into an API response. FastAPI does exactly that automatically and returns a 422. Use @field_validator for a rule the type system cannot express, and model_config = ConfigDict(extra="forbid") to reject unknown keys.

Catch anything with except Exception as e: — that covers every normal error. A bare except: also swallows Ctrl-C and SystemExit, so avoid it. Several types: except (ValueError, KeyError) as e:. Your own: class ConfigError(Exception): pass — subclass Exception, and that is the whole definition. Re-raise the current one with a bare raise. The ones you will meet most: ValueError, TypeError, KeyError, IndexError, AttributeError, FileNotFoundError, ZeroDivisionError, TimeoutError. Catch the narrowest that fits.

Order is try → except → else → finally. Keep the try block down to the one line that can fail and put the follow-up in else, so you never catch an exception from the wrong statement. contextlib.suppress(FileNotFoundError) is the tidy form of try/except/pass.

Subclass Exception, not BaseException. Give your errors a common base — class AppError(Exception) with class ConfigError(AppError) — so callers can catch broadly or narrowly. raise X from e keeps the cause; raise X from None deliberately hides it when the original would only confuse.

with open(path) as f: is the everyday case — it closes even if you raise. Several at once: with open(a) as f, open(b) as g:. Write your own quickly with @contextlib.contextmanager on a generator that yields once. contextlib.suppress and tempfile.TemporaryDirectory are the two you will reach for soonest.

asyncio.gather(*tasks) runs them concurrently; add return_exceptions=True to collect failures instead of aborting. asyncio.wait_for(coro, timeout=5) bounds one. Use async with for clients and async for over streams. The rule that catches everyone: one blocking call inside an async function stalls the whole loop — use the async library, or asyncio.to_thread(fn).

A function is a generator function if yield appears anywhere in its body — even in a branch that never runs. That is why adding one yield to an existing function silently changes what callers get back. You can have both: return value inside a generator sets StopIteration.value, which yield from picks up but a plain for loop ignores.

next(gen) pulls one value; next(gen, default) avoids StopIteration at the end. A for loop calls next for you and stops on StopIteration. Laziness is the point: you can wrap an infinite source and take only what you need with itertools.islice(gen, 10).

Because the frame is kept alive, a generator is a cheap alternative to a small class with instance state. Add cleanup with try/finally around the yield — the finally runs when the generator is closed or garbage-collected, which is how @contextlib.contextmanager builds a with block out of a generator.

yield from other_generator() delegates: it forwards every value and is how you compose generators into a pipeline. gen.close() stops one early, and gen.throw(exc) raises inside it — both rarely needed, but they explain why a generator can have a finally that still runs.

async for needs an async generator; a normal for over one raises. Comprehensions work too: [x async for x in ticks(3)]. contextlib.aclosing(gen) guarantees cleanup if you break out early. The rule that bites: one blocking call inside the loop stalls the whole event loop — use the async client, or asyncio.to_thread.

Real streams do not split on message boundaries, so a line can arrive in two pieces — buffer until you see the delimiter rather than parsing whatever the last read gave you. httpx's response.aiter_lines() handles that for you; aiter_bytes() does not. Never json.loads a whole NDJSON body: it is not valid JSON as a document.

The full format also has event:, id: and retry: lines, and a leading : marks a comment used as a keep-alive. Browsers have EventSource built in, but it is GET-only and cannot send a JSON body — which is why this app reads the stream with fetch and a reader instead. Frames can split across reads, so buffer on \n\n.

In the real version each step is separated: the transport yields lines, a parser turns lines into typed chunks, and the route wraps chunks in SSE frames. Keeping them apart is what makes the parser testable without a network — feed it a list of strings. Add cancellation with an AbortSignal on the client and it stops mid-stream.

Imports work here, so anything in the standard library is available. A few third-party packages load on demand too — import pydantic in a block and it will be fetched before the code runs.