PCPP1 key terms

A class whose instances are themselves classes. It controls how a class object is created and can inject or modify methods and attributes at class-creation time, most often by subclassing type.

A classmethod-like hook defined on a parent class that runs whenever a subclass is created. It lets a base class validate or configure subclasses without writing a custom metaclass.

A class that cannot be instantiated until its abstract methods are overridden. Built with the abc module, it documents an interface and enforces implementation through the ABCMeta metaclass and @abstractmethod.

A decorator marking a method that subclasses must override. Instantiating a class that still has unimplemented abstract methods raises TypeError at runtime.

A class registered with an abstract base class via register() or subclasshook so that isinstance and issubclass report it as a subclass without inheritance. No methods are actually inherited.

A classmethod on an abstract base class that lets issubclass decide membership structurally, for example by checking for a particular method name, instead of relying on explicit registration.

The linearized order Python uses to look up attributes across a class's inheritance graph. Computed by the C3 algorithm and exposed as the mro attribute; it resolves diamond inheritance deterministically.

A built-in returning a proxy that delegates attribute lookup to the next class in the method resolution order. In cooperative multiple inheritance it forwards calls along the chain rather than jumping to a fixed parent.

A design pattern where each class in a hierarchy calls super() with matching signatures so every sibling's method runs exactly once, following the method resolution order.

An object defining get, set, or delete that customizes attribute access on a class. Functions, properties, classmethods, and staticmethods are all descriptors.

A descriptor that defines set or delete, giving it priority over entries in the instance dict during attribute lookup. Functions are non-data descriptors because they only define get.

A hook called automatically on every descriptor in a class body when the owning class is created, receiving the owner class and the attribute name. Useful for caching the attribute name.

A built-in descriptor that turns getter, setter, and deleter methods into managed attributes. Accessing the attribute invokes the getter, so validation and computed values stay transparent to callers.

A class attribute listing permitted instance attribute names, replacing the per-instance dict with fixed storage. It reduces memory use and blocks assignment of undeclared attributes.

The namespace dictionary holding an object's writable attributes. Instances normally have one; classes use it for their own attributes, and it is absent on instances of classes defining slots.

A special method with double leading and trailing underscores, such as len or add, invoked implicitly by Python syntax and built-in functions rather than called directly by name.

Implementing dunder methods like add, eq, or lt so that operators and comparisons work on user-defined types with intuitive syntax and predictable semantics.

A class decorator that fills in the remaining rich comparison methods (le, gt, ge) once a class defines eq plus one of lt, le, gt, or ge.

A dunder method that makes instances callable like functions. Defining it lets an object hold configuration state while still being invoked with parentheses.

A nested function that captures and retains variables from its enclosing scope after that scope has finished executing. Captured names are exposed through closure and read via nonlocal.

A statement letting a nested function rebind a name from an enclosing function scope instead of creating a new local variable. It does not reach module or global scope.

A callable applied to a class definition with the @ syntax that receives the class object and returns a replacement, often used to add methods or register classes in a registry.

The official style guide for Python code, covering naming conventions, indentation, imports, blank lines, and line length. Compliance is checked by linters such as flake8 or ruff.

The convention for docstrings: a one-line summary ending with a period, a blank line, then details for multi-line docstrings. It defines where docstrings belong and how tools read them.

A string literal placed as the first statement of a module, class, or function, stored in doc. It documents intent and is extracted by help() and documentation generators.

An annotation on a parameter, return value, or variable describing the expected type, such as list[int]. Hints are not enforced at runtime; static checkers and tools read them.

A static type checker that analyzes annotations without running the code, reporting incompatible assignments and calls. It supports gradual typing, so unannotated code is largely ignored.

A typing construct meaning a value is either the given type or None. Modern syntax writes it as X | None; it flags callers to handle the absent-value case.

A base class for defining structural interfaces. A class satisfies a Protocol by having matching methods and attributes, without inheriting from it, enabling static duck typing.

A style where an object's suitability depends on the methods and attributes it actually has, not on its declared type. Python resolves such behavior at runtime.

Easier to Ask Forgiveness than Permission: a Python idiom of attempting an operation and handling the resulting exception, rather than pre-checking conditions as in LBYL style.

A compound statement where except handles matching exceptions, else runs only when no exception occurred, and finally always runs for cleanup. Order matters and bare except clauses hide bugs.

An object implementing enter and exit so it can be used in a with statement. It guarantees setup and teardown, such as closing files or releasing locks, even when exceptions occur.

A decorator turning a generator function into a context manager. Code before yield is setup, the yielded value becomes the as-target, and code after yield is teardown.

A tool that statically inspects source code for style violations, unused imports, and suspicious constructs without executing it. Common Python examples are ruff, flake8, and pylint.

A tool that rewrites source code to a consistent layout automatically, such as black or ruff format. It removes debates over spacing while leaving semantics unchanged.

The standard-library module for creating isolated environments with their own interpreter link and site-packages, so project dependencies do not clash across projects.

A plain-text file listing package specifications, optionally pinned with ==, that pip install -r reads to reproduce an environment. Pinning versions makes builds reproducible.

Python's bundled GUI toolkit wrapping Tcl/Tk. It provides widgets, geometry managers, and an event loop through mainloop(), requiring no third-party installation.

The blocking call that starts a GUI application's event loop, dispatching user input and redraw events until the window closes. Code after it runs only after the loop exits.

A mechanism deciding widget size and placement inside a container. Tkinter offers pack, grid, and place; mixing pack and grid in one container causes layout errors.

Associating a callback with a user action, such as a click or keypress, using bind() or the command option. The callback runs later, inside the event loop.

A function passed to another component to be invoked later when something happens, such as a button press or a completed request. It should return quickly to avoid freezing the UI.

A visible GUI component such as a button, label, entry, or frame. Widgets are arranged in a parent-child hierarchy and configured through options like text, width, and command.

An architectural style for networked APIs using stateless requests, resource-oriented URLs, and standard HTTP methods. Representations are typically JSON, and servers should not rely on client session state.

The verb in a request indicating intent: GET retrieves, POST creates, PUT replaces, PATCH partially updates, and DELETE removes. Choosing the right method keeps APIs predictable.

A request that produces the same server state whether sent once or many times. GET, PUT, and DELETE are idempotent; POST usually is not, which matters for safe retries.

A three-digit number in an HTTP response summarizing the outcome, such as 200 success, 201 created, 404 not found, or 500 server error. Clients branch on these values.

An object that persists settings across requests, including headers, cookies, and connection pooling. Reusing one session speeds up repeated calls to the same host.

A popular third-party HTTP client offering simple functions like get and post. Responses expose status_code, headers, text, and a json() method for parsing JSON bodies.

A response method that raises an exception when the status code indicates a client or server error. It replaces manual status checks and surfaces failed calls immediately.

A limit on how long a client waits for a connection or response. Always setting it prevents a program from hanging indefinitely when a server stops responding.

A lightweight text data format of objects, arrays, strings, numbers, booleans, and null. Python maps it to dicts, lists, and primitives via the json module.

Converting a transferred representation such as JSON text into native objects. In Python, json.loads produces dicts and lists; the result should be validated before use.

A credential string sent with requests, typically in an Authorization header, proving the caller's identity. Bearer tokens should be stored securely and never committed to source control.

Splitting a large result set into pages using query parameters like limit and offset or a cursor. Clients must follow links or cursors until no further records remain.

A key-value pair appended to a URL after a question mark, used for filtering, sorting, or paging. The requests library accepts them as a params dictionary.

Resending a failed request after increasing delays, often with jitter, to handle transient errors. It should be limited to idempotent operations or those with safe retry semantics.