Python Glossary: 100+ Terms Explained — Reference

A reference dictionary of Python terms, from "argument" to "yield". Bookmark this page. Each definition is one paragraph or shorter. Where there's a deeper lesson, the term links to it.

Jump: A · B · C · D · E · F · G · H · I · J · K · L · M · N · O · P · Q · R · S · T · U · V · W · Y

A

ABC (Abstract Base Class): A class that cannot be instantiated directly and defines an interface subclasses must implement. Defined via the abc module with @abstractmethod. Useful for enforcing a contract across a family of classes. See OOP.

__all__: A module-level list of names that defines what from module import * exports. Also signals the public API of a module to readers and linters. See Modules.

Annotation: A piece of metadata attached to a variable, parameter, or return value, written after a colon: x: int = 5. Annotations are stored in __annotations__ and used by type checkers like mypy, but Python itself ignores them at runtime. See Type hints.

Argument: A value passed to a function when it is called. print("hi") calls print with the argument "hi". Contrast with parameter (the name in the function's def line). See Functions.

Async / asynchronous: Code that pauses at await points so other tasks can run on the same thread. Python's asyncio module provides the event loop that schedules coroutines. See Async / Await.

Attribute: A value attached to an object, accessed with dot notation: obj.x. Methods are attributes that can be called. Attributes can live on the instance, the class, or be looked up via descriptors. See OOP.

B

Backreference (regex): A reference to a previously matched group inside the same pattern, written as \1, \2, etc. (\w+) \1 matches a repeated word. See Regex.

BaseException: The root of Python's exception hierarchy. Most user exceptions inherit from Exception, not BaseException, because SystemExit and KeyboardInterrupt also derive from BaseException and should rarely be caught. See Exceptions.

bool(): The built-in that converts any value to True or False using truthiness rules. Empty containers, 0, None, and "" are falsy. Everything else is truthy.

Boolean: The type with exactly two values: True and False. A subclass of int, so True + 1 == 2 and sum([True, True, False]) == 2.

Built-in: A name available without any import, such as len, print, range, or Exception. Defined in the builtins module, which Python searches after the local, enclosing and global scopes.

Bytecode: The compact, platform-independent instructions Python compiles your source to before the interpreter runs it. Cached on disk as .pyc files in __pycache__/.

Bytes: An immutable sequence of integers in 0..255, written b"hello". Used for binary data and network I/O. Contrast with str, which is a sequence of Unicode code points. Encode with .encode("utf-8") to convert between them.

C

Cache (functools): A way to memoise expensive function results using @functools.cache or @functools.lru_cache(maxsize=N). The decorated function stores results keyed by its arguments. See Decorators.

Callable: Any object that can be invoked with (). Functions, classes, methods, and instances with a __call__ method are all callable. Check with callable(obj).

ChainMap: A collections class that groups multiple dicts into a single view, searching them in order. Handy for layered configuration (defaults, user, environment). See Collections.

Class: A blueprint for creating objects, defined with class Name:. Instances share the methods and class attributes defined inside. See OOP.

Class attribute: A name bound at class level rather than on an instance. Shared across all instances unless shadowed by an instance attribute of the same name. Mutable class attributes (lists, dicts) are a common bug source. See OOP.

Classmethod: A method that receives the class itself as its first argument instead of an instance. Declared with @classmethod and commonly used for alternative constructors like dict.fromkeys. See OOP.

Closure: A function that remembers variables from the enclosing scope where it was defined, even after that scope has returned. The foundation for decorators and many functional patterns. See Decorators.

Comprehension: A concise expression that builds a list, set, dict, or generator by iterating in a single line: [x*x for x in nums if x > 0]. See Comprehensions.

Conditional: A construct that runs code only when a test is true: if, elif, else. Also covers the conditional expression a if cond else b. See Conditionals.

Context manager: An object that defines __enter__ and __exit__ so it can be used with with. Guarantees cleanup (closing files, releasing locks) even on exceptions. See Context managers.

Coroutine: A function defined with async def. Calling it returns a coroutine object. You must await it (or schedule it with the event loop) to make it run. See Async / Await.

Counter: A collections dict subclass that counts hashable items: Counter("mississippi") gives {'i': 4, 's': 4, ...}. Has most_common(n) and supports arithmetic. See Collections.

Cython: A separate language and compiler that translates Python-like code into C extensions for speed. Not part of standard Python, but a common option when pure Python is too slow.

D

Dataclass: A class decorated with @dataclass that auto-generates __init__, __repr__, and __eq__ from class-level annotations. Removes the boilerplate of plain data containers. See Dataclasses.

datetime: The standard module for working with dates, times, and durations. Key types: date, time, datetime, timedelta. See Datetime.

Decorator: A callable that wraps another callable to add behaviour, applied with @decorator syntax above a def. Common uses: caching, logging, registration, access control. See Decorators.

deepcopy: copy.deepcopy(obj) recursively copies an object and every object it references. Use it when a shallow copy would share mutable inner objects (such as nested lists) that you want to keep separate.

Default argument: A parameter with a fallback value used when the caller omits it: def f(x=10). Never use a mutable default like []: it is created once and reused across calls. See Functions.

defaultdict: A collections dict that creates a default value for missing keys via a factory function. defaultdict(list) returns [] for any new key. See Collections.

Deque: collections.deque, a double-ended queue with O(1) appends and pops from either end. Use it instead of a list when you need a FIFO queue. See Collections.

Descriptor: An object that customises attribute access by defining __get__, __set__, or __delete__. Properties, methods, and classmethods are all built on descriptors. See Descriptors.

Dict: Built-in mapping from hashable keys to arbitrary values: {"a": 1, "b": 2}. Preserves insertion order since Python 3.7. See Dictionaries.

Docstring: A string literal placed as the first statement inside a module, class, or function. Accessible via obj.__doc__ and shown by help(). Use triple quotes.

Duck typing: "If it walks like a duck and quacks like a duck, it's a duck." Python cares about whether an object supports the operations you need, not what class it belongs to.

Dunder method: A method whose name begins and ends with double underscores, like __init__, __len__, __iter__. They connect your class to language syntax (operators, with, iteration). See OOP.

Dynamic typing: Variables are bound to objects, not to types, so the same name can hold an int then a str later. Type checking happens at runtime when an operation is attempted.

E

EAFP: "Easier to Ask Forgiveness than Permission." A Pythonic style that tries an operation and catches the exception if it fails, instead of pre-checking. Contrast with LBYL. See Exceptions.

Encoding: A mapping between text characters and bytes. UTF-8 is the most common encoding and the right choice in almost every case. Legacy systems may use latin-1, cp1252, or others.

Enum: A class from the enum module whose members are named constants. class Colour(Enum): RED = 1; BLUE = 2. Members are singletons and comparable by identity.

Environment variable: A key-value pair set in the OS environment, read in Python with os.environ["NAME"] or os.getenv("NAME", default). Standard place for secrets and per-environment config. See Env config.

eval: Built-in that executes a string as a Python expression. Dangerous on untrusted input. Use ast.literal_eval for safe parsing of literals.

ExceptionGroup: A container for multiple exceptions raised together, introduced in Python 3.11. Caught with except* syntax. Used by asyncio.TaskGroup.

except: The clause that catches an exception raised inside a try block. Can be qualified by type and bound to a name: except ValueError as e:. See Exceptions.

Exception: An object representing an error or unusual condition, raised with raise and caught with try/except. The base class for normal user exceptions. See Exceptions basics.

ExitStack: A contextlib helper that combines multiple context managers dynamically. Useful when the number of resources is not known at write time. See Context managers.

Expression: Any piece of code that evaluates to a value: 2 + 2, f(x), [a for a in xs]. Contrast with a statement, which performs an action.

extend (list method): list.extend(iterable) appends every item from the iterable to the list in place. Differs from append, which adds the iterable itself as one element.

F

f-string: A formatted string literal prefixed with f, where {expr} is replaced by the value of expr: f"x = {x:.2f}". The fastest and clearest formatting tool in modern Python. See f-strings.

Filter: The built-in filter(pred, iterable) keeps items for which pred(item) is true. A comprehension [x for x in xs if pred(x)] is usually clearer.

Finally: A try clause that always runs, exception or not. Used for cleanup that must happen even on failure. Largely superseded by context managers. See Exceptions.

First-class function: In Python, functions are objects you can pass as arguments, return from other functions, store in lists, and bind to names. This enables decorators, callbacks, and functional patterns.

Float: A 64-bit IEEE 754 floating-point number. Subject to rounding, so 0.1 + 0.2 != 0.3. Use decimal.Decimal for money.

for-loop: A statement that iterates over any iterable: for item in iterable: .... Python's for is foreach. There is no C-style three-part form. See Loops.

Frozenset: An immutable, hashable version of set. Useful as a dict key or set member. See Sets.

Function: A reusable block of code defined with def name(params): ... that may return a value. Calling without return yields None. See Functions.

functools: Standard library module of higher-order tools: cache, lru_cache, partial, reduce, wraps, singledispatch. See Decorators.

Future (concurrent): An object representing the eventual result of an asynchronous operation, returned by executors in concurrent.futures and awaitable in asyncio.

G

Generator: A function that uses yield to produce a sequence of values lazily. Each call to next() resumes execution until the next yield. Saves memory for large or infinite sequences. See Generators.

Generator expression: A lazy comprehension written with parentheses: (x*x for x in xs). Builds no list and yields values one at a time. See Generators.

Generic: A type parameterised by other types, like list[int] or dict[str, User]. Defined with Generic[T] or, in modern syntax, class Stack[T]:. See Type hints.

GIL (Global Interpreter Lock): A mutex in CPython that allows only one thread to execute Python bytecode at a time. Threads still help with I/O-bound work. For CPU-bound parallelism, use processes or release the GIL in C extensions. See Multiprocessing.

global: A statement that binds a name in the module-level scope from inside a function. Required only when you need to assign to a global, not to read one. See Functions.

groupby: itertools.groupby(iterable, key) yields runs of consecutive items sharing a key. Sort first if you want global grouping. See itertools.

H

Hash: An integer derived from an object via hash(obj). Used by dicts and sets to locate entries. Two equal objects must have equal hashes.

Hashable: An object is hashable if it has a stable __hash__ and supports ==. All immutable built-ins (int, str, tuple of hashables, frozenset) are hashable, but lists and dicts are not.

Heap (heapq): A binary heap implemented on top of a list, exposed by the heapq module. heappush and heappop are O(log n), and heappop always returns the smallest item. The basis for priority queues.

I

Identity (is): a is b is true when a and b are the same object in memory, not merely equal. Use is for None, True, False. Use == for value comparison.

Immutable: An object whose value cannot change after creation: int, float, str, tuple, frozenset, bytes. Operations that seem to modify them create new objects.

Import: A statement that loads another module and binds names from it. import x, from x import y, from x import y as z. See Modules.

Indentation: Leading whitespace that defines block structure in Python. Four spaces per level is the standard. Mixing tabs and spaces is a syntax error.

Index: The integer position of an item in a sequence, starting at 0. Negative indices count from the end: s[-1] is the last item.

IndexError: Raised when a sequence index is out of range, e.g. [1, 2][5]. See the IndexError reference.

Inheritance: Defining a class that reuses and extends another via class Child(Parent):. The child receives the parent's attributes and methods. See Inheritance.

__init__: The initialiser method called right after a new instance is created. Sets up instance attributes and does not return a value. See OOP.

__init_subclass__: A class method on a parent that runs each time a subclass is defined. Lets a base class customise or validate its descendants without a metaclass.

Instance: A specific object produced by calling a class: c = Car() creates an instance of Car. See OOP.

int: Built-in arbitrary-precision integer type. It never overflows, so 2**1000 is an ordinary int. Booleans are a subclass.

Interpreter: The program that reads your Python source, compiles it to bytecode, and executes it. The reference implementation is CPython. Alternatives include PyPy and GraalPy.

Iterable: Any object you can loop over with for. Internally, iter(obj) returns an iterator. Lists, tuples, dicts, sets, strings, files, and generators are all iterables.

Iterator: An object with a __next__ method that yields the next item or raises StopIteration. Every iterator is also iterable (its __iter__ returns itself).

itertools: Standard library module of lazy iterator-building blocks: chain, cycle, repeat, count, groupby, product, permutations, combinations. See itertools.

J

JSON: JavaScript Object Notation, a text format for exchanging structured data. Maps cleanly to Python dicts, lists, strings, numbers, booleans, and None. See CSV / JSON.

json.dumps / json.loads: dumps serialises a Python object to a JSON string, and loads parses a JSON string back. dump / load work with file objects. See CSV / JSON.

K

KeyError: Raised when a dict lookup fails: {}["missing"]. See the KeyError reference.

Keyword (reserved word): A name reserved by the language grammar and unusable as an identifier: if, else, for, def, class, lambda, import, and so on. Listed in keyword.kwlist.

Keyword argument: An argument passed by name: f(x=1, y=2). The order doesn't have to match the function signature, and the call is easier to read. See Functions.

L

Lambda: An anonymous, single-expression function: lambda x: x + 1. Useful for short callbacks. Prefer def when the logic grows. See Lambda.

LEGB rule: Python's name lookup order: Local, Enclosing, Global, Built-in. Each unqualified name is searched in that order, and the first match wins.

List: A mutable, ordered sequence: [1, 2, 3]. Supports indexing, slicing, append, and arbitrary item types. See Lists.

List comprehension: A comprehension that produces a list: [x*2 for x in xs]. See Comprehensions.

Literal: A value written directly in source: 42, "hi", [1, 2], None. The compiler emits the value without any function call.

Logging: Producing structured records of program events via the logging module. Preferred over print for any code beyond a script. See Logging.

lru_cache: @functools.lru_cache(maxsize=N) decorator that caches function results with a least-recently-used eviction policy. Use @cache for unbounded caching. See Decorators.

M

Map: The built-in map(func, iterable) lazily applies func to each item. A comprehension [func(x) for x in xs] is usually clearer.

Memoization: Caching a function's results keyed by its arguments so repeated calls are O(1). Implemented in Python with @functools.cache or @lru_cache.

Metaclass: The class of a class. Controls how classes themselves are created. type is the default metaclass. Rarely needed. Use decorators or __init_subclass__ first. See Metaclasses.

Method: A function defined inside a class. When accessed on an instance, the instance is automatically bound as the first argument (self). See OOP.

Method resolution order (MRO): The linear order Python searches base classes during attribute lookup, computed by the C3 algorithm. Inspect with Cls.__mro__. See Inheritance.

Mixin: A class designed to be combined with others via multiple inheritance to add a focused capability (e.g. SerialisableMixin). Never instantiated alone. See Inheritance.

Module: A single .py file that can be imported. Its top-level names are what other code can import from it. See Modules.

Mutable: An object whose state can change in place: list, dict, set, most user classes. Mutability has implications for default arguments, hashing, and aliasing.

N

Name: An identifier bound to an object via assignment, def, class, or import. Python names are references, not boxes that hold values.

NameError: Raised when a name is used before being defined in any reachable scope. See the NameError reference.

namedtuple: collections.namedtuple("Point", ["x", "y"]) creates a tuple subclass with named fields. Modern alternative: @dataclass(frozen=True) or typing.NamedTuple. See Collections.

None: The singleton sentinel returned by functions that have no other value to return, and the canonical "missing" marker. Compare with is None.

NoneType: The type of None. type(None) is NoneType. There is exactly one instance.

nonlocal: A statement that binds a name in the nearest enclosing function scope (but not module scope) from inside a nested function. Required to assign to such a name. See Functions.

numpy: Third-party library for fast numerical arrays and linear algebra. Foundation of the scientific Python stack. Install with pip install numpy.

O

Object: The base class of every class in Python. Every value, including functions and classes, is an object with attributes and a type.

OOP (Object-Oriented Programming): A style that bundles state and behaviour into classes and instances, using inheritance, encapsulation, and polymorphism. See OOP.

Optional: Optional[T] is shorthand for T | None, signalling that a value may be missing. Modern syntax prefers T | None. See Type hints.

OrderedDict: A collections dict subclass that historically preserved insertion order. It is now mostly redundant since plain dict does the same in 3.7+. Still useful for move_to_end and order-sensitive equality.

Override: Defining a method in a subclass with the same name as one in a parent, replacing the parent's behaviour. Use super().method() to delegate. See Inheritance.

P

Package: A directory of modules with an __init__.py (or a namespace package without one). Imported as a dotted path: package.subpackage.module. See Packaging.

Parameter: A name listed in a function's def line that receives an argument when the function is called. See Functions.

pathlib: Standard library module providing the Path class for filesystem paths as objects with methods like .read_text(), .exists(), and .glob(). Preferred over raw os.path strings. See File I/O.

PEP: Python Enhancement Proposal, a numbered document describing a language change or convention. PEP 8 is the style guide, and PEP 20 is the Zen of Python.

pickle: Standard module that serialises Python objects to bytes for storage or transport. Never unpickle untrusted data: it can execute arbitrary code.

pip: Python's package installer, used to fetch third-party libraries from PyPI: pip install requests. See pip and stdlib.

Polymorphism: The ability for different types to be used through a shared interface. In Python this is usually duck typing: any object with the right methods works. See OOP.

Property: A class attribute defined with @property that runs a method on access, letting computed values look like plain attributes. Pair with @x.setter to allow assignment. See OOP.

Pure function: A function whose output depends only on its inputs and that produces no side effects. Easier to test, reason about, and cache.

Pyenv: A third-party tool for installing and switching between multiple Python versions per shell or project. Not the same as venv.

pytest: The de facto third-party testing framework. Tests are plain functions whose names start with test_, and a plain assert is enough, with no special API. See Testing.

Q

Queue (queue module): Thread-safe FIFO, LIFO, and priority queues for producer-consumer patterns. Different from collections.deque, which is faster but has no blocking get or put for making threads wait.

R

Raise: The statement that throws an exception: raise ValueError("bad"). Use raise ... from e to chain causes. See Exceptions.

range: Built-in that lazily produces a sequence of integers: range(stop), range(start, stop), range(start, stop, step). It uses little memory, because values are computed when they are needed.

Recursion: A function that calls itself, usually with a smaller input, until it hits a base case. CPython's default recursion limit is around 1000. Raise it with sys.setrecursionlimit if you must.

Regular expression (regex): A pattern language for matching and extracting text, accessed in Python via the re module. See Regex.

REPL: Read-Eval-Print Loop, the interactive Python shell you get by running python with no arguments. Useful for trying things out. python -i script.py runs a file and then opens the REPL.

Repr (__repr__): A dunder method returning an unambiguous, developer-facing string for an object. Ideally a valid expression that recreates it. str() uses it when __str__ is not defined.

Return: The statement that exits a function and supplies a value. A function with no return (or a bare return) yields None. See Functions.

S

Scope: The region of code where a name is visible. Python has four (LEGB): local, enclosing, global, built-in.

Self: The conventional name for the first parameter of an instance method, bound to the instance the method was called on. Not a keyword: any name works, but use self. See OOP.

Sequence: An ordered, indexable collection: list, tuple, str, bytes, range. Supports len, indexing, slicing, and iteration.

Set: A mutable, unordered collection of unique hashable items: {1, 2, 3}. Fast membership tests and set algebra (|, &, -, ^). See Sets.

Set comprehension: A comprehension that builds a set: {x % 7 for x in xs}. See Comprehensions.

Setter: A method paired with a property that runs on assignment: @x.setter. Lets you validate or compute on write. See OOP.

Side effect: Any change a function makes beyond returning a value: mutating an argument, writing to a file, printing. Pure functions have none.

Singleton: A class with exactly one instance. None, True, False, and Ellipsis are language-level singletons. If you want a singleton in your own code, a module is usually the better choice.

Slice: A way to extract or assign a sub-range of a sequence: s[start:stop:step]. Negative indices and omitted bounds are allowed. See Slicing cheat sheet.

Slot (__slots__): A class attribute listing the only instance attributes allowed. Replaces the per-instance __dict__ with a fixed array, saving memory and forbidding ad-hoc attributes.

Sorted vs sort: sorted(iterable) returns a new sorted list and works on any iterable. list.sort() sorts in place and returns None. Both accept key and reverse.

Standard library: The set of modules that ship with Python: os, sys, re, json, datetime, collections, itertools, and many more. No pip install needed. See pip and stdlib.

Statement: A unit of execution that performs an action: assignment, if, for, def, return, import. Contrast with expression.

staticmethod: A method declared with @staticmethod that receives neither self nor cls. It is a plain function that lives inside the class's namespace. See OOP.

String: An immutable sequence of Unicode characters, written "text" or 'text'. Supports slicing, formatting, and many methods. See Strings.

Stub: A .pyi file containing type hints for code (often third-party or C) that has none inline. Loaded by type checkers, ignored at runtime.

super: A built-in that returns a proxy delegating attribute lookups to the parent classes per the MRO. Use super().__init__(...) to call a parent's initialiser. See Inheritance.

T

Ternary: Python's conditional expression: value_if_true if condition else value_if_false. One line, returns a value. Do not nest deeply.

Truthy / Falsy: How any value behaves in a boolean context. Falsy: False, None, 0, 0.0, "", [], {}, (), set(). Everything else is truthy. Avoid len(x) > 0 when if x: works.

try / except: The statement that runs guarded code in a try block and handles raised exceptions in matching except clauses. Optional else runs on success, and finally always runs. See Exceptions basics.

Tuple: An immutable, ordered sequence: (1, 2, 3). Often used for fixed-size records and as dict keys. The comma makes the tuple: (x) is just x, but (x,) is a one-item tuple. See Tuples.

type: Built-in that returns an object's class: type(3) is int. Also the default metaclass: type(name, bases, dict) creates a new class dynamically.

Type hint: An annotation declaring the expected type of a variable, parameter, or return value. Checked by tools like mypy or pyright, and ignored at runtime. See Type hints.

TypeError: Raised when an operation gets an argument of the wrong type, like "5" + 5 or len(42). See the TypeError concat reference.

TypedDict: A typing construct describing dicts with a fixed set of string keys and per-key value types. Useful for JSON-shaped data. See Type hints.

TypeVar: A placeholder used in generic type hints: T = TypeVar("T") then def first(xs: list[T]) -> T. Modern syntax: def first[T](xs: list[T]) -> T. See Type hints.

U

Unbound: A name with no value in the current scope. Reading it raises NameError. Reading a local name before it has been assigned in that function raises UnboundLocalError. See the UnboundLocalError reference.

Unicode: The character set Python str uses internally. Each character has a code point, and chr and ord convert between characters and integers.

Union (type): A type hint meaning "one of these types": int | str (or Union[int, str] in older code). See Type hints.

unittest: The standard library's xUnit-style test framework. It works, but most new projects prefer pytest because its syntax is simpler. See Testing.

UTF-8: The dominant encoding for Unicode text. ASCII-compatible, variable-width, the default for Python source files and most modern I/O. Always pass encoding="utf-8" when opening text files.

V

ValueError: Raised when an operation receives the right type but an unacceptable value, like int("abc"). See the ValueError reference.

Variable: A name bound to an object. Python variables are references, and assignment never copies. See Variables.

Virtual environment (venv): An isolated Python install with its own site-packages, created by python -m venv .venv. Keeps project dependencies independent. See Virtual environments.

W

Walrus operator: Assignment expression := that binds and returns a value inline: if (n := len(data)) > 10: .... Useful in comprehensions and while conditions. Avoid it when a plain assignment is clearer.

while loop: A statement that repeats a block as long as its condition is true. Best for unknown iteration counts. Prefer for over range for counted loops. See Loops.

with statement: The syntax for using a context manager: with open(p) as f: .... Guarantees cleanup. See Context managers.

wraps (functools): @functools.wraps(func) inside a decorator copies the wrapped function's name, docstring, and metadata onto the wrapper. Always use it when writing decorators. See Decorators.

Y

yield: A statement inside a function that turns it into a generator. Each yield suspends the function, returning a value, and the next next() resumes after it. See Generators.

yield from: Delegates iteration to another iterable from inside a generator: yield from sub_gen(). It passes on values, sent values and the return value automatically.

This page is part of the Reference path. Use it together with the cheat sheets and error references.