| Abstract Base Class | A class using abc.ABC that defines interface contracts with abstract methods subclasses must implement. |
| Argument | A value passed to a function when it is called. |
| Async/Await | Keywords enabling cooperative multitasking: async def defines a coroutine, await suspends it until a result is ready. |
| Bytecode | Compiled intermediate representation of Python source executed by the CPython virtual machine. |
| Class | A blueprint for creating user-defined objects with attributes and methods. |
| Closure | A function that captures and retains variables from its enclosing lexical scope after that scope has exited. |
| Comprehension | Concise syntax for creating sequences, e.g., list comprehensions: [x for x in range(5)]. |
| Context Manager | An object implementing __enter__ and __exit__ that manages resource setup and teardown via the with statement. |
| Coroutine | A function defined with async def that can suspend execution at await points and resume later. |
| CPython | The reference implementation of Python, written in C, that compiles source to bytecode and executes it in a virtual machine. |
| Decorator | A function that modifies the behavior of another function or method using @ syntax. |
| Deepcopy | A copy operation (copy.deepcopy) that recursively duplicates an object and all objects it references. |
| Descriptor | An object with __get__, __set__, or __delete__ methods that intercepts attribute access on class instances. |
| Dictionary | A collection of key-value pairs: {'key': 'value'}. |
| Duck Typing | A typing strategy where an object's suitability is determined by its methods and properties rather than its explicit type. |
| Dunder Methods | Special methods with double-underscore names (e.g., __init__, __repr__) that Python calls implicitly for operator and protocol support. |
| Exception | An error detected during execution that can be handled with try/except. |
| F-String | A string literal prefixed with f that evaluates embedded expressions at runtime: f"{name} is {age}". |
| Function | A block of reusable code defined using the def keyword. |
| Generator | A function that uses yield to produce a sequence of values lazily. |
| Generator Expression | A lazy iterator created with parenthesis syntax: (x*x for x in range(10)). |
| Global Interpreter Lock | A mutex in CPython that allows only one thread to execute Python bytecode at a time, limiting CPU-bound parallelism. |
| Immutable | Describes types that cannot be changed after creation (e.g., tuple, str, int). |
| Import | Statement used to bring modules and their functions into the current namespace. |
| Indentation | Whitespace that defines block structure in Python code. It replaces curly braces used in other languages. |
| Iterable | Any object capable of returning its elements one at a time, e.g., lists, strings, files. |
| Iterator | An object representing a stream of data that implements the __next__() method. |
| Lambda | An anonymous function defined with the lambda keyword. |
| List | An ordered, mutable sequence of items: [1, 2, 3]. |
| Metaclass | The class of a class; customizes class creation behavior, with type as the default metaclass. |
| Method Resolution Order | The linearized sequence of classes Python searches when resolving method or attribute lookups in an inheritance hierarchy. |
| Mixin | A class providing reusable methods via multiple inheritance without being intended as a standalone base type. |
| Module | A file containing Python definitions and statements, typically ending in .py. |
| Nonlocal | A keyword that allows an inner function to rebind a variable from an enclosing (non-global) scope. |
| Object | An instance of a class. Almost everything in Python is an object. |
| Package | A directory containing an __init__.py file and one or more modules. |
| Parameter | A variable in a function definition that accepts a value when the function is called. |
| Pip | The standard package installer for Python, used to install and manage packages from PyPI. |
| Protocol | A structural typing mechanism (from typing) that defines an interface by required methods and attributes without inheritance. |
| Reference Counting | CPython's primary memory management technique; objects are freed when their reference count drops to zero. |
| Set | An unordered collection of unique elements: {1, 2, 3}. |
| Slice | A way to extract parts of sequences using [start:stop:step] syntax. |
| String | A sequence of Unicode characters: "hello" or 'hello'. |
| Structural Pattern Matching | Python 3.10+ feature using match/case to destructure and branch on the shape of data. |
| Tuple | An immutable sequence of elements: (1, 2, 3). |
| Type Hints | Optional annotations on variables and function signatures indicating expected types, used by static analyzers but not enforced at runtime. |
| TypeVar | A placeholder type variable from the typing module used to define generic functions and classes. |
| Variable | A name that refers to a value stored in memory. |
| Virtual Environment | An isolated Python environment for managing dependencies separately from the global installation. |
| Walrus Operator | The := operator (Python 3.8+) that assigns a value within an expression. |
| Yield | A keyword used in generator functions to return a value and suspend function state. |