Reference · Vocabulary

Glossary

332 terms from across the course, from Python syntax to data structures, data science, machine learning, data engineering, and professional tooling. Each entry has a short definition and a link to the module that teaches it.

⏱ Look things up as you go118 Python, 60 CS, 30 Data science, 39 ML, 32 Data engineering, 53 Tooling

Terms A–Z

A

A shortest-path algorithm that expands nodes by cost so far plus a heuristic estimate of the remaining cost. M31 Graph Algorithms
Abstract base class (ABC) Python
A class from abc that declares abstract methods subclasses must implement; it cannot be instantiated itself. M12 Inheritance, Composition & Protocols
ACID Data engineering
Atomicity, Consistency, Isolation, Durability: the guarantees that make database transactions reliable. M44 Databases & SQL
Activation function ML
A nonlinear function (ReLU, sigmoid, tanh) applied to a neuron's output so networks can model nonlinear relationships. M58 Neural Networks from Scratch
Adjacency list CS
A graph representation mapping each vertex to a list of its neighbors; O(V + E) space, ideal for sparse graphs. M26 Graphs
Adjacency matrix CS
A V × V grid whose cell (i, j) records an edge from i to j; O(1) edge checks but O(V²) space. M26 Graphs
Algorithm CS
A finite, precise sequence of steps that solves a problem. M19 Complexity & Big-O
Amortized analysis CS
Averaging the cost of operations over a sequence, so rare expensive steps (like list resizing) still give O(1) per operation. M19 Complexity & Big-O
Annotation Python
Metadata attached to a parameter, return value, or variable with : or ->, usually a type hint. In 3.14 annotations are evaluated lazily (PEP 649). M16 Type Hints & Static Typing
annotationlib Python
The 3.14 standard-library module for reading annotations in different formats (VALUE, FORWARDREF, STRING) via get_annotations(). M16 Type Hints & Static Typing
Apache Arrow Data science
A language-independent columnar in-memory format that lets tools like pandas, Polars, and DuckDB share data without copying. M52 Polars, Arrow & Columnar Data
API Tooling
Application Programming Interface: the documented way programs talk to a library or service, such as a REST API over HTTP. M45 Web & APIs
*args / **kwargs Python
Parameters that collect any extra positional arguments into a tuple and extra keyword arguments into a dict. M05 Functions
Argument Python
A value passed to a function when it is called. Arguments fill the function's parameters by position or by keyword. M05 Functions
Assertion Python
An assert condition, message statement that raises AssertionError when the condition is false; pytest uses plain asserts for tests. M17 Testing with pytest
Async / await Python
Keywords for defining coroutines (async def) and suspending them until an awaitable finishes (await), so one thread can interleave many I/O tasks. M38 Async Programming with asyncio
Attribute Python
A name attached to an object and accessed with a dot, such as user.name or list.append. M10 Classes & Objects
Autograd ML
Automatic differentiation that records operations on tensors and computes gradients for you, as in PyTorch. M58 Neural Networks from Scratch
AVL tree CS
A self-balancing binary search tree whose subtrees differ in height by at most one, restored with rotations. M24 Trees & Binary Search Trees

B

Backpressure Data engineering
A mechanism that slows producers when consumers cannot keep up, so a streaming system does not run out of memory. M63 Streaming & Big Data
Backpropagation ML
Computing the gradient of the loss with respect to every weight by applying the chain rule backward through the network. M58 Neural Networks from Scratch
Backtracking CS
Building a solution step by step and undoing a choice as soon as it cannot lead to a valid answer. M33 Greedy Algorithms & Backtracking
Base case CS
The condition in a recursive function that returns directly without recursing, stopping the recursion. M28 Recursion & Divide and Conquer
Batch processing Data engineering
Processing data in large scheduled chunks (hourly, daily) rather than continuously. M60 Data Engineering Foundations
Bellman-Ford CS
A shortest-path algorithm that relaxes every edge V − 1 times; handles negative weights and detects negative cycles in O(VE). M31 Graph Algorithms
Graph traversal that visits vertices in order of distance from the start using a queue; finds shortest paths in unweighted graphs. M26 Graphs
Bias-variance trade-off ML
Simple models underfit (high bias) and flexible models overfit (high variance); good models balance the two. M55 Machine Learning Foundations
Big-O notation CS
An upper bound on how an algorithm's cost grows with input size, ignoring constant factors, such as O(n log n). M19 Complexity & Big-O
Finding a target in sorted data by repeatedly halving the search interval; O(log n). M30 Searching & Array Techniques
Binary search tree (BST) CS
A binary tree where each node's left subtree holds smaller keys and its right subtree larger ones. M24 Trees & Binary Search Trees
Bit manipulation CS
Working directly with an integer's binary digits using operators like &, |, ^, ~, <<, and >>. M34 Strings, Bits & Number Theory
Black-box testing Tooling
Testing behavior through public inputs and outputs without relying on internal implementation details. M17 Testing with pytest
Bloom filter CS
A compact probabilistic set that can say "definitely not present" or "probably present", using a bit array and k hash functions. M27 Advanced Structures
Bound method Python
A function retrieved from an instance, with that instance already filled in as self. M10 Classes & Objects
Breakpoint Tooling
A marker where a debugger pauses execution; breakpoint() drops into pdb. M43 Debugging & Secure Code
Broadcasting Data science
NumPy's rules for combining arrays of different shapes by virtually stretching size-1 dimensions, without copying data. M48 NumPy Fundamentals
Built-in Python
A name available everywhere without importing, such as print, len, or ValueError; they live in the builtins module. M01 First Steps
Bytecode Python
The compact instruction format that CPython compiles source code into and then executes; cached in __pycache__ as .pyc files. M01 First Steps
bytes Python
An immutable sequence of integers 0–255 representing raw binary data; text becomes bytes by encoding it (for example to UTF-8). M03 Strings & Text

C

Call stack CS
The stack of active function frames; each call pushes a frame and each return pops it. M28 Recursion & Divide and Conquer
Callable Python
Any object you can call with (): functions, methods, classes, and instances whose class defines __call__. M15 Decorators & Context Managers
CI (continuous integration) Tooling
Automatically running checks (lint, types, tests) on every push or pull request, for example with GitHub Actions. M42 Code Quality & Tooling
Class Python
A blueprint that defines the attributes and methods of its instances; creating an instance is calling the class. M10 Classes & Objects
Class method Python
A method decorated with @classmethod that receives the class (cls) rather than an instance; often used as an alternative constructor. M10 Classes & Objects
Classification ML
Supervised learning that predicts a discrete label, such as spam or not spam. M55 Machine Learning Foundations
Closure Python
A function that remembers variables from the enclosing scope where it was defined, even after that scope has finished. M15 Decorators & Context Managers
Clustering ML
Grouping unlabeled data points so points in the same group are similar, as in k-means. M57 Unsupervised Learning & Embeddings
Collision (hashing) CS
Two different keys mapping to the same hash-table slot, resolved by chaining or probing. M23 Hash Tables & Sets
Composition Python
Building objects by holding other objects as attributes ("has-a") instead of inheriting from them ("is-a"). M12 Inheritance, Composition & Protocols
Comprehension Python
A compact expression that builds a list, set, or dict from an iterable, such as [x * x for x in xs if x > 0]. M06 Collections
conda-forge Tooling
A community-maintained channel of conda packages for many languages; Pixi's default source of packages. M41 Packaging & Environments with Pixi
Confidence interval Data science
A range computed from a sample that, under repeated sampling, contains the true parameter a stated fraction of the time (e.g. 95%). M54 Statistics & Probability
Context manager Python
An object with __enter__ and __exit__ used in a with statement to set up and reliably clean up a resource. M15 Decorators & Context Managers
Conventional Commits Tooling
A commit-message convention like feat(parser): add t-string support that tools use to generate changelogs. M42 Code Quality & Tooling
Coroutine Python
The object returned by calling an async def function; it runs only when awaited or scheduled as a task. M38 Async Programming with asyncio
Correlation Data science
A measure from −1 to 1 of how strongly two variables move together linearly; correlation does not imply causation. M54 Statistics & Probability
Cosine similarity ML
The cosine of the angle between two vectors; 1 means same direction, commonly used to compare embeddings. M57 Unsupervised Learning & Embeddings
Coverage Tooling
The share of code lines or branches executed by the test suite, measured with pytest-cov. M17 Testing with pytest
CPython Python
The reference implementation of Python, written in C, which is what python.org and conda-forge ship. M01 First Steps
Cross-validation ML
Estimating model performance by training and evaluating on several different train/validation splits (folds). M56 scikit-learn in Practice
CTE (common table expression) Data engineering
A named temporary result defined with WITH in SQL, used to make complex queries readable. M61 Analytical SQL & DuckDB
Cycle detection CS
Determining whether a graph contains a cycle, typically with DFS coloring or union-find. M31 Graph Algorithms

D

Dask Data engineering
A Python library for parallel and out-of-core computing that scales pandas- and NumPy-style code across cores or clusters. M63 Streaming & Big Data
Data drift ML
A change over time in the distribution of production inputs compared with the training data, which degrades model accuracy. M59 ML in Production
Data lake Data engineering
Cheap storage holding raw files (often Parquet) of any structure, queried later by engines like DuckDB or Spark. M60 Data Engineering Foundations
Data leakage ML
Information from the test set or the future sneaking into training, producing over-optimistic scores. M56 scikit-learn in Practice
Data quality Data engineering
How fit data is for use: complete, valid, accurate, consistent, and timely; enforced by validation checks in pipelines. M62 Pipelines, Orchestration & Data Quality
Data warehouse Data engineering
A database optimized for analytical queries over integrated, cleaned historical data. M60 Data Engineering Foundations
Dataclass Python
A class decorated with @dataclass that gets __init__, __repr__, and __eq__ generated from its annotated fields. M13 Dataclasses, Enums & Records
DataFrame Data science
A two-dimensional table of labeled columns, each with its own dtype, as in pandas and Polars. M51 pandas: Series & DataFrames
Debugger Tooling
A tool to pause a program, inspect variables, and step through code; Python's built-in one is pdb. M43 Debugging & Secure Code
Decision tree ML
A model that predicts by asking a sequence of feature threshold questions arranged as a tree. M56 scikit-learn in Practice
Decorator Python
A callable that takes a function or class and returns a replacement, applied with @name above the definition. M15 Decorators & Context Managers
Deep copy Python
A copy that recursively duplicates nested objects too (copy.deepcopy), so changes to the copy never affect the original. M06 Collections
Dependency injection Tooling
Passing a component's collaborators in (as parameters) instead of creating them inside, which makes code testable and flexible. M46 Software Design & Architecture
Deque CS
A double-ended queue supporting O(1) insertion and removal at both ends; collections.deque in Python. M22 Stacks, Queues & Deques
Descriptor Python
An object defining __get__, __set__, or __delete__ that controls attribute access on another class; property is one. M36 Metaprogramming
Design pattern Tooling
A named, reusable solution to a common design problem, such as Strategy, Adapter, or Observer. M46 Software Design & Architecture
Graph traversal that goes as deep as possible before backtracking, using recursion or an explicit stack. M26 Graphs
Dictionary (dict) Python
A mutable mapping from hashable keys to values, implemented as a hash table and ordered by insertion. M06 Collections
Dijkstra's algorithm CS
Single-source shortest paths for non-negative edge weights using a priority queue; O((V + E) log V) with a binary heap. M31 Graph Algorithms
Dimension table Data engineering
A table of descriptive attributes (customer, product, date) that fact tables reference in a star schema. M60 Data Engineering Foundations
Directed acyclic graph (DAG) CS
A directed graph with no cycles, such as a task-dependency graph; it always has a topological order. M26 Graphs
Distribution Data science
A description of how likely each value of a random variable is, such as the normal or binomial distribution. M54 Statistics & Probability
Divide and conquer CS
Solving a problem by splitting it into smaller independent subproblems, solving them, and combining the results, as in merge sort. M28 Recursion & Divide and Conquer
Docstring Python
A string literal as the first statement of a module, class, or function that documents it; available as __doc__. M05 Functions
Dot product Data science
The sum of element-wise products of two equal-length vectors; it measures how aligned they are. M47 Vectors & Matrices from Scratch
dtype Data science
The data type of a NumPy array's elements (such as float64 or int32), fixed for the whole array. M48 NumPy Fundamentals
Duck typing Python
Using an object based on the methods it has rather than its declared type: if it has .read(), treat it like a file. M12 Inheritance, Composition & Protocols
DuckDB Data engineering
An in-process analytical SQL database that queries Parquet, CSV, and DataFrames directly and very fast. M61 Analytical SQL & DuckDB
Dunder method Python
A "double underscore" special method such as __len__ or __eq__ that Python calls to implement built-in operations. M11 The Python Data Model
Dynamic array CS
A resizable array that over-allocates capacity so appends are amortized O(1); Python's list. M20 Arrays & Dynamic Arrays
Dynamic programming CS
Solving problems with overlapping subproblems by storing each subproblem's answer instead of recomputing it. M32 Dynamic Programming
Dynamic typing Python
Types belong to objects, not variables, and are checked at run time; a name can refer to an int now and a str later. M02 Values, Types & Variables

E

Edit distance CS
The minimum number of insertions, deletions, and substitutions needed to turn one string into another (Levenshtein distance). M32 Dynamic Programming
Editable install Tooling
Installing your own package so that changes to its source are visible immediately, e.g. { path = ".", editable = true } in Pixi. M41 Packaging & Environments with Pixi
Eigenvector Data science
A nonzero vector that a matrix only scales (by its eigenvalue) without changing its direction. M49 Linear Algebra with NumPy & SciPy
ELT Data engineering
Extract, Load, Transform: load raw data into the warehouse first and transform it there with SQL. M60 Data Engineering Foundations
Embedding ML
A dense vector representation of an item (word, user, image) where similar items are close together. M57 Unsupervised Learning & Embeddings
Encapsulation Python
Bundling data with the methods that operate on it and hiding internal details behind a public interface. M10 Classes & Objects
Encoding Python
The rule that converts text to bytes and back, such as UTF-8; always pass encoding= to open(). M09 Files & Data Formats
Ensemble ML
A model that combines many models' predictions, such as random forests or gradient boosting. M56 scikit-learn in Practice
Enum Python
A class whose members are a fixed set of named constants, from the enum module (Enum, IntEnum, StrEnum). M13 Dataclasses, Enums & Records
Environment (Pixi) Tooling
A named, installed set of packages built from one or more features, stored in .pixi/envs/<name>. M41 Packaging & Environments with Pixi
Epoch ML
One full pass of the training algorithm over the entire training dataset. M58 Neural Networks from Scratch
Estimator ML
Any scikit-learn object with fit(); predictors add predict() and transformers add transform(). M56 scikit-learn in Practice
ETL Data engineering
Extract, Transform, Load: pull data from sources, clean and reshape it, and then load it into a target store. M60 Data Engineering Foundations
Event loop Python
The scheduler at the heart of asyncio that runs coroutines, switching between them whenever one awaits I/O. M38 Async Programming with asyncio
Exception Python
An object signaling an error or unusual condition; raising it unwinds the call stack until a matching except handles it. M07 Errors & Exceptions
Exception chaining Python
Linking a new exception to the one that caused it with raise New(...) from err, so tracebacks show both. M07 Errors & Exceptions
Exception group Python
An ExceptionGroup bundles several exceptions raised together (for example by a TaskGroup); handle them with except*. M07 Errors & Exceptions
Exploratory data analysis (EDA) Data science
Investigating a dataset with summaries and plots to understand its structure and problems before modeling. M53 Data Visualization
Expression Python
Code that evaluates to a value, such as 2 + 3 or len(xs); contrast with a statement. M01 First Steps

F

f-string Python
A string literal prefixed with f whose {expressions} are evaluated and formatted immediately, e.g. f"{total:.2f}". M03 Strings & Text
Fact table Data engineering
The central table in a star schema holding measurable events (sales, clicks) with foreign keys to dimensions. M60 Data Engineering Foundations
FastAPI Tooling
A Python web framework for building typed HTTP APIs with automatic validation and documentation. M45 Web & APIs
Feature ML
An input variable used by a model to make predictions. M55 Machine Learning Foundations
Feature (Pixi) Tooling
A named bundle of dependencies, tasks, and settings in pixi.toml that environments are composed from. M41 Packaging & Environments with Pixi
Feature engineering ML
Creating, transforming, or selecting input features to make patterns easier for a model to learn. M56 scikit-learn in Practice
Fenwick tree CS
A binary indexed tree supporting prefix sums and point updates in O(log n) using a single array. M27 Advanced Structures
Fixture (pytest) Tooling
A function decorated with @pytest.fixture that provides setup (and teardown) to tests that request it by name. M17 Testing with pytest
Foreign key Data engineering
A column referencing another table's primary key, enforcing a relationship between the tables. M44 Databases & SQL
Free-threaded build Python
A CPython build without the GIL (python3.14t), officially supported in 3.14 (PEP 779), in which threads can run Python code in parallel. M37 Concurrency: Threads, Processes & Interpreters
frozendict Python
An immutable, hashable mapping added as a built-in in Python 3.15 (PEP 814). M18 Functional Python
Frozenset Python
An immutable, hashable version of set, usable as a dict key or set member. M06 Collections
Function Python
A named, reusable block of code defined with def that takes parameters and returns a value (None by default). M05 Functions

G

Garbage collection Python
Automatic memory reclamation; CPython frees most objects by reference counting and uses a cycle collector for reference cycles. M39 Performance & Profiling
Generator Python
A function containing yield; calling it returns an iterator that produces values lazily, pausing between them. M14 Iterators & Generators
Generator expression Python
A lazy comprehension in parentheses, such as (x * x for x in xs), that yields values one at a time. M14 Iterators & Generators
Generic Python
A class or function parameterized by a type variable, written def first[T](xs: list[T]) -> T in PEP 695 syntax. M16 Type Hints & Static Typing
GIL (global interpreter lock) Python
A lock in standard CPython that lets only one thread execute Python bytecode at a time; removed in the free-threaded build. M37 Concurrency: Threads, Processes & Interpreters
Git Tooling
A distributed version-control system that records snapshots (commits) of a project's history. M42 Code Quality & Tooling
Gradient descent ML
An optimization method that repeatedly steps parameters in the direction that most decreases the loss. M55 Machine Learning Foundations
Graph CS
A set of vertices (nodes) connected by edges, possibly directed or weighted. M26 Graphs
Greedy algorithm CS
An algorithm that makes the locally best choice at each step; correct only when the problem has the greedy-choice property. M33 Greedy Algorithms & Backtracking
groupby Data science
The split-apply-combine operation: split rows into groups by key, aggregate each group, and combine the results. M51 pandas: Series & DataFrames

H

Hash function CS
A function mapping data to a fixed-size integer, ideally spreading keys uniformly; equal keys must hash equally. M23 Hash Tables & Sets
Hash table CS
A structure that stores key-value pairs in slots chosen by hashing the key, giving O(1) average lookup. M23 Hash Tables & Sets
Hashable Python
An object with a hash value that never changes during its lifetime and an equality consistent with it; required for dict keys and set members. M23 Hash Tables & Sets
Heap CS
A complete binary tree where every parent is ≤ (min-heap) or ≥ (max-heap) its children, stored compactly in an array. M25 Heaps & Priority Queues
Higher-order function Python
A function that takes or returns other functions, such as map, sorted(key=...), and decorators. M18 Functional Python
HTTP Tooling
The request/response protocol of the web, with methods like GET and POST and status codes like 200 and 404. M45 Web & APIs
httpx Tooling
A modern Python HTTP client with both synchronous and async APIs. M45 Web & APIs
Huffman coding CS
A greedy, optimal prefix-free code that gives frequent symbols shorter bit strings. M33 Greedy Algorithms & Backtracking
Hyperparameter ML
A setting chosen before training (learning rate, tree depth) rather than learned from data; tuned with search and cross-validation. M56 scikit-learn in Practice
Hypothesis test Data science
A procedure that measures how surprising the data would be if a null hypothesis were true, summarized by a p-value. M54 Statistics & Probability

I

Idempotent Data engineering
An operation that has the same effect whether it runs once or many times; essential for safely re-running pipelines. M62 Pipelines, Orchestration & Data Quality
Identity Python
Which object a name refers to, compared with is and shown by id(); distinct from equality (==). M02 Values, Types & Variables
Immutable Python
An object whose value cannot change after creation, such as int, str, tuple, and frozenset. M02 Values, Types & Variables
Import system Python
The machinery that finds, loads, and caches modules when you write import; loaded modules live in sys.modules. M08 Modules, Packages & Pixi Projects
In-place algorithm CS
An algorithm that uses only O(1) (or O(log n)) extra memory beyond its input. M29 Sorting
Incremental load Data engineering
Processing only new or changed data since the last run instead of everything. M62 Pipelines, Orchestration & Data Quality
Index (database) Data engineering
A data structure (usually a B-tree) that speeds up lookups on a column at the cost of extra storage and slower writes. M44 Databases & SQL
Inheritance Python
Defining a class in terms of a parent class so it reuses and can override the parent's attributes and methods. M12 Inheritance, Composition & Protocols
Instance Python
A concrete object created from a class, with its own attribute values. M10 Classes & Objects
Integration test Tooling
A test that exercises several components together against real resources such as files or databases. M17 Testing with pytest
Interpreter Python
The program that reads and executes Python code; also a single isolated runtime inside a process (see subinterpreter). M01 First Steps
Introspection Python
Examining objects at run time with tools like type(), dir(), getattr(), and the inspect module. M36 Metaprogramming
Iterable Python
Any object you can loop over: it returns an iterator from iter(), e.g. lists, strings, dicts, files, and generators. M14 Iterators & Generators
Iterator Python
An object with __next__ that yields items one at a time and raises StopIteration when exhausted. M14 Iterators & Generators
itertools Python
The standard-library module of fast building blocks for iterators, such as chain, islice, groupby, and batched. M14 Iterators & Generators

J

JIT compiler Tooling
A just-in-time compiler that translates hot code to machine code while the program runs; CPython's is experimental in 3.14 (PYTHON_JIT=1). M39 Performance & Profiling
Join Data engineering
Combining rows from two tables based on matching key values (inner, left, right, full outer). M44 Databases & SQL
JSON Tooling
JavaScript Object Notation, a text format for nested data; read and written with Python's json module. M09 Files & Data Formats

K

k-means ML
A clustering algorithm that alternates assigning points to the nearest of k centroids and moving each centroid to its points' mean. M57 Unsupervised Learning & Embeddings
Kafka Data engineering
A distributed, durable log for streaming events, organized into topics split into partitions. M63 Streaming & Big Data
Keyword argument Python
An argument passed by parameter name, such as sorted(xs, reverse=True). M05 Functions
KMP algorithm CS
Knuth-Morris-Pratt string search, which uses a failure table to find a pattern in O(n + m) without re-scanning text. M34 Strings, Bits & Number Theory

L

Label ML
The target value a supervised model learns to predict. M55 Machine Learning Foundations
Lambda Python
A small anonymous function written as a single expression, such as lambda x: x * 2. M05 Functions
Lazy evaluation (Polars) Data science
Building a query plan first and executing it only when results are requested, so the engine can optimize the whole query. M52 Polars, Arrow & Columnar Data
Lazy import Python
Python 3.15's lazy import (PEP 810), which binds a module name now but loads the module only on first use. M39 Performance & Profiling
Learning rate ML
The step size in gradient descent; too large diverges, too small learns slowly. M55 Machine Learning Foundations
LEGB rule Python
The order Python searches for a name: Local, Enclosing function, Global (module), then Built-in. M05 Functions
Linear regression ML
A model predicting a number as a weighted sum of features, fit by minimizing squared error. M56 scikit-learn in Practice
Linked list CS
A sequence of nodes where each node points to the next (and in a doubly linked list, the previous). M21 Linked Lists
Linter Tooling
A tool that flags likely bugs and style problems without running the code; this course uses ruff. M42 Code Quality & Tooling
List Python
A mutable, ordered sequence implemented as a dynamic array of references. M06 Collections
Literal Python
Source code that directly denotes a value, such as 42, "hi", or [1, 2]. M02 Values, Types & Variables
Load factor CS
The ratio of stored items to slots in a hash table; tables resize when it passes a threshold to keep operations fast. M23 Hash Tables & Sets
Lock (mutex) Python
A synchronization primitive (threading.Lock) that lets only one thread at a time run a critical section. M37 Concurrency: Threads, Processes & Interpreters
Lockfile Tooling
A file (pixi.lock) recording the exact version of every package for every platform, so installs are reproducible. M41 Packaging & Environments with Pixi
Logging Tooling
Recording events from a running program for later diagnosis; professional code uses structured logs (structlog) instead of print(). M42 Code Quality & Tooling
Logistic regression ML
A linear classifier that passes a weighted sum through the sigmoid function to output a probability. M56 scikit-learn in Practice
Loss function ML
A function measuring how wrong a model's predictions are, such as mean squared error or cross-entropy; training minimizes it. M55 Machine Learning Foundations
LRU cache CS
A fixed-size cache that evicts the least recently used item; built from a hash map plus a doubly linked list, or functools.lru_cache. M27 Advanced Structures

M

Matrix multiplication Data science
Combining an m × n and an n × p matrix into an m × p matrix where each entry is a row-column dot product; @ in Python. M47 Vectors & Matrices from Scratch
Memoization CS
Caching a function's results by its arguments so repeated calls return instantly; functools.cache in Python. M28 Recursion & Divide and Conquer
Merge sort CS
A stable divide-and-conquer sort that splits the list, sorts halves, and merges them; O(n log n) time, O(n) space. M29 Sorting
Metaclass Python
The class of a class; it controls how classes are created. The default metaclass is type. M36 Metaprogramming
Method Python
A function defined in a class body and called on instances, receiving the instance as its first parameter (self). M10 Classes & Objects
Method resolution order (MRO) Python
The order in which Python searches base classes for an attribute, computed with C3 linearization; see Class.__mro__. M12 Inheritance, Composition & Protocols
Minimum spanning tree CS
A subset of edges connecting all vertices of a weighted graph with minimum total weight, found by Prim's or Kruskal's algorithm. M31 Graph Algorithms
Mixin Python
A small class that adds one capability to others through multiple inheritance, not meant to stand alone. M12 Inheritance, Composition & Protocols
MLOps ML
Practices for deploying, monitoring, versioning, and retraining machine-learning models reliably in production. M59 ML in Production
Mocking Tooling
Replacing a dependency with a fake object in tests (unittest.mock) to isolate the code under test. M17 Testing with pytest
Model persistence ML
Saving a trained model to disk (for example with joblib or skops) and loading it later for predictions. M59 ML in Production
Modular arithmetic CS
Arithmetic on remainders after division by a modulus; pow(b, e, m) computes modular powers efficiently. M34 Strings, Bits & Number Theory
Module Python
A single .py file (or extension) whose top-level names form a namespace you can import. M08 Modules, Packages & Pixi Projects
Mutable Python
An object whose contents can change in place, such as list, dict, set, and most user-defined objects. M02 Values, Types & Variables
mypy Tooling
A static type checker that reads type hints and reports type errors without running the program. M16 Type Hints & Static Typing

N

Name binding Python
Associating a name with an object via assignment, def, import, and so on; names are references, not boxes. M02 Values, Types & Variables
NamedTuple Python
A tuple subclass with named fields (typing.NamedTuple), useful for lightweight immutable records. M13 Dataclasses, Enums & Records
Namespace Python
A mapping from names to objects, such as a module's globals or a function's locals. M05 Functions
ndarray Data science
NumPy's n-dimensional array: a block of same-typed values with a shape and strides. M48 NumPy Fundamentals
Nearest neighbors ML
Finding the training points closest to a query point; the basis of k-NN models and vector search. M57 Unsupervised Learning & Embeddings
Neural network ML
A model made of layers of weighted sums followed by nonlinear activations, trained with backpropagation. M58 Neural Networks from Scratch
None Python
Python's single null value, the default return value of functions; test for it with is None. M02 Values, Types & Variables
Norm Data science
A measure of a vector's length, such as the Euclidean (L2) norm or the Manhattan (L1) norm. M49 Linear Algebra with NumPy & SciPy
Normalization Data engineering
Structuring relational tables to remove duplication so each fact is stored once. M44 Databases & SQL

O

Orchestrator Data engineering
A tool (Airflow, Dagster, Prefect) that schedules pipeline tasks, tracks dependencies, retries failures, and records runs. M62 Pipelines, Orchestration & Data Quality
ORM Data engineering
Object-relational mapper: a library such as SQLAlchemy that maps database rows to Python objects. M44 Databases & SQL
Overfitting ML
A model learning noise in the training data so it performs well there but poorly on new data. M55 Machine Learning Foundations

P

p-value Data science
The probability of seeing data at least as extreme as observed if the null hypothesis were true; small values are evidence against it. M54 Statistics & Probability
Package Python
A directory of modules importable as a unit, usually with an __init__.py. M08 Modules, Packages & Pixi Projects
Parameter Python
A name in a function definition that receives an argument when the function is called. M05 Functions
Parametrize Tooling
@pytest.mark.parametrize runs one test function with many input/expected-output cases. M17 Testing with pytest
Parquet Data engineering
A compressed, columnar file format for analytics that stores a schema and lets engines read only needed columns. M60 Data Engineering Foundations
Partial application Python
Fixing some of a function's arguments to make a new function; functools.partial, with Placeholder slots in 3.14. M18 Functional Python
Partitioning Data engineering
Splitting data by a key (date, user id) so work can be parallelized and queries can skip irrelevant parts. M63 Streaming & Big Data
pathlib Tooling
The object-oriented filesystem path module; Path objects join with / and gained copy() and move() in 3.14. M09 Files & Data Formats
Pattern matching Python
The match/case statement that compares a value against structural patterns and binds parts of it. M04 Control Flow
PCA (principal component analysis) Data science
A linear method that finds the orthogonal directions of maximum variance, used to reduce dimensionality. M57 Unsupervised Learning & Embeddings
pdb Tooling
Python's built-in debugger; 3.14 can attach to a running process with python -m pdb -p PID (PEP 768). M43 Debugging & Secure Code
PEP Python
A Python Enhancement Proposal: the design document for a language or process change, such as PEP 8 (style) or PEP 750 (t-strings). M00 Setup: Python 3.14 with Pixi
PEP 8 Python
Python's official style guide for naming, layout, and formatting; ruff enforces most of it. M42 Code Quality & Tooling
Pipeline (scikit-learn) ML
A chain of preprocessing steps and a final estimator fit together, which prevents data leakage between splits. M56 scikit-learn in Practice
Pixi Tooling
A fast, cross-platform package and environment manager built on conda-forge and PyPI; the only tool this course uses to install Python and run code. M00 Setup: Python 3.14 with Pixi
pixi.toml Tooling
The Pixi manifest declaring a workspace's channels, platforms, dependencies, features, environments, and tasks. M41 Packaging & Environments with Pixi
Polars Data science
A fast DataFrame library built on Arrow with an expression API and a lazy query optimizer. M52 Polars, Arrow & Columnar Data
Polymorphism Python
Different types responding to the same method call in their own way, so code can work with any of them. M12 Inheritance, Composition & Protocols
Positional-only parameter Python
A parameter before / in a signature, which cannot be passed by keyword. M05 Functions
pre-commit Tooling
A framework that runs checks such as ruff and mypy automatically before each git commit. M42 Code Quality & Tooling
Precision and recall ML
Precision: of predicted positives, how many are correct. Recall: of actual positives, how many were found. M59 ML in Production
Prefix sum CS
An array where entry i holds the sum of the first i items, so any range sum takes O(1) after O(n) setup. M30 Searching & Array Techniques
Primary key Data engineering
A column (or set of columns) whose value uniquely identifies each row in a table. M44 Databases & SQL
Priority queue CS
An abstract structure that always returns the highest-priority item next, usually implemented with a heap. M25 Heaps & Priority Queues
Process Python
A running program with its own memory space; multiprocessing and ProcessPoolExecutor run Python code in several. M37 Concurrency: Threads, Processes & Interpreters
Profiler Tooling
A tool that measures where a program spends time or memory, such as cProfile, tracemalloc, or 3.15's sampling profiler. M39 Performance & Profiling
Property Python
A managed attribute defined with @property, letting a method run when the attribute is read or set. M10 Classes & Objects
Protocol Python
A typing.Protocol class describing required methods for structural ("duck") typing checked statically. M12 Inheritance, Composition & Protocols
Pure function Python
A function whose output depends only on its inputs and that has no side effects, which makes it easy to test and reason about. M18 Functional Python
PyPI Tooling
The Python Package Index, the public repository of Python packages; add them in Pixi with pixi add --pypi. M41 Packaging & Environments with Pixi
pyproject.toml Tooling
The standard file for Python packaging metadata and tool configuration (ruff, mypy, pytest). M41 Packaging & Environments with Pixi
pytest Tooling
Python's most popular test framework, using plain assert statements, fixtures, and plugins. M17 Testing with pytest

Q

Queue CS
A first-in, first-out (FIFO) collection. M22 Stacks, Queues & Deques
Quicksort CS
An in-place divide-and-conquer sort that partitions around a pivot; O(n log n) average, O(n²) worst case. M29 Sorting

R

Rabin-Karp CS
String search using a rolling hash to compare a pattern against each text window in expected O(n + m). M34 Strings, Bits & Number Theory
Race condition Python
A bug where the result depends on the unpredictable timing of threads or tasks accessing shared state; prevented with locks or by not sharing. M37 Concurrency: Threads, Processes & Interpreters
Random forest ML
An ensemble of decision trees trained on random subsets of rows and features, whose votes are averaged. M56 scikit-learn in Practice
Recommender system ML
A system predicting which items a user will like, using collaborative filtering, content features, or embeddings. M57 Unsupervised Learning & Embeddings
Recursion CS
A function solving a problem by calling itself on smaller inputs until it reaches a base case. M28 Recursion & Divide and Conquer
Refactoring Tooling
Restructuring code to improve its design without changing its behavior, protected by tests. M46 Software Design & Architecture
Reference counting Python
CPython's main memory strategy: each object counts its references and is freed when the count drops to zero. M39 Performance & Profiling
Regularization ML
Penalizing model complexity (L1, L2, dropout) to reduce overfitting. M56 scikit-learn in Practice
REPL Python
Read-Eval-Print Loop: the interactive Python prompt (>>>), syntax-highlighted in 3.14. M01 First Steps
REST Tooling
An architectural style for web APIs built around resources identified by URLs and manipulated with HTTP methods. M45 Web & APIs
ruff Tooling
An extremely fast Python linter and formatter that replaces flake8, isort, and black. M42 Code Quality & Tooling

S

Sampling Data science
Selecting a subset of a population to estimate its properties; random sampling avoids systematic bias. M54 Statistics & Probability
Schema Data engineering
The structure of data: column names, types, and constraints. M60 Data Engineering Foundations
SciPy Data science
The scientific computing library built on NumPy, with optimization, integration, interpolation, signal processing, statistics, and sparse matrices. M50 SciPy for Science & Engineering
Scope Python
The region of code where a name is visible; Python has function, module, and built-in scopes (see LEGB). M05 Functions
Secure coding Tooling
Writing code that resists attack: validate input, parameterize SQL, never eval untrusted data, and keep secrets out of source. M43 Debugging & Secure Code
Segment tree CS
A tree over array intervals that answers range queries (sum, min) and applies updates in O(log n). M27 Advanced Structures
Semantic versioning Tooling
Version numbers MAJOR.MINOR.PATCH where a major bump signals breaking changes. M41 Packaging & Environments with Pixi
Sentinel Python
A unique marker object meaning "no value given" when None is a valid value; Python 3.15 adds a sentinel() built-in (PEP 661). M05 Functions
Sequence Python
An ordered collection supporting integer indexing and len(), such as list, tuple, str, and range. M06 Collections
Series Data science
A one-dimensional labeled array in pandas; each DataFrame column is a Series. M51 pandas: Series & DataFrames
Set Python
A mutable, unordered collection of unique hashable items with fast membership tests. M06 Collections
Shallow copy Python
A new container holding references to the same inner objects (xs.copy(), xs[:]). M06 Collections
Slice Python
A start:stop:step selection of a sequence, such as s[1:4]; stop is exclusive. M03 Strings & Text
Sliding window CS
A technique that maintains a moving range over a sequence, updating results incrementally instead of recomputing. M30 Searching & Array Techniques
__slots__ Python
A class attribute listing allowed instance attributes, which saves memory by avoiding a per-instance __dict__. M36 Metaprogramming
Soft keyword Python
A word that is a keyword only in specific contexts, such as match, case, type, and 3.15's lazy. M04 Control Flow
SOLID Tooling
Five object-oriented design principles: Single responsibility, Open/closed, Liskov substitution, Interface segregation, Dependency inversion. M46 Software Design & Architecture
Space complexity CS
How much extra memory an algorithm needs as a function of input size. M19 Complexity & Big-O
Spark Data engineering
A distributed engine for large-scale batch and streaming data processing across a cluster. M63 Streaming & Big Data
Sparse matrix Data science
A matrix stored by its nonzero entries only, saving memory and time when most entries are zero. M49 Linear Algebra with NumPy & SciPy
SQL Data engineering
Structured Query Language, the declarative language for querying and modifying relational databases. M44 Databases & SQL
SQL injection Tooling
An attack that smuggles SQL through unescaped string formatting; prevented with parameterized queries. M43 Debugging & Secure Code
src layout Tooling
Placing a package under src/<name>/ so tests import the installed package, not stray files in the working directory. M08 Modules, Packages & Pixi Projects
Stable sort CS
A sort that keeps items with equal keys in their original relative order; Python's sorted is stable. M29 Sorting
Stack CS
A last-in, first-out (LIFO) collection; a Python list with append and pop. M22 Stacks, Queues & Deques
Standard deviation Data science
The square root of variance; a measure of how spread out values are around the mean. M54 Statistics & Probability
Star schema Data engineering
A warehouse model with a central fact table joined to surrounding dimension tables. M60 Data Engineering Foundations
Statement Python
A complete instruction such as an assignment, if, for, or return; statements do not produce values. M01 First Steps
Static method Python
A method decorated with @staticmethod that receives neither instance nor class; a plain function grouped in a class. M10 Classes & Objects
Streaming Data engineering
Processing events continuously as they arrive rather than in scheduled batches. M63 Streaming & Big Data
Strides Data science
The number of bytes to step in memory to move one position along each dimension of a NumPy array. M48 NumPy Fundamentals
String (str) Python
An immutable sequence of Unicode code points. M03 Strings & Text
structlog Tooling
A structured-logging library that emits key-value or JSON log events that log aggregators can parse. M42 Code Quality & Tooling
Subinterpreter Python
An isolated interpreter inside the same process with its own modules and GIL, exposed by concurrent.interpreters in 3.14 (PEP 734). M37 Concurrency: Threads, Processes & Interpreters
Subprocess Tooling
A separate operating-system program started from Python with subprocess.run(). M40 Standard Library Power Tools
Supervised learning ML
Learning a mapping from inputs to known labels using labeled examples. M55 Machine Learning Foundations
SVD (singular value decomposition) Data science
Factoring any matrix as U Σ Vᵀ; the basis of PCA, low-rank approximation, and least squares. M49 Linear Algebra with NumPy & SciPy

T

t-string (template string) Python
A 3.14 literal prefixed with t (PEP 750) that produces a Template keeping text and interpolated values separate for safe processing. M03 Strings & Text
Task (Pixi) Tooling
A named command in pixi.toml run with pixi run <name>, optionally with dependencies, arguments, and caching. M41 Packaging & Environments with Pixi
TaskGroup Python
asyncio.TaskGroup: an async context manager that runs tasks together and cancels the rest if one fails (structured concurrency). M38 Async Programming with asyncio
Tensor ML
A multi-dimensional array, the core data type of deep learning frameworks like PyTorch. M58 Neural Networks from Scratch
Test-driven development (TDD) Tooling
Writing a failing test first, then the minimal code to pass it, then refactoring: red, green, refactor. M17 Testing with pytest
Thread Python
An independent flow of execution within a process that shares the process's memory with other threads. M37 Concurrency: Threads, Processes & Interpreters
Tidy data Data science
A layout where each variable is a column, each observation a row, and each value a cell. M51 pandas: Series & DataFrames
Time complexity CS
How an algorithm's running time grows with input size, usually expressed in Big-O. M19 Complexity & Big-O
Timsort / Powersort CS
Python's adaptive, stable hybrid of merge sort and insertion sort; since 3.11 its run-merging policy is Powersort. M29 Sorting
TOML Tooling
A minimal configuration file format used by pixi.toml and pyproject.toml; read with tomllib. M09 Files & Data Formats
Topological sort CS
An ordering of a DAG's vertices so every edge points forward; graphlib.TopologicalSorter in the stdlib. M26 Graphs
Traceback Python
The report printed for an unhandled exception, listing the chain of calls (most recent last) that led to it. M01 First Steps
Train/test split ML
Holding back part of the data for final evaluation so the reported score reflects unseen data. M55 Machine Learning Foundations
Transaction Data engineering
A group of database operations that succeed or fail together (atomically), following ACID guarantees. M44 Databases & SQL
Tree CS
A connected, acyclic graph, usually rooted, where each node has children and exactly one parent except the root. M24 Trees & Binary Search Trees
Trie CS
A prefix tree storing strings character by character, so prefix lookups take time proportional to the key length. M27 Advanced Structures
Truthiness Python
How a value behaves in a boolean context; empty containers, zero, and None are falsy, most other values truthy. M04 Control Flow
Tuple Python
An immutable, ordered sequence, often used as a fixed-size record. M06 Collections
Two pointers CS
A technique that moves two indices through a sequence (often from both ends) to solve problems in linear time. M30 Searching & Array Techniques
Type alias Python
A name for a type expression, written with the type statement: type Vector = list[float]. M16 Type Hints & Static Typing
Type hint Python
An annotation that states the expected type of a value for readers and static checkers; Python does not enforce it at run time. M16 Type Hints & Static Typing
TypedDict Python
A typing construct describing a dict with a fixed set of string keys and value types. M13 Dataclasses, Enums & Records

U

Unicode Python
The standard assigning a code point to every character in every writing system; Python str holds Unicode text. M03 Strings & Text
Union-find CS
A disjoint-set structure supporting near-constant-time union and find with union by rank and path compression. M27 Advanced Structures
Unit test Tooling
A fast test of one function or class in isolation, with no real I/O. M17 Testing with pytest
Unpacking Python
Assigning the items of an iterable to several names at once (a, *rest = xs) or spreading them into a call or literal with */**. M06 Collections
Unsupervised learning ML
Finding structure in data without labels, such as clusters or low-dimensional representations. M57 Unsupervised Learning & Embeddings
UTF-8 Python
The dominant variable-width encoding of Unicode into bytes; the default for open() from Python 3.15 (PEP 686). M09 Files & Data Formats
UUID Tooling
A 128-bit universally unique identifier; uuid.uuid7() (3.14) generates time-ordered UUIDs that make good database keys. M40 Standard Library Power Tools

V

Vectorization Data science
Replacing Python loops with whole-array operations that run in compiled code, often 10–100× faster. M48 NumPy Fundamentals
View (NumPy) Data science
An array that shares memory with another array, such as a basic slice; changing one changes the other. M48 NumPy Fundamentals
Virtual environment Python
An isolated set of installed packages for one project; in this course Pixi creates and manages these for you in .pixi/envs. M00 Setup: Python 3.14 with Pixi
Visualization Data science
Encoding data as position, length, color, and shape in a chart so patterns become visible; matplotlib in this course. M53 Data Visualization

W

Walrus operator Python
The assignment expression :=, which assigns and returns a value inside a larger expression. M04 Control Flow
Window function Data engineering
A SQL function computed over a set of related rows (OVER (PARTITION BY ... ORDER BY ...)) without collapsing them, such as running totals. M61 Analytical SQL & DuckDB
Workspace (Pixi) Tooling
A project directory managed by Pixi, defined by its pixi.toml and pixi.lock. M41 Packaging & Environments with Pixi

Z

Zstandard Tooling
A fast modern compression algorithm, available in the standard library as compression.zstd since 3.14 (PEP 784). M09 Files & Data Formats

Flashcards: 20 key terms

Say the definition out loud before you flip each card. These are the terms the rest of the course leans on most.

Check yourself

Going further