Glossary

alias = original doesn’t copy original — it gives the same object a second name. For an immutable value this is invisible, since nothing can change it anyway. For a mutable one (a list, dict, or set), it means alias.append(x) and original.append(x) do the exact same thing. original.copy() (or list(original), or a full slice original[:]) creates an independent object instead, breaking the alias.

An assertion documents an invariant the code assumes is always true — “this list is never empty here,” “this value was already validated.” It’s the wrong tool for rejecting bad user input: python -O strips every assert statement from a program entirely, so validation that must always run belongs in an explicit if ...: raise ValueError(...) instead.

Thinking of a variable as a labeled box that holds a value leads to wrong predictions in Python. The accurate picture: a name is a label attached to an object that lives independently of the name. Assignment moves the label, not the object — a = b attaches the label a to whatever object b was already labeling, and does not duplicate anything.

len() on a str counts code points, which usually matches “characters” for plain text but can diverge for accented letters built from a combining mark, emoji with modifiers, or other symbols assembled from more than one code point — a case this site doesn’t dwell on early, but worth knowing exists before trusting len() as a stand-in for “how many characters will this look like.”

A Library that has a list of Book objects (composition) is more flexible than a Library that somehow is a Book (inheritance) — the relationship here is clearly “holds,” not “is a kind of.” Composition is usually the safer default; inheritance earns its place when there’s a genuine, stable is-a relationship the whole design depends on.

A comprehension is an expression, not a statement — it produces a new collection as a value, rather than a loop that mutates one you already built. [name for name, qty in pairs if qty < 10] reads as “the name, for each (name, qty) pair, where qty is under 10” — the same result as an explicit for loop that appends to a list, written more compactly once that longer form is already familiar.

with open(path) as f: is the example almost everyone meets first: opening is the setup, closing is the cleanup, and with guarantees the file gets closed when the block ends — even if the code inside raised an exception partway through.

A function that calls .read() on its argument works with an open file, a network response, or any other object exposing a .read() method — it never checks isinstance(arg, SomeSpecificType) first. Python favors this over requiring a specific base class, which is also why protocols like __repr__/__eq__ and the iterator protocol matter so much: they’re exactly the “right methods” duck typing checks for.

A Python str has no encoding — it’s already a sequence of code points. An encoding only enters the picture at the boundary where text becomes bytes (str.encode(encoding)) or bytes become text again (bytes.decode(encoding)). Using the wrong encoding at either boundary is what produces garbled text or a UnicodeDecodeError.

os.environ["API_KEY"] (or os.environ.get("API_KEY") for an optional one) reads a value the program’s environment provides rather than one written into the source code — the standard way to keep secrets (API keys, database passwords) and per-deployment configuration out of version control entirely.

pytest’s built-in tmp_path fixture (a parameter named tmp_path on a test function) hands the test a fresh, empty temporary directory, deleted automatically afterward — the standard way to test file-writing code without leaving files behind or depending on a real, shared location on disk.

A test asserting on datetime.now(), an unseeded random number, a live network call, or state left over from a different test are the classic causes. A deterministic test controls every source of variation explicitly (a fixed/injected time, a seeded random generator, a fake instead of a real network call) so the same code always produces the same test result.

Checking for an invalid or edge-case input first and returning immediately — rather than wrapping the “normal” logic in an if valid: ... block — keeps the common path at the outer indentation level, which stays readable as a function grows.

Two names can be equal (==, same value) without being identical (is, the same object) — [1, 2] == [1, 2] is True even though they’re two separate list objects. Identity is strictly stronger than equality: identical objects are always equal, but equal objects are not always identical.

When this site says “the interpreter,” it means the running python process itself — most commonly CPython, the reference implementation you get from python.org. The interpreter compiles source to an internal bytecode form and then executes that bytecode; “interpreted” describes the absence of a separate ahead-of-time compile-to-native-binary step that a language like C requires, not a claim that Python skips compilation entirely.

The standard library’s logging module supports severity levels (debug, info, warning, error, critical) that can be filtered without editing the code that emits them, and — unlike print — writes to stderr by default, keeping diagnostic noise separate from a program’s actual output on stdout.

A mutable object (a list, dict, or set, or most custom objects) can be changed in place — my_list.append(x) modifies the same object every other name bound to it also sees. An immutable object (an int, float, str, tuple, or frozenset) can never change after creation; an operation that looks like it changes one, such as s = s + "!", actually builds a new object and rebinds the name to it, leaving the original untouched.

math.pi and a local variable named pi never collide, because math’s namespace and the current function’s local namespace are separate mappings — the module name (math.) is what selects which namespace to look pi up in. Every module is itself a namespace, which is exactly why importing one doesn’t dump all its names directly into the importer’s own namespace.

Starting python with no file argument opens the REPL, recognizable by its >>> prompt. It’s the fastest way to check what a short expression does, but it evaluates one statement (or block) at a time and doesn’t save anything to disk — code meant to be run again later belongs in a script file instead.

Python looks up a name using the LEGB order: Local (the current function), Enclosing (an outer function, for a nested one), Global (the module), then Built-in (len, print, and friends). A name assigned inside a function is local by default; the global keyword (as increment() uses in this lesson’s example) explicitly opts into reading and writing a module-level name instead.

A pure function’s output depends only on its arguments, and calling it changes nothing else about the program’s state — calling it twice with the same arguments always gives the same result. Pure functions are easier to test and reason about in isolation; side effects are often necessary (printing output, persisting data) but worth keeping deliberate and visible rather than incidental.

A traceback lists frames from oldest call to most recent, and — this is the part worth internalizing early — the most useful information is almost always at the bottom: the last line names the exception type and message, and the line just above it points at the exact source line where it was raised. Reading a traceback bottom-up, rather than top-down, is the fastest path to the actual cause.

0, 0.0, None, False, and every empty collection ("", [], {}, set()) are falsy; nearly everything else is truthy. if items: is a common, idiomatic way to check “is this collection non-empty” without spelling out if len(items) > 0:.

Created with python -m venv .venv (or uv sync, which does the equivalent automatically from a pyproject.toml), a virtual environment means pip install (or uv add) affects only that one project — never the system-wide Python, and never another project’s own dependencies.