Python Glossary

The binary interface between compiled extension modules and the Python interpreter. It affects the compatibility of compiled packages across Python versions and builds.

A class that defines a common interface for subclasses, often using the abc module. Cannot be instantiated directly and enforces certain method implementations.

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.

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.

A value passed to a function when it is called. Arguments can be positional, keyword, or variable-length (via *args and **kwargs).

Using * and ** in calls to expand sequences and mappings into positional and keyword arguments. Useful when forwarding parameters dynamically.

Keywords for writing asynchronous code. async def defines a coroutine; await pauses until an awaitable completes without blocking other tasks.

The standard library framework for asynchronous programming using event loops, coroutines, tasks, and futures. Best for many concurrent I/O-bound tasks.

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.

A sequence starting with \ in strings that represents special characters, e.g., \n for newline or \t for tab.

The parent class from which other classes inherit properties and methods. In Python, all classes implicitly inherit from object unless specified otherwise.

A binary-to-text encoding for safely transmitting binary data as ASCII text. Provided by the standard base64 module.

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".

Operators that manipulate individual bits of integers, such as & (AND), | (OR), ^ (XOR), << (shift left), and >> (shift right).

A state where a program waits (halts) until an operation, such as I/O, completes before continuing execution.

A Unicode character used at the start of a text stream to indicate byte order (endianness). Relevant in UTF encoding handling.

A data type with only two values: True or False. Often used in condition checks and logical expressions.

A method bound to a specific instance. When invoked, it automatically receives the instance as the first parameter (commonly self).

A control statement used to exit the nearest enclosing loop immediately, skipping the remaining iterations.

Temporary storage in memory for data being transferred between locations, often used in file and network operations for efficiency.

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.

Functions provided by Python by default, such as len(), print(), max(), and type(). They are always available without importing modules.

The top-level namespace in Python that stores built-in functions, exceptions, and constants like None, True, and False.

A mutable sequence of bytes, useful for handling binary data that can be modified in place.

The intermediate compiled form of Python source code (stored as .pyc) that the Python virtual machine executes.

An immutable sequence of bytes, often used for representing raw binary data. Created with literals like b'hello'.

Immutable (bytes) and mutable (bytearray) sequences of 8-bit values used for raw binary data and I/O operations.

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.

Python’s calling model, where references to objects are passed to functions. Mutating a passed-in mutable object affects the original reference.

Any object that can be invoked like a function (functions, methods, or objects implementing __call__). Use callable(obj) to check.

A technique where multiple method calls or operations are connected in a single statement, often returning self or another object to enable continued calls.

A fixed-size or logical segment of data processed at once, often used in file reading, streaming, or batching operations.

An import loop where two or more modules depend on each other, often causing ImportError or partially initialized modules.

A blueprint for creating objects that groups attributes and methods. Classes enable inheritance and encapsulation in object-oriented designs.

A variable that is shared across all instances of a class, defined directly inside the class body but outside any method.

A method bound to the class rather than an instance, defined with @classmethod. Receives the class (cls) as its first argument.

A function that captures variables from its enclosing scope. Closures let inner functions retain access to outer variables even after the outer function returns.

The implicit or explicit conversion of one data type into another (e.g., converting int to float in arithmetic).

Operators that compare values and return a Boolean, including ==, !=, <, >, <=, and >=.

The process of translating Python source code into bytecode (.pyc files) before execution by the interpreter.

A data type that can store multiple values, such as lists, dictionaries, tuples, and sets.

A compact syntax to build lists, sets, dicts, or generators (e.g., [x for x in it]). They improve readability and often performance.

Running multiple tasks during overlapping time periods. In Python, this can be achieved with threads, processes, or async code, each with trade-offs.

An expression that evaluates one of two values based on a condition, written as x if condition else y.

A standard library module for reading and writing configuration files in INI format.

A variable intended to remain unchanged throughout a program. Python does not enforce immutability, but naming in ALL_CAPS indicates constants by convention.

The special method __init__ in a class, automatically called when creating an instance to initialize attributes.

An object used with the with statement that implements __enter__ and __exit__ to reliably manage resources like files or locks.

A special function defined with async def that can pause execution with await and resume later, enabling asynchronous programming.

The reference Python implementation written in C. It compiles source to bytecode and uses reference counting plus a garbage collector.

A background thread that runs without blocking program exit. It terminates automatically when all non-daemon threads finish.

The practice of limiting direct access to an object’s internal state, often by using a naming convention like a leading underscore (_).

The process of converting Python objects into a format (e.g., JSON, pickle) that can be stored or transmitted and later reconstructed.

A decorator from the dataclasses module that automatically generates boilerplate methods (like __init__ and __repr__) for classes used to store data.

Debugging is the process of finding and fixing errors or unexpected behavior in code, often using tools like pdb or IDE debuggers.

A callable that wraps and returns a new callable, used with the @ syntax to modify or extend functions and methods without editing their code.

A copy of an object and all objects it contains, created using the copy.deepcopy() function, ensuring no shared references with the original.

A function parameter with a preset value that is used if no argument is provided when the function is called.

A character or sequence of characters that marks boundaries between separate data elements, such as commas in CSV files or tabs in TSV files

An object defining attribute access via __get__, __set__, or __delete__. Descriptors power properties, methods, and attribute management.

A mutable mapping from hashable keys to values (dict). Offers average O(1) lookup and supports view objects for keys/items/values.

A literal string placed at the start of a module, function, class, or method that documents its purpose. Accessible via __doc__.

A testing module that runs examples embedded in docstrings and checks their output. Useful for simple, documentation-driven tests.

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…”

A feature where variable types are determined at runtime, allowing reassignment to different types without explicit declarations.

A Pythonic approach that tries an operation and handles exceptions rather than pre-checking conditions.

A special constant Ellipsis (or ...) used in slicing syntax for advanced indexing, often in NumPy arrays or to indicate omitted code.

A sequence with no elements, such as [], (), '', or range(0). Evaluates as False in Boolean contexts.

The process of converting text (Unicode) into a specific byte representation, such as UTF-8 or ASCII, for storage or transmission.

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.

The location where program execution begins, such as the if __name__ == "__main__": block in Python scripts.

An enumeration type from enum.Enum used to define named constant values, improving readability and safety over raw literals.

A key-value pair in the operating system’s environment, accessible via Python’s os.environ for configuration and settings.

A built-in function that parses and executes a string as a Python expression, often considered unsafe with untrusted input.

A core part of asynchronous programming (asyncio) that manages and schedules the execution of tasks, callbacks, and I/O events.

An error condition raised during execution. Use try/except blocks to handle exceptions and keep programs robust.

A file or script that can be directly run by the operating system or interpreter, such as a .py file executed by Python.

An integer returned by a program upon completion, where 0 usually indicates success, and non-zero values indicate errors.

The intentional casting of a value to a specific type using functions like int(), str(), or float().

Any combination of literals, identifiers, operators, and function calls that produces a value when evaluated.

A slicing technique that uses the third parameter in sequence[start:stop:step] to define step size, including negative steps.

A module written in C or C++ that can be imported into Python, often used to improve performance or interface with system libraries.

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.

The product of all positive integers up to a given number n. In Python, it can be computed with math.factorial(n).

A built-in Boolean constant representing the false value. Equivalent to 0 in numeric contexts and evaluates as False in conditionals.

A queue ordering principle where the first item added is the first to be removed. Implemented using collections like deque.

Reading and writing files using open() or higher-level APIs like pathlib. Use context managers to ensure files close cleanly.

Any object that implements methods like read() or write(), such as sockets or in-memory streams (io.StringIO).

A built-in data type representing real numbers with decimal points, implemented as double-precision floating-point numbers.

The mechanisms that determine the order in which statements are executed, including loops, conditionals, and exceptions.

A control structure that iterates over an iterable’s elements in sequence. Uses for ... in ...: syntax.

Functional programming tools such as map, filter, functools, and itertools to write pipeline-style transformations.

A collection of pre-written code and tools providing a structure for application development, such as Django or Flask.

An immutable set type in Python that cannot be modified after creation. Useful as dictionary keys or set elements.

Metadata attached to function parameters and return values, defined using : and ->, often used for type hints.

The local namespace created when a function is called, where its variables are stored and resolved.

A standard module with utilities like partial, lru_cache, and singledispatch for functional-style programming and caching.

Functions that accept other functions as arguments or return functions. They enable composable, reusable behavior.

The automatic process of freeing memory by reclaiming objects no longer in use. Python uses reference counting with a cyclic garbage collector.

The process of designing functions or classes to handle a broader range of inputs or types, improving code reusability.

A function using yield to produce values lazily, conserving memory for large or infinite sequences.

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.

A CPython mechanism that allows only one native thread to execute Python bytecode at a time, limiting CPU-bound multi-threading.

A statement used to declare that a variable inside a function refers to a globally scoped variable, allowing modification.

The top-level scope of a Python module where variables, functions, and classes defined at the file level reside.

A variable defined at the module level, accessible from anywhere in the module (and from other modules if imported).

An optimization algorithm often used in machine learning to minimize a loss function by iteratively adjusting parameters.

A data structure consisting of nodes (vertices) connected by edges, used to represent networks, relationships, and paths.

A function in itertools and pandas that groups iterable elements or DataFrame rows by a key function or column(s)

Libraries for desktop GUIs like tkinter, PyQt, and Kivy, each with different trade-offs and use cases.

A built-in function that returns the hash value of an object, which must be hashable (immutable and with __hash__ defined).

An object with a stable hash value used as dictionary keys or set items. Immutable objects are typically hashable.

A specialized tree-based data structure where the parent node is ordered with respect to its children; implemented in Python via the 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.

Python’s built-in help() function or pydoc tool for accessing documentation interactively.

A built-in function that converts an integer to its hexadecimal string representation.

A base-16 number system using digits 0–9 and letters A–F. In Python, hexadecimal literals use the 0x prefix.

A programming language like Python that abstracts away hardware details, focusing on readability and productivity.

Libraries such as requests (sync) and httpx (supports async) used to make HTTP calls to web APIs.

A basic HTTP server provided by the http.server module in the standard library, useful for lightweight development and testing.

A Python library for property-based testing generates test cases automatically based on specifications.

Objects that cannot be changed after creation (e.g., str, tuple, frozenset). Immutability helps with safety and hashing.

How Python locates and loads modules and packages (via sys.path, package __init__.py, import hooks, and importlib).

Accessing elements with seq[i] or subranges with seq[start:stop:step]. Slices create new sequence objects.

Built-in numeric types: arbitrary-size int, floating-point float, and decimal.Decimal for exact decimal arithmetic.

Any object capable of returning its elements one at a time (e.g., lists, tuples, generators), typically used in for loops.

An object implementing __iter__() and __next__() that yields successive values until exhaustion.

The protocol requiring __iter__() and __next__(), enabling objects to be iterated with loops and comprehensions.

A standard library module offering fast, memory-efficient tools for building and combining iterators for combinatorics and streaming tasks.

Projects like Pyodide and Brython that run Python in the browser or bridge Python and JavaScript for web contexts.

A runtime optimization technique that compiles bytecode to native machine code on the fly for faster execution. Implemented in projects like PyPy.

A Python library for lightweight pipelining in machine learning, often used for parallel processing and model persistence.

A string method that concatenates elements of an iterable into a single string with a specified separator.

A threading method that blocks until the specified thread terminates.

A widely used compressed image format that is readable and writable in Python via libraries like Pillow.

JSON is a lightweight data format for exchanging structured data, supported in Python via the json module.

A file format where each line is a separate JSON object, helpful in streaming large datasets.

An interactive development environment that combines code, output, and markdown in a single document, widely used for data science.

An implementation of Python written in Java, allowing Python code to run on the JVM and interoperate with Java libraries.

A simple machine learning algorithm that classifies data points based on the classes of their nearest neighbors.

The core of an operating system or, in data science, the execution engine (e.g., IPython kernel) that runs Python code.

A function passed to sorting or grouping operations (sorted(), min(), max()) to determine the sort or selection criteria.

An exception raised when a dictionary key is not found in the existing keys.

An argument passed to a function by explicitly naming its parameter (e.g., func(x=10)), improving clarity and flexibility.

A list of key=value style arguments often collected into a dictionary via **kwargs in function definitions.

A function parameter that must be specified using its name, defined after * in the parameter list.

A unit of digital information equal to 1,024 bytes, distinct from a kilobyte (1,000 bytes).

An open-source Python framework for developing cross-platform applications, especially mobile apps and multitouch interfaces.

A small anonymous function defined with lambda. It is limited to a single expression and used for short, inline callbacks.

The order Python uses to resolve variable names — Local, Enclosing, Global, Built-in.

A built-in function that returns the number of items in a container such as a list, tuple, dict, or string.

A collection of modules or packages that provide reusable functionality for Python programs.

Another term for a thread, which shares memory with other threads but executes independently.

A mutable ordered sequence of items created with square brackets. Lists support appends, pops, indexing, and slicing.

A concise expression to build lists from iterables with optional filtering (e.g., [f(x) for x in it if cond(x)]).

A fixed value written directly in code, such as numbers (42), strings ("hello"), lists ([1, 2, 3]), or booleans (True).

String interpolation via f-strings or the .format() method to insert variable values directly into a string.

A safe function in ast that evaluates strings containing Python literals into their corresponding objects.

A variable defined within a function or block and accessible only within that scope.

A synchronization primitive from the threading module that prevents multiple threads from accessing shared resources simultaneously.

The standard logging framework providing levels, handlers, and formatters to record events and debug production code.

A control structure (for or while) that repeatedly executes a block of code until a condition changes.

A language closer to machine code, like C or assembly; Python is considered high-level, but can interface with low-level code via extensions.

Special methods surrounded by double underscores (e.g., __init__, __add__) that enable operator overloading and customize object behavior.

The script that is run as the main program, identified by __name__ == "__main__".

A built-in function that applies a given function to every item of an iterable, returning an iterator with the results.

The process of converting Python objects into a byte stream for storage or transmission, often used internally by pickle and for .pyc files.

A pattern matching construct introduced in Python 3.10 using the match and case keywords.

A standard library module providing mathematical functions like sqrt(), sin(), and constants like pi.

Memory Leak is a situation where memory is allocated but never released, potentially causing excessive memory usage over time.

A built-in object that allows Python code to access the internal data of an object that supports the buffer protocol without copying.

A class of a class that controls class creation, enabling customization or enforcement of patterns at class-definition time.

The order in which base classes are searched when executing a method, available via the __mro__ attribute.

Memory maps a file for efficient, random-access I/O without loading the entire file into memory.

A file containing Python definitions and statements, which can be imported into other scripts using the import statement.

Modifying or extending code at runtime by changing classes, methods, or modules without altering the original source.

A standard library module that runs processes in parallel to bypass the GIL, ideal for CPU-bound tasks.

An object whose state or contents can be changed after creation, such as lists, dictionaries, and sets.

Optional static typing annotations (via the typing module) and tools like mypy to catch type errors before runtime.

A factory function in collections that creates tuple subclasses with named fields for more readable code.

A mapping from names to objects (e.g., local, global, builtins). Namespaces prevent name collisions and scope variables.

A special floating-point value representing undefined or unrepresentable results, such as 0.0 / 0.0. Accessible via math.nan or float('nan').

Using negative numbers to index sequences, where -1 refers to the last element, -2 to the second last, and so on.

A function defined inside another function, often used for encapsulation or closures.

A comprehension inside another comprehension, used to flatten or transform multi-dimensional structures.

Endpoints for sending and receiving data over a network, handled in Python via the socket module.

Any class that explicitly or implicitly inherits from object. In Python 3, all classes are new-style by default.

A statement or operation that does nothing, often represented by the pass statement in Python.

A special singleton object in Python represents the absence of a value or a null reference.

A special singleton returned by special methods to indicate that an operation is not supported for the given operands.

A file path format used by Windows NT and its derivatives, often requiring escaping backslashes in Python strings.

A core library for numerical arrays and vectorized operations. It’s the foundation for scientific computing and data analysis in Python.

An Object is an instance of a class that encapsulates data (attributes) and behavior (methods). In Python nearly everything is an object.

A base-8 number system using digits 0–7. In Python, octal literals are written with a 0o prefix (e.g., 0o755).

A sequence of 8 bits, equivalent to a byte; commonly used in networking contexts.

A numeric value indicating a position relative to a starting point, such as byte offsets in files or index offsets in sequences.

Importing modules only when they are needed during runtime, reducing initial load time.

A short Python statement that accomplishes a task in a single line of code.

The string argument in open() that specifies how a file is accessed, such as 'r' for read or 'wb' for binary write.

A symbol or function that performs an operation, such as arithmetic (+, -), comparison (==, <), or logical (and, or).

Defining special methods (like __add__, __eq__) in a class to customize the behavior of operators for its instances.

The process of improving code performance or memory usage through algorithmic improvements, data structure choice, or built-in optimizations.

A deprecated standard library module for parsing command-line options, replaced by argparse.

A dictionary subclass from collections that preserves insertion order (now the default for dict since Python 3.7+).

A layer that maps database tables to Python classes so you can work with objects instead of raw SQL (e.g., SQLAlchemy, Django ORM).

A directory of Python modules, typically with an __init__.py, used to organize and distribute related code.

An object representing a filesystem path that implements __fspath__(), accepted by os and pathlib.

A design document describing new features, processes, or standards for Python; PEPs guide language evolution and conventions.

A built-in binary serialization protocol for Python objects. Convenient for Python-only usage but unsafe for untrusted data.

The standard package installer for Python that fetches packages from PyPI and installs them into environments.

APIs to discover package metadata, versions, and entry points; importlib.metadata is the modern approach.

Tools such as cProfile and timeit that measure execution time and identify performance bottlenecks.

A decorator that makes a method behave like an attribute with getter/setter semantics, keeping interfaces clean and controlled.

The Python Package Index, the central repository where packages are published and installed using pip.

A modern configuration file that centralizes build and packaging metadata for Python projects (PEP 518/621).

Interactive environments for exploratory coding. IPython improves ergonomics; Jupyter displays code, output, and rich media in notebooks.

An open-source geographic information system that can be automated or extended using Python scripting.

A declarative language for designing UI in the Qt framework; accessible from Python through PyQt or PySide bindings.

In XML processing, the namespace-qualified name of an element or attribute, handled in Python via libraries like xml.etree.ElementTree.

A two-dimensional barcode that can store data such as URLs; Python supports generation and decoding via libraries like qrcode and pyzbar.

A time complexity of O(n²), where runtime grows proportionally to the square of the input size.

The qualified name of a function or class showing nesting; helpful for debugging and reflection.

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.

The key-value pairs in a URL after the ?, accessible in Python via urllib.parse or web frameworks.

Thread-safe FIFO, LIFO, and priority queues useful for producer-consumer patterns and inter-thread coordination.

An efficient selection algorithm for finding the k-th smallest element in an unordered list, related to Quicksort.

A divide-and-conquer sorting algorithm that partitions data around a pivot, achieving average O(n log n) time complexity.

A keyword used to trigger an exception in Python, optionally specifying the exception type and message.

Utilities for pseudo-random number generation, sampling, and shuffling. Not cryptographically secure — use secrets for that.

An immutable sequence of integers used commonly in loops. It is memory-efficient and supports slicing-like behavior.

A string prefixed with r or R where backslashes are treated literally, useful for regex patterns and Windows file paths.

A file access mode ('r' or 'rb') that opens a file for reading without modifying it.

Recursion is a programming technique where a function calls itself directly or indirectly to solve a problem.

An in-memory key-value store often accessed from Python using libraries like redis-py for caching and messaging.

A function from functools that cumulatively applies another function to items in an iterable, reducing it to a single value.

CPython primarily uses reference counting and a cyclic garbage collector to manage memory and free unreachable objects.

Regular expression support for searching, matching, and replacing text. Powerful but can reduce readability if overused.

Importing modules using a relative path within a package, denoted by leading dots (e.g., from . import module).

An interactive Python shell that reads user input, evaluates it, prints the result, and repeats.

A built-in function that returns the string representation of an object, ideally one that can be passed to eval() to recreate it.

A popular third-party package for making HTTP requests in a simpler way than the standard urllib.

A plain list of project dependencies (often pinned) used to reproduce environments with pip install -r.

A warning raised when resources like files or sockets are not properly closed.

The result a function passes back to its caller via return. If omitted the function returns None.

An unordered collection of unique, hashable items supporting fast membership tests and standard set operations.

A packaging library used to build and distribute Python projects; historically tied to setup.py workflows.

An object or syntax (start:stop:step) representing a subsequence; used to extract parts of lists, tuples, and strings.

A low-level networking module for TCP/UDP communication that underlies higher-level HTTP and WebSocket libraries.

Built-in utilities to sort iterables; use the key= parameter to sort by computed attributes while keeping the sort stable.

A flexible ORM and SQL toolkit that provides both high-level ORM features and low-level SQL expression language control.

The sequence of function calls shown when an exception occurs, used to identify where errors originate for debugging.

The rich set of modules that ship with Python, such as os, sys, json, and itertools.

Python prefers duck typing (behavior-based). Static typing tools (like mypy) provide stricter checks without changing runtime behavior.

Module to spawn and communicate with external processes, replace older modules, and manage process I/O safely.

A built-in helper to call methods from a parent class, simplifying cooperative multiple inheritance when used properly.

Syntax is the set of rules defining valid Python code; linters and formatters help keep code consistent and readable.

The list of directories Python searches to resolve imports. It can be modified but prefer packaging over manual tweaks.

An exception raised when Python detects inconsistent use of tabs and spaces in indentation.

A shorthand conditional expression written as a if condition else b.

A class from the io module that provides a text interface to a buffered raw stream, handling encoding and decoding.

The standard library module for threads. Threads share memory but are affected by the GIL for CPU-bound work.

A measure of how an algorithm’s runtime scales with input size, often expressed using Big O notation.

A standard library module for time-related functions, such as sleeping, measuring performance, and working with timestamps.

A limit on how long an operation can take before it is aborted, often used in network requests and threading.

The process of breaking Python source code into tokens, which are the smallest meaningful elements for parsing.

The report Python generates when an exception occurs, showing the call stack at the point of error.

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.

A control structure used to catch and handle exceptions via try, except, else, and finally clauses.

An immutable, ordered collection of elements, written with parentheses (1, 2, 3).

type is the runtime object for types; the typing module offers static typing constructs for annotations.

An exception raised when an operation or function is applied to an object of an inappropriate type.

A numeric value assigned to each user in an operating system; accessible in Python via os.getuid() on Unix-like systems.

A universal character encoding standard that supports virtually all written languages. Python 3 strings are Unicode by default.

A string escape sequence format (e.g., \u2764) used to represent Unicode characters in Python source code.

A type hint that allows multiple possible types, written as X | Y (Python 3.10+) or typing.Union[X, Y].

Testing frameworks: unittest is built-in and class-based; pytest is third-party and favored for concise tests and powerful fixtures.

The process of extracting values from sequences or iterables into variables, using * for positional and ** for keyword arguments.

A dictionary method (dict.update()) that merges key-value pairs from another mapping or iterable into the dictionary.

A standard library package for fetching data across the web using URLs, with modules like urllib.request and urllib.parse.

The primary time standard by which the world regulates clocks; Python’s datetime supports UTC-aware objects.

An exception raised when a function receives an argument of the correct type but with an inappropriate value, such as int("abc").

A named reference to an object in memory. Python variables are dynamically typed and can be rebound to different types.

The region of code where a variable is accessible, including local, enclosing, global, and built-in scopes.

The process of applying operations to entire arrays or sequences at once, often via NumPy, for speed and code clarity.

A system (e.g., Git) for tracking changes to source code and coordinating work among multiple developers.

Dynamic views returned by dict.keys(), dict.items(), and dict.values() that reflect dictionary changes.

An isolated Python environment (via venv, virtualenv, or Conda) to manage project-specific dependencies.

A lightweight concurrency unit (not native to Python) conceptually similar to asyncio tasks, used in some languages and experimental Python runtimes.

In computing, data that is lost when power is removed; in Python contexts, often refers to temporary in-memory data or non-persistent caches.

The computer architecture model where program instructions and data share the same memory and bus, influencing Python’s execution model indirectly.

A utility to traverse directory trees yielding directory names and file lists; commonly used when processing files recursively.

Weak references let you reference objects without increasing their reference count, enabling caches that don’t prevent garbage collection.

Frameworks for building web apps and APIs, e.g., Flask (lightweight), Django (full-featured), and FastAPI (async, modern).

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 binary distribution format for Python packages that speeds installation by avoiding local builds.

A control structure that repeatedly executes a block of code as long as a given condition evaluates to True.

Any space, tab, or newline character used to separate tokens in Python code; indentation using whitespace is syntactically significant.

An import statement like from module import * that imports all public names from a module into the current namespace (generally discouraged).

A control-flow construct that simplifies resource management by ensuring __enter__ and __exit__ methods are called, often used for files or locks.

The current folder from which a Python script is run; accessible and changeable with os.getcwd() and os.chdir().

A helper from functools that preserves the original function’s metadata when creating decorators.

A file access mode ('w' or 'wb') that overwrites a file or creates it if it doesn’t exist.

Server interfaces for Python web apps. WSGI is synchronous; ASGI supports asynchronous protocols like WebSocket and HTTP/2.

A reference implementation of the WSGI standard in Python’s standard library, useful for simple web servers or testing.

The horizontal axis in a two-dimensional plot or graph, often representing independent variables in data visualization.

An optimized gradient boosting library used in machine learning, accessible via its Python API.

Extensible Markup Language, a markup format for storing and transporting structured data. In Python, handled by modules like xml.etree.ElementTree or lxml.

Common data interchange formats; Python provides built-in and third-party modules to parse and produce them (json, xml).

A remote procedure call protocol using XML to encode requests and responses over HTTP. Python’s xmlrpc module supports it.

A bitwise operator (^) that returns 1 for each bit position where the corresponding bits of two integers are different.

A memory-efficient range-like object in Python 2 that generated numbers lazily. Replaced by range in Python 3.

X Virtual FrameBuffer, a display server implementation that enables GUI applications to run without a physical display. Can be used with Python GUI tests.

The vertical axis in a two-dimensional plot or graph, often representing dependent variables in data visualization libraries like Matplotlib.

A human-readable data serialization format often used for configuration files. In Python, handled by libraries like PyYAML or ruamel.yaml.

A warning raised by PyYAML when using yaml.load() without specifying a loader, due to potential security issues.

A time unit representing 365 or 366 days. In Python, handled through datetime.date or datetime.datetime objects.

A user interface prompt that expects a yes/no answer. Often implemented in GUI frameworks or CLI programs.

A keyword that returns a value from a generator and pauses its state so it can resume later, enabling lazy iteration.

A syntax that delegates part of a generator’s operations to another generator, enabling generator composition.

A commercial performance profiling tool that supports Python via integrations, useful for identifying bottlenecks.

A space-filling curve used in spatial indexing to preserve locality when mapping multidimensional data to one dimension.

Adding leading zeros to a number or string for formatting, often using str.zfill() or format specifiers.

An exception raised when attempting to divide a number by zero using /, //, or %.

A built-in function that aggregates elements from multiple iterables into tuples, stopping at the shortest iterable.

Modules for compression and archive handling, supporting common formats and streaming operations.

A feature allowing Python to import modules directly from ZIP archives via zipimport.

A standard library module for reading and writing ZIP archive files.

A process that has completed execution but still has an entry in the process table, usually awaiting acknowledgment by its parent process.

A standard library module (Python 3.9+) for IANA time zone support, enabling accurate datetime conversions.