Welcome to the Python Glossary — This guide explains common Python terms in clear, simple language. It helps beginners learn the basics and gives experienced developers a quick way to refresh their knowledge. You’ll find short, direct definitions covering Python’s core features, built-in tools, and useful programming ideas.
A
ABI (Application Binary Interface): The binary interface between compiled extension modules and the Python interpreter. It affects the compatibility of compiled packages across Python versions and builds.
Abstract Base Class (ABC): A class that defines a common interface for subclasses, often using the abc module. Cannot be instantiated directly and enforces certain method implementations.
Annotation: Metadata attached to variables, parameters, or return types for documentation or static typing. Accessible at runtime via __annotations__ but ignored by the interpreter unless tools use them.
API (Application Programming Interface): A set of functions, classes, and rules that let different software components communicate and work together. In Python, APIs can be module-level functions or web service endpoints.
Argument: A value passed to a function when it is called. Arguments can be positional, keyword, or variable-length (via *args and **kwargs).
Argument Unpacking: Using * and ** in calls to expand sequences and mappings into positional and keyword arguments. Useful when forwarding parameters dynamically.
Async / Await: Keywords for writing asynchronous code. async def defines a coroutine; await pauses until an awaitable completes without blocking other tasks.
AsyncIO: The standard library framework for asynchronous programming using event loops, coroutines, tasks, and futures. Best for many concurrent I/O-bound tasks.
Attribute: A value or method bound to an object, accessed with dot notation (e.g., obj.attr). Attributes hold state or behavior for objects and classes.
B
Base Class: The parent class from which other classes inherit properties and methods. In Python, all classes implicitly inherit from object unless specified otherwise.
Base64: A binary-to-text encoding for safely transmitting binary data as ASCII text. Provided by the standard base64 module.
Bound Method: A method bound to a specific instance. When invoked, it automatically receives the instance as the first parameter (commonly self).
Binary File: A file that contains data in a format not meant for direct human reading, such as images, videos, or compiled code. Opened in Python with modes like "rb" or "wb".
Bitwise Operator: Operators that manipulate individual bits of integers, such as & (AND), | (OR), ^ (XOR), << (shift left), and >> (shift right).
Boolean: A data type with only two values: True or False. Often used in condition checks and logical expressions.
Break Statement: A control statement used to exit the nearest enclosing loop immediately, skipping the remaining iterations.
Buffer Protocol: An internal Python mechanism that allows direct access to an object’s byte-oriented data without copying it, used by objects like bytes and bytearray.
Built-in Function: Functions provided by Python by default, such as len(), print(), max(), and type(). They are always available without importing modules.
bytearray: A mutable sequence of bytes, useful for handling binary data that can be modified in place.
bytes: An immutable sequence of bytes, often used for representing raw binary data. Created with literals like b'hello'.
BOM (Byte Order Mark): A Unicode character used at the start of a text stream to indicate byte order (endianness). Relevant in UTF encoding handling.
Buffer: Temporary storage in memory for data being transferred between locations, often used in file and network operations for efficiency.
Blocking: A state where a program waits (halts) until an operation, such as I/O, completes before continuing execution.
Builtin Namespace: The top-level namespace in Python that stores built-in functions, exceptions, and constants like None, True, and False.
Backslash Escape: A sequence starting with \ in strings that represents special characters, e.g., \n for newline or \t for tab.
Bytecode: The intermediate compiled form of Python source code (stored as .pyc) that the Python virtual machine executes.
Bytes / Bytearray: Immutable (bytes) and mutable (bytearray) sequences of 8-bit values used for raw binary data and I/O operations.
C
Call by Object Reference: Python’s calling model, where references to objects are passed to functions. Mutating a passed-in mutable object affects the original reference.
Callable: Any object that can be invoked like a function (functions, methods, or objects implementing __call__). Use callable(obj) to check.
Class: A blueprint for creating objects that groups attributes and methods. Classes enable inheritance and encapsulation in object-oriented designs.
Closure: A function that captures variables from its enclosing scope. Closures let inner functions retain access to outer variables even after the outer function returns.
Comprehension: A compact syntax to build lists, sets, dicts, or generators (e.g., [x for x in it]). They improve readability and often performance.
Concurrency: Running multiple tasks during overlapping time periods. In Python, this can be achieved with threads, processes, or async code, each with trade-offs.
Context Manager: An object used with the with statement that implements __enter__ and __exit__ to reliably manage resources like files or locks.
CPython: The reference Python implementation written in C. It compiles source to bytecode and uses reference counting plus a garbage collector.
Cache: A temporary storage layer that keeps frequently accessed data in memory for faster retrieval. In Python, caching can be implemented manually or via tools like functools.lru_cache.
Chaining: A technique where multiple method calls or operations are connected in a single statement, often returning self or another object to enable continued calls.
Chunk: A fixed-size or logical segment of data processed at once, often used in file reading, streaming, or batching operations.
Circular Import: An import loop where two or more modules depend on each other, often causing ImportError or partially initialized modules.
Class Attribute: A variable that is shared across all instances of a class, defined directly inside the class body but outside any method.
Class Method: A method bound to the class rather than an instance, defined with @classmethod. Receives the class (cls) as its first argument.
Coercion: The implicit or explicit conversion of one data type into another (e.g., converting int to float in arithmetic).
Comparison Operators: Operators that compare values and return a Boolean, including ==, !=, <, >, <=, and >=.
Compile: The process of translating Python source code into bytecode (.pyc files) before execution by the interpreter.
Composite Data Type: A data type that can store multiple values, such as lists, dictionaries, tuples, and sets.
Conditional Expression: An expression that evaluates one of two values based on a condition, written as x if condition else y.
ConfigParser: A standard library module for reading and writing configuration files in INI format.
Constant: A variable intended to remain unchanged throughout a program. Python does not enforce immutability, but naming in ALL_CAPS indicates constants by convention.
Constructor: The special method __init__ in a class, automatically called when creating an instance to initialize attributes.
Coroutine: A special function defined with async def that can pause execution with await and resume later, enabling asynchronous programming.
D
Dataclass: A decorator from the dataclasses module that automatically generates boilerplate methods (like __init__ and __repr__) for classes used to store data.
Decorator: A callable that wraps and returns a new callable, used with the @ syntax to modify or extend functions and methods without editing their code.
Descriptor: An object defining attribute access via __get__, __set__, or __delete__. Descriptors power properties, methods, and attribute management.
Dictionary: A mutable mapping from hashable keys to values (dict). Offers average O(1) lookup and supports view objects for keys/items/values.
Docstring: A literal string placed at the start of a module, function, class, or method that documents its purpose. Accessible via __doc__.
Doctest: A testing module that runs examples embedded in docstrings and checks their output. Useful for simple, documentation-driven tests.
Duck Typing: A style where an object’s suitability is determined by the presence of methods/attributes, not by its explicit type. “If it walks like a duck…”
Daemon Thread: A background thread that runs without blocking program exit. It terminates automatically when all non-daemon threads finish.
Data Hiding: The practice of limiting direct access to an object’s internal state, often by using a naming convention like a leading underscore (_).
Data Serialization: The process of converting Python objects into a format (e.g., JSON, pickle) that can be stored or transmitted and later reconstructed.
Debugging: Debugging is the process of finding and fixing errors or unexpected behavior in code, often using tools like pdb or IDE debuggers.
Deep Copy: A copy of an object and all objects it contains, created using the copy.deepcopy() function, ensuring no shared references with the original.
Default Argument: A function parameter with a preset value that is used if no argument is provided when the function is called.
Dynamic Typing: A feature where variable types are determined at runtime, allowing reassignment to different types without explicit declarations.
Delimiter: A character or sequence of characters that marks boundaries between separate data elements, such as commas in CSV files or tabs in TSV files
E
EAFP (Easier to Ask Forgiveness than Permission): A Pythonic approach that tries an operation and handles exceptions rather than pre-checking conditions.
Enum: An enumeration type from enum.Enum used to define named constant values, improving readability and safety over raw literals.
Exception: An error condition raised during execution. Use try/except blocks to handle exceptions and keep programs robust.
Ellipsis: A special constant Ellipsis (or ...) used in slicing syntax for advanced indexing, often in NumPy arrays or to indicate omitted code.
Empty Sequence: A sequence with no elements, such as [], (), '', or range(0). Evaluates as False in Boolean contexts.
Encoding: The process of converting text (Unicode) into a specific byte representation, such as UTF-8 or ASCII, for storage or transmission.
Endianness: The byte order used to represent multi-byte data types; can be little-endian or big-endian. Python’s sys.byteorder reveals the system’s order.
Entry Point: The location where program execution begins, such as the if __name__ == "__main__": block in Python scripts.
Environment Variable: A key-value pair in the operating system’s environment, accessible via Python’s os.environ for configuration and settings.
Eval: A built-in function that parses and executes a string as a Python expression, often considered unsafe with untrusted input.
Event Loop: A core part of asynchronous programming (asyncio) that manages and schedules the execution of tasks, callbacks, and I/O events.
Executable: A file or script that can be directly run by the operating system or interpreter, such as a .py file executed by Python.
Exit Code: An integer returned by a program upon completion, where 0 usually indicates success, and non-zero values indicate errors.
Explicit Conversion: The intentional casting of a value to a specific type using functions like int(), str(), or float().
Expression: Any combination of literals, identifiers, operators, and function calls that produces a value when evaluated.
Extended Slice: A slicing technique that uses the third parameter in sequence[start:stop:step] to define step size, including negative steps.
Extension Module: A module written in C or C++ that can be imported into Python, often used to improve performance or interface with system libraries.
F
File I/O: Reading and writing files using open() or higher-level APIs like pathlib. Use context managers to ensure files close cleanly.
File-like Object: Any object that implements methods like read() or write(), such as sockets or in-memory streams (io.StringIO).
FP Helpers: Functional programming tools such as map, filter, functools, and itertools to write pipeline-style transformations.
Functor / Higher-order Function: Functions that accept other functions as arguments or return functions. They enable composable, reusable behavior.
functools: A standard module with utilities like partial, lru_cache, and singledispatch for functional-style programming and caching.
False: A built-in Boolean constant representing the false value. Equivalent to 0 in numeric contexts and evaluates as False in conditionals.
f-string: A string literal prefixed with f or F that supports inline expressions inside curly braces {}, introduced in Python 3.6 for fast and readable string formatting.
Factorial: The product of all positive integers up to a given number n. In Python, it can be computed with math.factorial(n).
FIFO (First In, First Out): A queue ordering principle where the first item added is the first to be removed. Implemented using collections like deque.
Float: A built-in data type representing real numbers with decimal points, implemented as double-precision floating-point numbers.
Flow Control: The mechanisms that determine the order in which statements are executed, including loops, conditionals, and exceptions.
For Loop: A control structure that iterates over an iterable’s elements in sequence. Uses for ... in ...: syntax.
Frozen Set: An immutable set type in Python that cannot be modified after creation. Useful as dictionary keys or set elements.
Framework: A collection of pre-written code and tools providing a structure for application development, such as Django or Flask.
Function Annotation: Metadata attached to function parameters and return values, defined using : and ->, often used for type hints.
Function Scope: The local namespace created when a function is called, where its variables are stored and resolved.
G
Generator: A function using yield to produce values lazily, conserving memory for large or infinite sequences.
GIL (Global Interpreter Lock): A CPython mechanism that allows only one native thread to execute Python bytecode at a time, limiting CPU-bound multi-threading.
GUI Frameworks: Libraries for desktop GUIs like tkinter, PyQt, and Kivy, each with different trade-offs and use cases.
Hashable: An object with a stable hash value used as dictionary keys or set items. Immutable objects are typically hashable.
HTTP / REST Clients: Libraries such as requests (sync) and httpx (supports async) used to make HTTP calls to web APIs.
Garbage Collection: The automatic process of freeing memory by reclaiming objects no longer in use. Python uses reference counting with a cyclic garbage collector.
Generalization: The process of designing functions or classes to handle a broader range of inputs or types, improving code reusability.
getattr(): A built-in function that retrieves the value of an object’s attribute by name. Can take a default value if the attribute is missing.
Global Keyword: A statement used to declare that a variable inside a function refers to a globally scoped variable, allowing modification.
Global Namespace: The top-level scope of a Python module where variables, functions, and classes defined at the file level reside.
Global Variable: A variable defined at the module level, accessible from anywhere in the module (and from other modules if imported).
Gradient Descent: An optimization algorithm often used in machine learning to minimize a loss function by iteratively adjusting parameters.
Graph: A data structure consisting of nodes (vertices) connected by edges, used to represent networks, relationships, and paths.
Groupby: A function in itertools and pandas that groups iterable elements or DataFrame rows by a key function or column(s)
H
hash() Function: A built-in function that returns the hash value of an object, which must be hashable (immutable and with __hash__ defined).
Heap: A specialized tree-based data structure where the parent node is ordered with respect to its children; implemented in Python via the heapq module.
heapq Module: A Python standard library module that provides functions for creating and working with heaps, useful for priority queues and fast min/max retrieval.
Help System: Python’s built-in help() function or pydoc tool for accessing documentation interactively.
Hexadecimal: A base-16 number system using digits 0–9 and letters A–F. In Python, hexadecimal literals use the 0x prefix.
hex() Function: A built-in function that converts an integer to its hexadecimal string representation.
High-Level Language: A programming language like Python that abstracts away hardware details, focusing on readability and productivity.
HTTPServer: A basic HTTP server provided by the http.server module in the standard library, useful for lightweight development and testing.
Hypothesis: A Python library for property-based testing generates test cases automatically based on specifications.
I
Immutable: Objects that cannot be changed after creation (e.g., str, tuple, frozenset). Immutability helps with safety and hashing.
Import System: How Python locates and loads modules and packages (via sys.path, package __init__.py, import hooks, and importlib).
Indexing & Slicing: Accessing elements with seq[i] or subranges with seq[start:stop:step]. Slices create new sequence objects.
Integer / Float / Decimal (Numeric Types): Built-in numeric types: arbitrary-size int, floating-point float, and decimal.Decimal for exact decimal arithmetic.
Iterable: Any object capable of returning its elements one at a time (e.g., lists, tuples, generators), typically used in for loops.
Iterator: An object implementing __iter__() and __next__() that yields successive values until exhaustion.
Iterator Protocol: The protocol requiring __iter__() and __next__(), enabling objects to be iterated with loops and comprehensions.
itertools: A standard library module offering fast, memory-efficient tools for building and combining iterators for combinatorics and streaming tasks.
J
JavaScript Interop: Projects like Pyodide and Brython that run Python in the browser or bridge Python and JavaScript for web contexts.
JIT Compilation (Just-In-Time): A runtime optimization technique that compiles bytecode to native machine code on the fly for faster execution. Implemented in projects like PyPy.
JSON (JavaScript Object Notation): JSON is a lightweight data format for exchanging structured data, supported in Python via the json module.
JSON Lines: A file format where each line is a separate JSON object, helpful in streaming large datasets.
join() Method: A string method that concatenates elements of an iterable into a single string with a specified separator.
join() Thread Method: A threading method that blocks until the specified thread terminates.
JPEG: A widely used compressed image format that is readable and writable in Python via libraries like Pillow.
Joblib: A Python library for lightweight pipelining in machine learning, often used for parallel processing and model persistence.
Jupyter Notebook: An interactive development environment that combines code, output, and markdown in a single document, widely used for data science.
Jython: An implementation of Python written in Java, allowing Python code to run on the JVM and interoperate with Java libraries.
K
KeyError: An exception raised when a dictionary key is not found in the existing keys.
Keyword Argument: An argument passed to a function by explicitly naming its parameter (e.g., func(x=10)), improving clarity and flexibility.
Keyword-Only Argument: A function parameter that must be specified using its name, defined after * in the parameter list.
Key Function: A function passed to sorting or grouping operations (sorted(), min(), max()) to determine the sort or selection criteria.
Kernel: The core of an operating system or, in data science, the execution engine (e.g., IPython kernel) that runs Python code.
KiB (Kibibyte): A unit of digital information equal to 1,024 bytes, distinct from a kilobyte (1,000 bytes).
Keyword List: A list of key=value style arguments often collected into a dictionary via **kwargs in function definitions.
Kivy: An open-source Python framework for developing cross-platform applications, especially mobile apps and multitouch interfaces.
K-nearest Neighbors (KNN): A simple machine learning algorithm that classifies data points based on the classes of their nearest neighbors.
L
Lambda: A small anonymous function defined with lambda. It is limited to a single expression and used for short, inline callbacks.
List: A mutable ordered sequence of items created with square brackets. Lists support appends, pops, indexing, and slicing.
List Comprehension: A concise expression to build lists from iterables with optional filtering (e.g., [f(x) for x in it if cond(x)]).
logging: The standard logging framework providing levels, handlers, and formatters to record events and debug production code.
len() Function: A built-in function that returns the number of items in a container such as a list, tuple, dict, or string.
LEGB Rule: The order Python uses to resolve variable names — Local, Enclosing, Global, Built-in.
Library: A collection of modules or packages that provide reusable functionality for Python programs.
Lightweight Process: Another term for a thread, which shares memory with other threads but executes independently.
Literal: A fixed value written directly in code, such as numbers (42), strings ("hello"), lists ([1, 2, 3]), or booleans (True).
Literal String Interpolation: String interpolation via f-strings or the .format() method to insert variable values directly into a string.
Literal_eval: A safe function in ast that evaluates strings containing Python literals into their corresponding objects.
Local Variable: A variable defined within a function or block and accessible only within that scope.
Lock: A synchronization primitive from the threading module that prevents multiple threads from accessing shared resources simultaneously.
Loop: A control structure (for or while) that repeatedly executes a block of code until a condition changes.
Low-Level Language: A language closer to machine code, like C or assembly; Python is considered high-level, but can interface with low-level code via extensions.
M
mmap: Memory maps a file for efficient, random-access I/O without loading the entire file into memory.
Metaclass: A class of a class that controls class creation, enabling customization or enforcement of patterns at class-definition time.
mypy/Type Hinting/typing: Optional static typing annotations (via the typing module) and tools like mypy to catch type errors before runtime.
Multiprocessing: A standard library module that runs processes in parallel to bypass the GIL, ideal for CPU-bound tasks.
Magic Method: Special methods surrounded by double underscores (e.g., __init__, __add__) that enable operator overloading and customize object behavior.
Main Module: The script that is run as the main program, identified by __name__ == "__main__".
Map Function: A built-in function that applies a given function to every item of an iterable, returning an iterator with the results.
Marshalling: The process of converting Python objects into a byte stream for storage or transmission, often used internally by pickle and for .pyc files.
Match Statement: A pattern matching construct introduced in Python 3.10 using the match and case keywords.
math Module: A standard library module providing mathematical functions like sqrt(), sin(), and constants like pi.
Memory Leak: Memory Leak is a situation where memory is allocated but never released, potentially causing excessive memory usage over time.
Memoryview: A built-in object that allows Python code to access the internal data of an object that supports the buffer protocol without copying.
Method Resolution Order (MRO): The order in which base classes are searched when executing a method, available via the __mro__ attribute.
Module: A file containing Python definitions and statements, which can be imported into other scripts using the import statement.
Monkey Patching: Modifying or extending code at runtime by changing classes, methods, or modules without altering the original source.
Mutable: An object whose state or contents can be changed after creation, such as lists, dictionaries, and sets.
N
Namespace: A mapping from names to objects (e.g., local, global, builtins). Namespaces prevent name collisions and scope variables.
numpy: A core library for numerical arrays and vectorized operations. It’s the foundation for scientific computing and data analysis in Python.
NaN (Not a Number): A special floating-point value representing undefined or unrepresentable results, such as 0.0 / 0.0. Accessible via math.nan or float('nan').
Namedtuple: A factory function in collections that creates tuple subclasses with named fields for more readable code.
Negative Indexing: Using negative numbers to index sequences, where -1 refers to the last element, -2 to the second last, and so on.
Nested Function: A function defined inside another function, often used for encapsulation or closures.
Nested List Comprehension: A comprehension inside another comprehension, used to flatten or transform multi-dimensional structures.
Network Sockets: Endpoints for sending and receiving data over a network, handled in Python via the socket module.
New-Style Class: Any class that explicitly or implicitly inherits from object. In Python 3, all classes are new-style by default.
No-op (No Operation): A statement or operation that does nothing, often represented by the pass statement in Python.
None: A special singleton object in Python represents the absence of a value or a null reference.
NotImplemented: A special singleton returned by special methods to indicate that an operation is not supported for the given operands.
NT Path: A file path format used by Windows NT and its derivatives, often requiring escaping backslashes in Python strings.
O
Object: An Object is an instance of a class that encapsulates data (attributes) and behavior (methods). In Python nearly everything is an object.
ORM (Object-Relational Mapper): A layer that maps database tables to Python classes so you can work with objects instead of raw SQL (e.g., SQLAlchemy, Django ORM).
Octal: A base-8 number system using digits 0–7. In Python, octal literals are written with a 0o prefix (e.g., 0o755).
Octet: A sequence of 8 bits, equivalent to a byte; commonly used in networking contexts.
Offset: A numeric value indicating a position relative to a starting point, such as byte offsets in files or index offsets in sequences.
On-Demand Import: Importing modules only when they are needed during runtime, reducing initial load time.
One-Liner: A short Python statement that accomplishes a task in a single line of code.
Open Mode: The string argument in open() that specifies how a file is accessed, such as 'r' for read or 'wb' for binary write.
Operator: A symbol or function that performs an operation, such as arithmetic (+, -), comparison (==, <), or logical (and, or).
Operator Overloading: Defining special methods (like __add__, __eq__) in a class to customize the behavior of operators for its instances.
Optparse: A deprecated standard library module for parsing command-line options, replaced by argparse.
Optimization: The process of improving code performance or memory usage through algorithmic improvements, data structure choice, or built-in optimizations.
OrderedDict: A dictionary subclass from collections that preserves insertion order (now the default for dict since Python 3.7+).
P
Package: A directory of Python modules, typically with an __init__.py, used to organize and distribute related code.
Path-like Object: An object representing a filesystem path that implements __fspath__(), accepted by os and pathlib.
PEP (Python Enhancement Proposal): A design document describing new features, processes, or standards for Python; PEPs guide language evolution and conventions.
pickle: A built-in binary serialization protocol for Python objects. Convenient for Python-only usage but unsafe for untrusted data.
pip: The standard package installer for Python that fetches packages from PyPI and installs them into environments.
pkg_resources / importlib.metadata: APIs to discover package metadata, versions, and entry points; importlib.metadata is the modern approach.
property: A decorator that makes a method behave like an attribute with getter/setter semantics, keeping interfaces clean and controlled.
profiling: Tools such as cProfile and timeit that measure execution time and identify performance bottlenecks.
pyproject.toml: A modern configuration file that centralizes build and packaging metadata for Python projects (PEP 518/621).
PyPI: The Python Package Index, the central repository where packages are published and installed using pip.
Python REPL / IPython / Jupyter: Interactive environments for exploratory coding. IPython improves ergonomics; Jupyter displays code, output, and rich media in notebooks.
Q
qualname / __qualname__: The qualified name of a function or class showing nesting; helpful for debugging and reflection.
queue module: Thread-safe FIFO, LIFO, and priority queues useful for producer-consumer patterns and inter-thread coordination.
QGIS (Quantum GIS): An open-source geographic information system that can be automated or extended using Python scripting.
QML (Qt Modeling Language): A declarative language for designing UI in the Qt framework; accessible from Python through PyQt or PySide bindings.
QName (Qualified Name): In XML processing, the namespace-qualified name of an element or attribute, handled in Python via libraries like xml.etree.ElementTree.
QR Code: A two-dimensional barcode that can store data such as URLs; Python supports generation and decoding via libraries like qrcode and pyzbar.
Quadratic Time: A time complexity of O(n²), where runtime grows proportionally to the square of the input size.
Quantization: The process of mapping a large set of values to a smaller set, often used in machine learning model optimization to reduce size and improve speed.
Query Parameters: The key-value pairs in a URL after the ?, accessible in Python via urllib.parse or web frameworks.
Quickselect: An efficient selection algorithm for finding the k-th smallest element in an unordered list, related to Quicksort.
Quicksort: A divide-and-conquer sorting algorithm that partitions data around a pivot, achieving average O(n log n) time complexity.
R
random module: Utilities for pseudo-random number generation, sampling, and shuffling. Not cryptographically secure — use secrets for that.
Range: An immutable sequence of integers used commonly in loops. It is memory-efficient and supports slicing-like behavior.
regex: Regular expression support for searching, matching, and replacing text. Powerful but can reduce readability if overused.
refcounting & garbage collection: CPython primarily uses reference counting and a cyclic garbage collector to manage memory and free unreachable objects.
requirements.txt: A plain list of project dependencies (often pinned) used to reproduce environments with pip install -r.
return value: The result a function passes back to its caller via return. If omitted the function returns None.
Raise Statement: A keyword used to trigger an exception in Python, optionally specifying the exception type and message.
Raw String: A string prefixed with r or R where backslashes are treated literally, useful for regex patterns and Windows file paths.
Read Mode: A file access mode ('r' or 'rb') that opens a file for reading without modifying it.
Recursion: Recursion is a programming technique where a function calls itself directly or indirectly to solve a problem.
Redis: An in-memory key-value store often accessed from Python using libraries like redis-py for caching and messaging.
Reduce Function: A function from functools that cumulatively applies another function to items in an iterable, reducing it to a single value.
Relative Import: Importing modules using a relative path within a package, denoted by leading dots (e.g., from . import module).
REPL (Read-Eval-Print Loop): An interactive Python shell that reads user input, evaluates it, prints the result, and repeats.
repr() Function: A built-in function that returns the string representation of an object, ideally one that can be passed to eval() to recreate it.
Requests Library: A popular third-party package for making HTTP requests in a simpler way than the standard urllib.
ResourceWarning: A warning raised when resources like files or sockets are not properly closed.
S
set: An unordered collection of unique, hashable items supporting fast membership tests and standard set operations.
setuptools: A packaging library used to build and distribute Python projects; historically tied to setup.py workflows.
slice: An object or syntax (start:stop:step) representing a subsequence; used to extract parts of lists, tuples, and strings.
socket: A low-level networking module for TCP/UDP communication that underlies higher-level HTTP and WebSocket libraries.
sorted / sorting key: Built-in utilities to sort iterables; use the key= parameter to sort by computed attributes while keeping the sort stable.
SQLAlchemy: A flexible ORM and SQL toolkit that provides both high-level ORM features and low-level SQL expression language control.
stack trace: The sequence of function calls shown when an exception occurs, used to identify where errors originate for debugging.
stdlib (Standard Library): The rich set of modules that ship with Python, such as os, sys, json, and itertools.
strict vs. duck typing: Python prefers duck typing (behavior-based). Static typing tools (like mypy) provide stricter checks without changing runtime behavior.
subprocess: Module to spawn and communicate with external processes, replace older modules, and manage process I/O safely.
super(): A built-in helper to call methods from a parent class, simplifying cooperative multiple inheritance when used properly.
Syntax: Syntax is the set of rules defining valid Python code; linters and formatters help keep code consistent and readable.
system path (sys.path): The list of directories Python searches to resolve imports. It can be modified but prefer packaging over manual tweaks.
T
threading: The standard library module for threads. Threads share memory but are affected by the GIL for CPU-bound work.
type/typing module: type is the runtime object for types; the typing module offers static typing constructs for annotations.
TabError: An exception raised when Python detects inconsistent use of tabs and spaces in indentation.
Ternary Operator: A shorthand conditional expression written as a if condition else b.
TextIOWrapper: A class from the io module that provides a text interface to a buffered raw stream, handling encoding and decoding.
Time Complexity: A measure of how an algorithm’s runtime scales with input size, often expressed using Big O notation.
time Module: A standard library module for time-related functions, such as sleeping, measuring performance, and working with timestamps.
Timeout: A limit on how long an operation can take before it is aborted, often used in network requests and threading.
Tokenization: The process of breaking Python source code into tokens, which are the smallest meaningful elements for parsing.
Traceback: The report Python generates when an exception occurs, showing the call stack at the point of error.
Trailing Comma: A comma at the end of a list, tuple, dict, or argument list, allowed in Python and often used to reduce diffs in version control.
try Statement: A control structure used to catch and handle exceptions via try, except, else, and finally clauses.
Tuple: An immutable, ordered collection of elements, written with parentheses (1, 2, 3).
TypeError: An exception raised when an operation or function is applied to an object of an inappropriate type.
U
unittest/pytest: Testing frameworks: unittest is built-in and class-based; pytest is third-party and favored for concise tests and powerful fixtures.
UID (User Identifier): A numeric value assigned to each user in an operating system; accessible in Python via os.getuid() on Unix-like systems.
Unicode: A universal character encoding standard that supports virtually all written languages. Python 3 strings are Unicode by default.
UnicodeEscape: A string escape sequence format (e.g., \u2764) used to represent Unicode characters in Python source code.
Union Type: A type hint that allows multiple possible types, written as X | Y (Python 3.10+) or typing.Union[X, Y].
Unpacking: The process of extracting values from sequences or iterables into variables, using * for positional and ** for keyword arguments.
Update Method: A dictionary method (dict.update()) that merges key-value pairs from another mapping or iterable into the dictionary.
urllib: A standard library package for fetching data across the web using URLs, with modules like urllib.request and urllib.parse.
UTC (Coordinated Universal Time): The primary time standard by which the world regulates clocks; Python’s datetime supports UTC-aware objects.
V
Variable: A named reference to an object in memory. Python variables are dynamically typed and can be rebound to different types.
virtual environment: An isolated Python environment (via venv, virtualenv, or Conda) to manage project-specific dependencies.
view object: Dynamic views returned by dict.keys(), dict.items(), and dict.values() that reflect dictionary changes.
ValueError: An exception raised when a function receives an argument of the correct type but with an inappropriate value, such as int("abc").
Variable Scope: The region of code where a variable is accessible, including local, enclosing, global, and built-in scopes.
Vectorization: The process of applying operations to entire arrays or sequences at once, often via NumPy, for speed and code clarity.
Version Control: A system (e.g., Git) for tracking changes to source code and coordinating work among multiple developers.
Virtual Thread: A lightweight concurrency unit (not native to Python) conceptually similar to asyncio tasks, used in some languages and experimental Python runtimes.
Volatile: In computing, data that is lost when power is removed; in Python contexts, often refers to temporary in-memory data or non-persistent caches.
von Neumann Architecture: The computer architecture model where program instructions and data share the same memory and bus, influencing Python’s execution model indirectly.
W
walk / os.walk: A utility to traverse directory trees yielding directory names and file lists; commonly used when processing files recursively.
weakref: Weak references let you reference objects without increasing their reference count, enabling caches that don’t prevent garbage collection.
web frameworks: Frameworks for building web apps and APIs, e.g., Flask (lightweight), Django (full-featured), and FastAPI (async, modern).
WSGI / ASGI: Server interfaces for Python web apps. WSGI is synchronous; ASGI supports asynchronous protocols like WebSocket and HTTP/2.
wheel (.whl): A binary distribution format for Python packages that speeds installation by avoiding local builds.
While Loop: A control structure that repeatedly executes a block of code as long as a given condition evaluates to True.
with Statement: A control-flow construct that simplifies resource management by ensuring __enter__ and __exit__ methods are called, often used for files or locks.
Wildcard Import: An import statement like from module import * that imports all public names from a module into the current namespace (generally discouraged).
Whitespace: Any space, tab, or newline character used to separate tokens in Python code; indentation using whitespace is syntactically significant.
Working Directory: The current folder from which a Python script is run; accessible and changeable with os.getcwd() and os.chdir().
Wraps Decorator: A helper from functools that preserves the original function’s metadata when creating decorators.
Write Mode: A file access mode ('w' or 'wb') that overwrites a file or creates it if it doesn’t exist.
WSGIRef: A reference implementation of the WSGI standard in Python’s standard library, useful for simple web servers or testing.
X
XML / JSON: Common data interchange formats; Python provides built-in and third-party modules to parse and produce them (json, xml).
X-axis: The horizontal axis in a two-dimensional plot or graph, often representing independent variables in data visualization.
XOR (Exclusive OR): A bitwise operator (^) that returns 1 for each bit position where the corresponding bits of two integers are different.
XML: Extensible Markup Language, a markup format for storing and transporting structured data. In Python, handled by modules like xml.etree.ElementTree or lxml.
XML-RPC: A remote procedure call protocol using XML to encode requests and responses over HTTP. Python’s xmlrpc module supports it.
Xrange: A memory-efficient range-like object in Python 2 that generated numbers lazily. Replaced by range in Python 3.
Xvfb: X Virtual FrameBuffer, a display server implementation that enables GUI applications to run without a physical display. Can be used with Python GUI tests.
XGBoost: An optimized gradient boosting library used in machine learning, accessible via its Python API.
Y
yield: A keyword that returns a value from a generator and pauses its state so it can resume later, enabling lazy iteration.
YAML: A human-readable data serialization format often used for configuration files. In Python, handled by libraries like PyYAML or ruamel.yaml.
YAMLLoadWarning: A warning raised by PyYAML when using yaml.load() without specifying a loader, due to potential security issues.
Year: A time unit representing 365 or 366 days. In Python, handled through datetime.date or datetime.datetime objects.
yesno Dialog: A user interface prompt that expects a yes/no answer. Often implemented in GUI frameworks or CLI programs.
Y-axis: The vertical axis in a two-dimensional plot or graph, often representing dependent variables in data visualization libraries like Matplotlib.
Yield from: A syntax that delegates part of a generator’s operations to another generator, enabling generator composition.
YourKit Profiler: A commercial performance profiling tool that supports Python via integrations, useful for identifying bottlenecks.
Z
zip / gzip / tarfile: Modules for compression and archive handling, supporting common formats and streaming operations.
ZeroDivisionError: An exception raised when attempting to divide a number by zero using /, //, or %.
Zero Padding: Adding leading zeros to a number or string for formatting, often using str.zfill() or format specifiers.
Zip: A built-in function that aggregates elements from multiple iterables into tuples, stopping at the shortest iterable.
zipfile: A standard library module for reading and writing ZIP archive files.
Zip Import: A feature allowing Python to import modules directly from ZIP archives via zipimport.
ZoneInfo: A standard library module (Python 3.9+) for IANA time zone support, enabling accurate datetime conversions.
Z-order Curve: A space-filling curve used in spatial indexing to preserve locality when mapping multidimensional data to one dimension.
Zombie Process: A process that has completed execution but still has an entry in the process table, usually awaiting acknowledgment by its parent process.
