Python Glossary

Key terms from the Python course, linked to the lesson that introduces each one.

1,591 terms.

#

`.describe()`: Statistical overview of numeric columns; Lesson 1043 — Inspecting a DataFrame Lesson 1064 — `.sum()`, `.mean()`, etc.
`.isdigit()`: returns `True` for standard digits (`0-9`) and some unicode digit-like characters (such as superscripts like `²`).; Lesson 160 — `.isnumeric()` vs `.isdigit()`Lesson 161 — `.isdecimal()`
`.isnumeric()`: returns `True` for everything `.; Lesson 160 — `.isnumeric()` vs `.isdigit()`Lesson 161 — `.isdecimal()`
`axis=0`: means "reduce down the *rows*" — collapse vertically, producing one result per *column*; Lesson 1028 — `axis` argument Lesson 1074 — `pd.concat`
`axis=1`: means "reduce across the *columns*" — collapse horizontally, producing one result per *row*; Lesson 1028 — `axis` argument Lesson 1074 — `pd.concat`
`func`: The blocking function to run; Lesson 925 — `run_in_executor`Lesson 1068 — `.apply()` on groups
`None`: Python's "nothing" value; Lesson 73 — Falsy values Lesson 599 — JSON type mapping
`optimizer.zero_grad()`: to clear old gradients.; Lesson 1182 — Optimizers in PyTorch Lesson 1184 — Training loop
`pyproject.toml`: is the modern answer to this chaos—a single, declarative file using the TOML format (Tom's Obvious Minimal Language) that can hold nearly all your project's metadata and tool settings.; Lesson 993 — `pyproject.toml`Lesson 1256 — Pinning dependencies
`requirements.txt`: comes in—it's a simple text file that lists all the packages your project needs, along with their versions.; Lesson 713 — requirements.txt Lesson 1256 — Pinning dependencies
`ValueError`: .; Lesson 96 — Failing conversions Lesson 540 — Raising built-in exceptions
1 cookie left over: (`10 % 3`).; Lesson 51 — Modulo `%`Lesson 199 — `%` modulo

A

ABC: Explicit inheritance, runtime checks; Lesson 651 — Protocols (typing)
Absolute paths: Lesson 578 — `os.path` basics Lesson 587 — Relative vs absolute paths
Abstract methods: solve this by making the requirement explicit.; Lesson 649 — Forcing subclasses to override
Accessing undefined attributes: Lesson 551 — `AttributeError`
accumulate: values into a single result.; Lesson 816 — `reduce`Lesson 1182 — Optimizers in PyTorch
Activation: Pass the sum through an **activation function** to get the final output; Lesson 1168 — Perceptrons and neurons
Activation functions: Introduce non-linearity (typically ReLU); Lesson 1188 — Convolutional networks (CNNs)
Adam: a smarter, adaptive optimizer that often works better with less tuning; Lesson 1182 — Optimizers in PyTorch
add: two `Counter` objects with `+`, Python combines their counts:; Lesson 468 — `Counter` arithmetic Lesson 1252 — Sessions and transactions
add or subtract: a `timedelta` to shift a `datetime`:; Lesson 773 — `timedelta`Lesson 774 — Adding/subtracting timedeltas
Add visuals: Screenshots, GIFs, or charts make your work tangible; Lesson 1289 — Building a portfolio
Adding a space: Lesson 242 — Printing without newline
Addition (`+`): Combines two integers; Lesson 49 — Integer arithmetic
Admin panel: Automatically generated interface for managing data; Lesson 1234 — Why Django
Agglomerative (bottom-up): is the most common approach:; Lesson 1164 — Hierarchical clustering
Alembic: is a migration tool for SQLAlchemy that solves this problem by treating schema changes as *version-controlled scripts*.; Lesson 1253 — Alembic migrations
AlexNet: (ImageNet breakthrough), **VGG** (uniform design), **ResNet** (skip connections), and **Inception** (multi-scale filters) each introduced innovations that shaped modern deep learning.; Lesson 1188 — Convolutional networks (CNNs)
Alignment: Operations automatically align on both row and column labels; Lesson 1040 — `pd.DataFrame` basics
all: characters, including spaces, punctuation, and escape sequences (which count as single characters):; Lesson 117 — `len()` on strings Lesson 142 — `.splitlines()`Lesson 156 — `.isdigit()`Lesson 411 — Intersection `&`Lesson 567 — `.read()`Lesson 699 — `__all__` list Lesson 766 — `ExitStack`Lesson 1056 — `.dropna()` (+1 more)
All remaining characters: become lowercase; Lesson 129 — `.capitalize()`
All-in-one: Replaces flake8, black, isort, pyupgrade, and more—one config, one command.; Lesson 970 — `ruff` — the modern linter
always: returns exactly 3 items; Lesson 144 — `.partition(sep)`Lesson 197 — `/` true division Lesson 757 — Why context managers Lesson 758 — The `with` statement
Analogy: The REPL is like a scratch pad.; Lesson 10 — The Python REPL Lesson 55 — Converting strings to int Lesson 66 — Infinity and NaN Lesson 138 — `.split()`Lesson 241 — `flush` argument Lesson 249 — Newline behavior of input Lesson 253 — `elif` chains Lesson 362 — Performance of comprehensions (+28 more)
Anonymous functions: you don't need to call again; Lesson 507 — Lambda vs def
any: format spec you've learned:; Lesson 184 — Format spec in f-strings Lesson 1056 — `.dropna()`
any valid Python expression: inside the `{}`:; Lesson 182 — f-string introduction Lesson 183 — Expressions in f-strings
Apache 2.0: Like MIT, but includes patent protection and contributor agreements.; Lesson 995 — LICENSE files
API consumption: Use `fetch('/api/tasks')` to load data, display in components; Lesson 1282 — Project: small SPA-backed web app
API design: – You're building a framework where declarative syntax hides complexity (like Django models or SQLAlchemy); Lesson 679 — Custom metaclasses
API key: a unique string you include in a header or query parameter.; Lesson 1206 — Headers and auth Lesson 1231 — Authentication patterns
API responses: Help developers understand your data; Lesson 597 — Pretty-printing JSON
API style: Keras (the high-level API) often feels more concise and "batteries-included" than PyTorch; Lesson 1195 — TensorFlow / Keras preview
API tokens: for better security.; Lesson 998 — `twine` for publishing
APIView: classes handle HTTP requests (GET, POST, PUT, DELETE) and return JSON responses.; Lesson 1243 — Django REST framework
App Engine: (PaaS), **Cloud Run** (containerized apps), and **Cloud Functions** (serverless).; Lesson 1274 — Cloud deployment options
Append mode (`'a'`): This *appends* to the file, meaning it **preserves all existing content** and positions the file pointer at the end.; Lesson 576 — Truncating vs appending
Append or extend: Tuples have no `.; Lesson 378 — Tuples are immutable
Apply it: Django executes the migration against your database, making the structural changes live.; Lesson 1240 — Migrations
Apply the activation function: – Transform the sum (e.; Lesson 1170 — Forward propagation
Applying quantifiers: `(?; Lesson 847 — Non-capturing groups
Approval & merge: once approved, the PR is merged into main; Lesson 989 — Pull requests / merge requests
Architecture decisions: how modules are organized, how responsibilities are separated, where inheritance makes sense versus composition.; Lesson 1285 — Reading other people's code
Artificial intelligence: Teaching computers to learn and make decisions; Lesson 1 — What is Python?
ASGI: (Asynchronous Server Gateway Interface) is the modern standard designed for asynchronous Python applications.; Lesson 1270 — WSGI vs ASGI
ASGI server: a lightning-fast server implementation designed specifically to run asynchronous Python web applications.; Lesson 1232 — Running with uvicorn
Asymmetric data (e.g., income): High skew; Lesson 1115 — Skew and kurtosis
Async: (short for asynchronous programming) solves this by letting a *single thread* juggle thousands of I/O operations.; Lesson 911 — Why async
Async by Default: Lesson 1223 — Why FastAPI
Async support: Works with `async def` / `await` for non-blocking I/O; Lesson 1210 — `httpx` for async HTTP
at least one: element is truthy, `False` otherwise; Lesson 367 — `any(lst)` / `all(lst)`Lesson 1056 — `.dropna()`
At the `(Pdb)` prompt: Lesson 952 — `pdb` commands
AUC: (Area Under the Curve) summarizes this into a single number.; Lesson 1155 — ROC and AUC
Auth: JWT tokens stored in `localStorage`, sent in `Authorization` header; Lesson 1282 — Project: small SPA-backed web app
Authentication & Security: Lesson 1280 — Project: REST API
Authentication Failures: Weak password policies, broken session management, no rate limiting on login attempts.; Lesson 1277 — Application security basics
Authentication or headers: For simple cases, pandas handles standard HTTP.; Lesson 1084 — Reading from URLs
Authentication support: Built-in helpers for common authentication schemes; Lesson 1202 — `requests` library
Auto-fix: Fixes most violations automatically (unused imports, quote style, line length).; Lesson 970 — `ruff` — the modern linter
Auto-fix issues: Lesson 970 — `ruff` — the modern linter
Auto-generated help: run `python script.; Lesson 863 — `argparse`
Autogenerate: Alembic inspects your models and creates migrations automatically; Lesson 1253 — Alembic migrations
Autograd: (short for "automatic differentiation") is PyTorch's engine that automatically calculates gradients (derivatives) of tensors.; Lesson 1180 — `autograd` engine
Automatic cleanup: Fixtures can tear down resources when tests finish; Lesson 936 — Fixtures
Automatic Documentation: Lesson 1223 — Why FastAPI
Automatic JSON handling: Parse JSON responses with a single method call; Lesson 1202 — `requests` library
Automatic parameter tracking: (handled by PyTorch behind the scenes); Lesson 1181 — Defining a model with `nn.Module`
Automatic registration: – You need every subclass to register itself in a global registry when defined (plugin systems, ORMs); Lesson 679 — Custom metaclasses
Automatic test discovery: the test runner finds and executes all methods starting with `test_`; Lesson 927 — `unittest.TestCase`
Automatic tracking: Every operation creates nodes in a computation graph; Lesson 1180 — `autograd` engine
Automatically converts: the string from the URL to your declared type (int, float, bool, etc.; Lesson 1225 — Path and query parameters
Automation: Having your computer handle repetitive tasks; Lesson 1 — What is Python?Lesson 2 — Why learn Python
Average linkage: average distance between all pairs; Lesson 1164 — Hierarchical clustering
Averaging results: For regression, the forest averages all tree predictions; for classification, it takes a majority vote; Lesson 1142 — Random forests
Avoid: cramming complicated logic into a lambda just to keep it one line.; Lesson 507 — Lambda vs def
Avoid doctests when: Lesson 949 — When doctests shine
Avoid repetition: Write setup code once, use it everywhere; Lesson 936 — Fixtures
Avoiding ambiguity: When passing tuples as function arguments or in expressions; Lesson 371 — Tuple literal `()`
Avoiding conflicts: Lesson 688 — `import as` alias
Avoiding IndexError: Making sure your index is valid before accessing `lst[i]`; Lesson 363 — `len(lst)`
Axes: The actual plotting area(s) with x/y coordinates—think of these as the graphs themselves; Lesson 1089 — Figure and axes objects
Axis 0: collapses rows (think "down the columns").; Lesson 1027 — Reductions: `sum`, `mean`, `std`
Axis 1: collapses columns (think "across the rows").; Lesson 1027 — Reductions: `sum`, `mean`, `std`

B

Backend: Lesson 1282 — Project: small SPA-backed web app
Backend for other tools: libraries like pandas and seaborn actually use matplotlib under the hood; Lesson 1087 — Why matplotlib
Backend setup: Create Flask app with routes for CRUD operations on a resource (e.; Lesson 1282 — Project: small SPA-backed web app
Backup script: Compress and copy critical folders to cloud storage nightly; Lesson 1284 — Project: automation script
Backward pass: compute gradients via `loss.; Lesson 1184 — Training loop
Backwards compatible: can even run `unittest` tests; Lesson 932 — Why pytest
Bad pattern: Lesson 978 — Common optimizations
Basic pattern: Lesson 589 — `csv.writer`
Basic syntax: Lesson 878 — `TypeAlias`Lesson 1073 — Sorting Lesson 1090 — Subplots
Batch size: is the number of training examples your network processes in a single forward-backward pass before updating the weights.; Lesson 1176 — Batch size and epochs
Batch size = 1: (stochastic gradient descent): Update weights after every single example.; Lesson 1176 — Batch size and epochs
Bearer tokens: (like OAuth tokens).; Lesson 1206 — Headers and auth
Behavior: (methods) — what the object *does*; Lesson 605 — Why OOP
Behind the scenes: Flask calls `jsonify()` for you when it sees a dictionary return value.; Lesson 1216 — Returning JSON
bell curve: .; Lesson 1118 — Normal distribution Lesson 1121 — Central limit theorem
Best for: Complex, nested data structures; rapidly evolving schemas; Lesson 1254 — NoSQL preview
Better defaults: Seaborn plots look polished immediately, with carefully chosen color palettes and styling that work well for data presentation.; Lesson 1099 — Why seaborn
Better error messages: easier debugging; Lesson 932 — Why pytest
Better security: Fewer tools mean a smaller attack surface; Lesson 1267 — Multi-stage builds
Bias: = error from overly simplistic assumptions.; Lesson 1133 — Overfitting and underfitting Lesson 1154 — Confusion matrix Lesson 1168 — Perceptrons and neurons
binary: (base-2) — the language of computers, which use only 0s and 1s.; Lesson 45 — Binary literals Lesson 1154 — Confusion matrix
Binary cross-entropy: Special case for two-class problems.; Lesson 1171 — Loss functions
binary mode: (`'rb'`) for:; Lesson 558 — Text vs binary mode Lesson 601 — `pickle.dump` / `pickle.load`
Binary mode (`'rb'`): – Python gives you the raw bytes exactly as stored on disk.; Lesson 558 — Text vs binary mode
Binary output: Sigmoid; Lesson 1169 — Activation functions
Binning continuous values: Convert age into age groups; Lesson 1150 — Feature engineering
Binomial: count of successes in fixed trials (like flipping a coin 10 times); Lesson 1034 — Random sampling Lesson 1119 — Binomial and Poisson
Binomial distribution: models the number of successes in a fixed number of independent trials (like flipping a coin 10 times and counting heads).; Lesson 1119 — Binomial and Poisson
Black: is an *opinionated* auto-formatter for Python.; Lesson 968 — Formatting with black Lesson 970 — `ruff` — the modern linter
Blank lines: Two blank lines between top-level functions and classes; one blank line between methods.; Lesson 966 — PEP 8 reminders
Blueprint: in Flask is like a mini-application or a plugin that can be registered with your main Flask app.; Lesson 1220 — Flask Blueprints
Body: (optional data you're sending, used with POST/PUT); Lesson 1196 — How HTTP works Lesson 1199 — Headers and bodies
Bokeh: specializes in creating **interactive visualizations** that run in web browsers.; Lesson 1108 — Bokeh intro
Boolean: Lesson 1010 — Array dtypes
Boolean conversion: Any numeric column to `bool`; Lesson 1060 — Changing dtypes
Boolean masking: (also called *boolean indexing*) is one of NumPy's most powerful features.; Lesson 1016 — Boolean masking Lesson 1017 — Fancy indexing Lesson 1031 — Element-wise comparison
Boolean Series: (a column of `True` and `False` values) by applying a condition to one or more columns, then use that Series to filter the DataFrame.; Lesson 1050 — Boolean indexing
both: operands are truthy.; Lesson 211 — `and` operator Lesson 222 — `&` bitwise AND Lesson 411 — Intersection `&`Lesson 770 — `datetime.datetime`Lesson 793 — `deque`Lesson 931 — Test discovery Lesson 1052 — Combining conditions
both sync and async: APIs.; Lesson 923 — Async libraries Lesson 1210 — `httpx` for async HTTP
Breakdown: Lesson 222 — `&` bitwise AND Lesson 1272 — Uvicorn for ASGI
Broadcast assignment: You can assign a single value to an entire slice: `arr[1:3, :] = 0`; Lesson 1015 — Slicing arrays
Broken Access Control: Users accessing resources they shouldn't (like another user's account or admin endpoints).; Lesson 1277 — Application security basics
Browser stores: the cookie; Lesson 1207 — Sessions and cookies
Browser-based: No special software needed to view your visualizations; Lesson 1108 — Bokeh intro
Browser-friendly: JavaScript natively understands JSON; Lesson 1200 — JSON over HTTP
BSD 3-Clause: Similar to MIT, slightly more explicit about attribution.; Lesson 995 — LICENSE files
buffer: ) and displays it in batches for efficiency.; Lesson 241 — `flush` argument Lesson 563 — Why `close()` matters Lesson 577 — Flushing buffers
build: based on your hardware—specifically, whether you have an NVIDIA GPU and which version of **CUDA** (NVIDIA's parallel computing platform) you want to use.; Lesson 1177 — Installing PyTorch Lesson 1265 — Building images
Build & deploy: Frontend builds to static files; backend serves them in production; Lesson 1282 — Project: small SPA-backed web app
Build system: (defined by PEP 517/518):; Lesson 993 — `pyproject.toml`
Building paths elegantly: Lesson 833 — `pathlib` recap
Built for messy data: Real-world data has missing values, mixed types, duplicates, and inconsistent formats.; Lesson 1037 — Why pandas
built-in: with Python—you already have it!; Lesson 7 — Choosing an editor Lesson 496 — Built-in scope
Built-in assertion methods: like `assertEqual`, `assertTrue`, etc.; Lesson 927 — `unittest.TestCase`
Byte strings (`bytes`): are like the raw ink patterns on paper — they're just sequences of numbers (0–255) with no assumed meaning.; Lesson 106 — Byte strings preview
Bytes: (`bytes`) are sequences of raw 8-bit values — they represent *data* as computers actually store it.; Lesson 190 — Encoding strings to bytes Lesson 861 — `zlib` / `gzip` / `bz2`

C

C3 Linearization: algorithm, which guarantees:; Lesson 641 — Method Resolution Order (MRO)
Caching framework: Speed up your site; Lesson 1234 — Why Django
Calculate errors: Find where the current model is wrong (the residuals); Lesson 1143 — Gradient boosting
California Housing dataset: contains 1990 census data with 8 features (median income, house age, etc.; Lesson 1137 — Loading a sample dataset
Call `load_dotenv()` early: Typically at the very top of your entry script (e.; Lesson 1258 — `python-dotenv`
callable: (they act like functions).; Lesson 753 — Class-based decorators Lesson 1230 — Dependency injection
Cancellation: lets you stop tasks mid-execution without waiting for them to finish naturally.; Lesson 921 — Cancellation
cannot: mix types:; Lesson 194 — `+` addition Lesson 425 — Empty dict Lesson 904 — Sharing data across processes Lesson 1052 — Combining conditions
Capping values (clipping): Lesson 1035 — `np.where`
Capture: Run your code, save the output to a file (the "snapshot"); Lesson 945 — Snapshot testing intro
capturing: or **closing over** those variables.; Lesson 512 — Capturing enclosing variables Lesson 845 — Groups and capturing
Cartesian product: in mathematics.; Lesson 803 — `product`
case-sensitive: `name` and `Name` are as different as `cat` and `dog`.; Lesson 21 — Case sensitivity Lesson 136 — `.replace(old, new)`Lesson 151 — `.count(sub)`Lesson 152 — `.startswith(prefix)`
Catch bugs early: editors can warn you if you pass the wrong type; Lesson 521 — Annotating parameters
Categorical data: Convert repeating strings to `'category'` dtype; Lesson 1060 — Changing dtypes
Categories: Group changes by type:; Lesson 1000 — Maintaining changelogs Lesson 1183 — Loss functions in PyTorch
Caution: `.; Lesson 570 — `.readlines()`Lesson 829 — `sys.path`
CDF: accumulates probability from left to right for any distribution type.; Lesson 1117 — Probability distributions
Central Limit Theorem (CLT): states that when you take many random samples from *any* population (with finite variance), calculate the mean of each sample, and plot those means, they form a **normal distribution** — even if the original population was wildly non-normal.; Lesson 1121 — Central limit theorem
Chain multiple dicts: `d1 | d2 | d3` is easier to read than nested unpacking; Lesson 460 — `d1 | d2`
Chained assignment: lets you assign *the same single value* to several variables at once by "chaining" the assignment operator.; Lesson 31 — Chained assignment
Change the order: arguments appear, regardless of how you pass them; Lesson 174 — Positional format placeholders
Check API docs: Every API specifies exactly how to send credentials (header name, format, prefix).; Lesson 1206 — Headers and auth
Check loop state: – What's happening on iteration 3?; Lesson 950 — Print-debugging
Check your code: Lesson 970 — `ruff` — the modern linter
Checking paths: Lesson 833 — `pathlib` recap
Children before parents: – check the class itself first; Lesson 641 — Method Resolution Order (MRO)
Choose comprehensions by default: They're more readable for most Python programmers and handle complex logic (transform *and* filter) elegantly.; Lesson 361 — Comprehensions vs map/filter
Choosing teams: Lesson 805 — `combinations`
CI/CD: stands for **Continuous Integration / Continuous Deployment**.; Lesson 1275 — CI/CD basics
CI/CD pipelines: One fast tool = faster builds.; Lesson 970 — `ruff` — the modern linter
CircleCI: , **Travis CI**, **Jenkins**; Lesson 1275 — CI/CD basics
Circular references: can prevent it from being called at all; Lesson 665 — `__del__`
Clarity: Anyone reading your code instantly knows this value shouldn't change; Lesson 39 — Constants by convention Lesson 175 — Keyword format placeholders Lesson 484 — Default parameter values Lesson 489 — Keyword-only arguments
class: is a blueprint for creating objects.; Lesson 606 — `class` keyword Lesson 619 — Class as a blueprint
class decorators: functions that take a class as input, modify or wrap it, and return a class (or a replacement).; Lesson 677 — Class decorators Lesson 679 — Custom metaclasses
classification: .; Lesson 1130 — Regression vs classification Lesson 1141 — Decision trees
Classification output: A label from a finite set of options (limited choices); Lesson 1130 — Regression vs classification
Clean interfaces: Users get simple functions tailored to their needs; Lesson 515 — Using closures for factories
Clean routes: Your endpoint handlers stay focused on their main job; Lesson 1230 — Dependency injection
Cleaner code: When you use a few functions repeatedly, this reads better; Lesson 687 — `from ... import ...`Lesson 1151 — Pipelines
Cleaner for obvious arguments: – Functions like `pow(x, y)` don't benefit from callers writing `pow(x=2, y=3)`.; Lesson 490 — Positional-only parameters `/`
Cleaner numbering: If you *do* need some captures, non-capturing groups keep the numbering simpler; Lesson 847 — Non-capturing groups
Cleaner syntax: No double parentheses; Lesson 742 — Passing generators to functions
Cleaner tests: Each test focuses on what it's testing, not how to prepare; Lesson 936 — Fixtures
Cleans up: by closing the loop and returning the result; Lesson 914 — Event loop concept
clear: the nth bit, use bitwise AND with the inverse of a mask:; Lesson 228 — Bit manipulation idioms Lesson 953 — Setting breakpoints
Clear intent: Other developers (including future-you) know what's safe to depend on.; Lesson 620 — Encapsulation by convention
Clear labels: keys explicitly name your columns; Lesson 1041 — Creating from a dict of lists
Clearer intent: Signals that the exact value doesn't matter; Lesson 684 — Auto values in enums
CLI: (command-line interface); Lesson 1262 — Installing Docker
Click the Extensions icon: on the left sidebar—it looks like four squares with one floating away; Lesson 8 — Installing VS Code for Python
Client decodes: JSON → Python dict/list; Lesson 1200 — JSON over HTTP
Client encodes: Python dict/list → JSON string; Lesson 1200 — JSON over HTTP
Client sends: JSON in HTTP POST/PUT body with `Content-Type: application/json`; Lesson 1200 — JSON over HTTP
Client sends a request: you ask for something (a webpage, data, etc.; Lesson 1196 — How HTTP works
Clone: it locally with `git clone`; Lesson 1286 — Contributing to open source
Closures: – The inner function can access variables from the outer function's scope (enclosing scope); Lesson 511 — Inner functions
Cloud Functions: (serverless).; Lesson 1274 — Cloud deployment options
Cloud Run: (containerized apps), and **Cloud Functions** (serverless).; Lesson 1274 — Cloud deployment options
Code: Lesson 1255 — Project structure for deploy Lesson 1257 — `.env` files
Code is self-documenting: the underscore signals "proceed with caution"; Lesson 622 — Public vs private API
Code organization: – Breaking down a complex function into smaller pieces; Lesson 511 — Inner functions Lesson 1278 — Project: CLI tool
Code quality matters: Follow PEP 8, use type hints, write tests; Lesson 1289 — Building a portfolio
Collaborate: by sharing well-defined modules with teammates; Lesson 695 — Creating your own module
Collaborating Safely: Lesson 980 — Why version control
Collaboration: Multiple people ensure the codebase stays maintainable; Lesson 989 — Pull requests / merge requests Lesson 1220 — Flask Blueprints
Collaborative: Team members share migration files via version control, keeping everyone's database in sync.; Lesson 1240 — Migrations
column: to every column.; Lesson 1026 — Broadcasting Lesson 1244 — SQL fundamentals
Column-oriented thinking: matches how we conceptualize tables; Lesson 1041 — Creating from a dict of lists
columns: (which is extremely common), the cleanest way to create a DataFrame is from a dictionary of lists:; Lesson 1041 — Creating from a dict of lists Lesson 1056 — `.dropna()`Lesson 1154 — Confusion matrix
Combined approach (better): Lesson 566 — Opening multiple files
Combining columns: `total_price = quantity * unit_price`; Lesson 1150 — Feature engineering
Combining multiple conditions: Lesson 256 — Comparison with `and`/`or`
comma: is what actually defines a tuple, not the parentheses!; Lesson 371 — Tuple literal `()`Lesson 373 — Single-element tuple
Commas separate dimensions: `arr[row_slice, col_slice]` instead of `arr[row][col]`; Lesson 1015 — Slicing arrays
Comments: PEP 8 suggests starting comments with `# ` (note the space); Lesson 25 — Intro to PEP 8
Commit: them with `git commit`; Lesson 984 — `git add` / `git commit`Lesson 1252 — Sessions and transactions Lesson 1286 — Contributing to open source
Common algorithms: `md5()`, `sha1()`, `sha256()`, `sha512()`.; Lesson 859 — `hashlib`
Common examples: Lesson 1116 — Random variables Lesson 1158 — Hyperparameters
Common mistake: Lesson 343 — `.reverse()`
Common tasks: Lesson 1129 — Supervised vs unsupervised
communication: .; Lesson 40 — Underscore as throwaway Lesson 1282 — Project: small SPA-backed web app
Community: Massive support, tutorials, and pre-trained models; Lesson 1128 — What is machine learning Lesson 1195 — TensorFlow / Keras preview
compare: them to determine whether two path references actually point to the same file or directory.; Lesson 587 — Relative vs absolute paths Lesson 945 — Snapshot testing intro
Compatibility: Wheels can be platform-specific (e.; Lesson 997 — Building wheels
Complete environment isolation: You need different Python versions across projects without installing system-wide Pythons; Lesson 719 — pip vs conda
Complete linkage: maximum distance between any two points; Lesson 1164 — Hierarchical clustering
Complex enough: to capture real patterns in your data; Lesson 1133 — Overfitting and underfitting
Complex transformations: Apply logic that references multiple columns or requires conditionals.; Lesson 1068 — `.apply()` on groups
Complex visualizations: 3D plots, geographic maps, financial charts; Lesson 1106 — Plotly intro
Composability: Fixtures can depend on other fixtures; Lesson 936 — Fixtures
Compressed: by default (often 10x smaller than CSV); Lesson 1085 — Parquet / Feather formats
Compute: values when an attribute is "set"; Lesson 667 — `__setattr__` / `__delattr__`
Compute Engine: (VMs), **App Engine** (PaaS), **Cloud Run** (containerized apps), and **Cloud Functions** (serverless).; Lesson 1274 — Cloud deployment options
Compute loss: measure prediction error; Lesson 1184 — Training loop
Compute the gradient: the slope of the loss with respect to each parameter.; Lesson 1172 — Gradient descent
Compute weight gradients: Use activations from the forward pass; Lesson 1173 — Backpropagation
Concise: One line instead of three or four.; Lesson 356 — Basic comprehension
condition: any expression that evaluates to `True` or `False`; Lesson 250 — `if` basics Lesson 273 — `while` basics
Conditions: and **Events**, two higher-level primitives that simplify patterns like "wait for a signal" and "notify waiting threads.; Lesson 898 — Conditions and Events
Configuration: Lock in settings once, use many times; Lesson 515 — Using closures for factories Lesson 1255 — Project structure for deploy
Configuration constants: shared across all instances; Lesson 886 — `ClassVar`
Configuration files: Store settings in a readable format; Lesson 597 — Pretty-printing JSON
Configure `~/.pypirc`: to include Test PyPI:; Lesson 999 — Test PyPI
Confirm: success or report errors; Lesson 998 — `twine` for publishing
Confirm execution flow: – Did this branch even run?; Lesson 950 — Print-debugging
Confusion matrices: Classification accuracy patterns; Lesson 1105 — Heatmaps
Cons: "Dead neurons" can occur if a neuron always outputs zero; Lesson 1169 — Activation functions Lesson 1174 — Optimizers
Consider your stack: If you're running Dockerized apps, Fly or AWS ECS shine.; Lesson 1274 — Cloud deployment options
Consistency: Functions and operators work more predictably across different situations; Lesson 3 — Python 2 vs Python 3 Lesson 690 — Standard library imports Lesson 779 — UTC vs local time Lesson 997 — Building wheels
Consistent reporting: across all your tests; Lesson 927 — `unittest.TestCase`
Consistent with sets: The `|` operator already means "union" for sets; Lesson 460 — `d1 | d2`
Console: Where `print()` output appears; Lesson 957 — PyCharm debugger basics
Constant: When you want to flag missingness explicitly (e.; Lesson 1149 — Handling missing values
constants: values you don't intend to change throughout your program.; Lesson 38 — PEP 8 naming conventions Lesson 610 — Class attributes
container: or **collection** of things.; Lesson 653 — `__len__`Lesson 1261 — What is Docker Lesson 1262 — Installing Docker Lesson 1266 — Running containers
context manager: that guarantees the file will close, no matter what:; Lesson 564 — `with open(...)` pattern Lesson 939 — `pytest.raises`
Continue execution: until the next breakpoint or the program ends.; Lesson 952 — `pdb` commands
Continuing the analogy: This is like the prosecution's case: "The defendant *is* guilty.; Lesson 1122 — Hypothesis testing intro
continuous: (height, temperature, time); Lesson 1117 — Probability distributions Lesson 1139 — Linear regression
Continuous Deployment (CD): Lesson 1275 — CI/CD basics
Continuous Integration (CI): Lesson 1275 — CI/CD basics
Continuous random variables: take any value in a range; Lesson 1116 — Random variables
continuous values: numbers that can fall anywhere within a range.; Lesson 1130 — Regression vs classification Lesson 1183 — Loss functions in PyTorch
contract: with users.; Lesson 622 — Public vs private API Lesson 650 — `@abstractmethod`
Contributing: – How people can help (optional for personal projects); Lesson 994 — `README.md`
Convenience: Common cases require fewer arguments; Lesson 484 — Default parameter values
Convention: It's the standard way Python developers enhance functions.; Lesson 516 — Function decoration syntax `@`
Convert to UTC immediately: when receiving user input or external data; Lesson 779 — UTC vs local time
Convolutional Neural Network (CNN): is a deep learning architecture specifically designed for processing grid-structured data like images.; Lesson 1188 — Convolutional networks (CNNs)
Cookies: and **sessions** solve this by creating persistent state:; Lesson 1207 — Sessions and cookies
cooperative multitasking: coroutines explicitly decide when to yield control by using `await`.; Lesson 913 — The `await` keyword Lesson 924 — Blocking calls in async code
Copy the generated command: .; Lesson 1177 — Installing PyTorch
coroutine: is a special function that can pause its execution and allow other code to run while it waits for something (like a network request or file operation).; Lesson 912 — Coroutines with `async def`Lesson 1229 — Async routes
Correct: "If the coin were fair, we'd see results this lopsided only 2% of the time.; Lesson 1123 — p-values explained
Correct version: Lesson 280 — Avoiding infinite loops
Correlation matrices: How strongly different variables relate to each other; Lesson 1105 — Heatmaps
Counters: that track how many instances have been created; Lesson 610 — Class attributes Lesson 886 — `ClassVar`
Counting by fives: Lesson 287 — `range(start, stop, step)`
Counting by twos: Lesson 287 — `range(start, stop, step)`
Cover: Percentage covered; Lesson 942 — Coverage with `pytest-cov`
Coverage: Explores more of the parameter space with fewer evaluations; Lesson 1160 — `RandomizedSearchCV`
CPU: .; Lesson 1186 — GPU acceleration
CPU-intensive tasks: that benefit from parallelism:; Lesson 901 — Why multiprocessing
CPU-intensive work: (calculations, data processing, looping), all those threads must still take turns holding the GIL.; Lesson 900 — The GIL
CPU-only: Works everywhere but slower for deep learning; Lesson 1177 — Installing PyTorch
CPython: (written in the C programming language), and it's what most people use.; Lesson 4 — Installing Python
Create: a new file and open it for writing; Lesson 559 — `'x'` exclusive create
Create a branch: for your feature or fix; Lesson 989 — Pull requests / merge requests Lesson 1286 — Contributing to open source
Create a FastAPI app: with a `/predict` route.; Lesson 1281 — Project: ML model API
Create a migration: Django compares your current models to the last known state and writes Python code describing what changed.; Lesson 1240 — Migrations
Create a new tuple: based on the old one; Lesson 378 — Tuples are immutable
Create an account: at https://test.; Lesson 999 — Test PyPI
Create an HTTP endpoint: that accepts input features as JSON.; Lesson 1281 — Project: ML model API
Create model classes: that inherit from this base; Lesson 1251 — SQLAlchemy ORM
Create, Read, Update, Delete: the four fundamental operations for managing data in any database.; Lesson 1245 — SELECT, INSERT, UPDATE, DELETE
Creates an event loop: a manager object that coordinates all async tasks; Lesson 914 — Event loop concept
Creating a new folder: (key) with a document (value) inside, or; Lesson 426 — Adding keys
Creating diversity: Each tree is trained on a different random sample of the data (called *bootstrap sampling*); Lesson 1142 — Random forests
Creating Path objects: Lesson 833 — `pathlib` recap
CRITICAL: – The program may be unable to continue; Lesson 959 — `logging` module basics Lesson 960 — Log levels
Critical value: depends on your confidence level (e.; Lesson 1126 — Confidence intervals
CROSS JOIN: Returns the Cartesian product—every row from the first table paired with every row from the second.; Lesson 1246 — JOINs
Cross-entropy loss: Measures how far predicted probabilities are from the true class.; Lesson 1171 — Loss functions Lesson 1183 — Loss functions in PyTorch
Cross-language dependencies: Your project mixes Python, R, or requires system libraries; Lesson 719 — pip vs conda
Cross-platform: option: Use Python's `schedule` library or run the script in a loop with `time.; Lesson 1284 — Project: automation script
CRUD Operations: Lesson 1280 — Project: REST API
Cryptographic Failures: Exposing sensitive data because it wasn't encrypted in transit or at rest (e.; Lesson 1277 — Application security basics
CSS: files (for styling); Lesson 1219 — Static files
CSV: | Human-readable, universal compatibility | Slow | Large |; Lesson 1085 — Parquet / Feather formats
CUDA: (NVIDIA's parallel computing platform) you want to use.; Lesson 1177 — Installing PyTorch
CUDA 11.8: For NVIDIA GPUs with CUDA 11.; Lesson 1177 — Installing PyTorch
CUDA 12.1: (or newer): For newer CUDA versions; Lesson 1177 — Installing PyTorch
Cumulative time: reveals the "expensive pathways"—maybe a single database query function is your top cumtime offender because it calls dozens of helpers.; Lesson 974 — Reading profile output
Curly braces: `{}`; Lesson 425 — Empty dict
Custom aggregations: Return a tuple or dict of multiple summary stats.; Lesson 1068 — `.apply()` on groups
Custom endings: Lesson 239 — `end` argument
Customizability: When you need *exact* control, matplotlib delivers; Lesson 1087 — Why matplotlib

D

d1: d2}`, Python creates a new dictionary containing all key-value pairs from `d1` followed by all pairs from `d2`.; Lesson 459 — `{**d1, **d2}`Lesson 460 — `d1 | d2`Lesson 461 — `d1 |= d2`Lesson 462 — Handling key collisions
Daemon threads: are threads that run in the background and are automatically terminated when all non-daemon threads finish.; Lesson 894 — Daemon threads
Data analysis: Making sense of spreadsheets and statistics; Lesson 1 — What is Python?
Data containers: – Sometimes you just need a simple object to attach attributes to; Lesson 607 — Empty class with `pass`
Data integrity: guarantee that an object's state won't change unexpectedly; Lesson 671 — Frozen dataclasses
Data loss: Changes you write to a file may sit in a temporary buffer and not actually reach the disk until the file is closed; Lesson 562 — Closing files Lesson 565 — Why `with` is preferred
Data pipeline: Fetch data from an API, clean it, save to a database; Lesson 1284 — Project: automation script
Data Science: Banks, hospitals, and research labs use Python to make sense of huge amounts of information.; Lesson 2 — Why learn Python
Data Science / Analytics: Lesson 1287 — Specialization paths
Data science/scientific computing: You're using NumPy, pandas, TensorFlow, or other packages with complex C/Fortran dependencies; Lesson 719 — pip vs conda
Data size: You can fine-tune effectively with hundreds or thousands of examples, not millions.; Lesson 1193 — Fine-tuning a transformer
Data-preserving: You can write custom logic to transform data during schema changes (e.; Lesson 1240 — Migrations
Database: SQLite (dev) → PostgreSQL (production); Lesson 1282 — Project: small SPA-backed web app
Database connections, sockets, threads: these are OS resources; Lesson 905 — Pickling requirements
Database integration: Use SQLAlchemy models, run migrations with Alembic; Lesson 1282 — Project: small SPA-backed web app
Database lookups: that might return `None` if no record exists; Lesson 871 — `Optional[X]`
Database ORM: Talk to databases using Python objects instead of writing SQL; Lesson 1234 — Why Django
Database safety: Stored timestamps remain unambiguous forever; Lesson 779 — UTC vs local time
DataFrame: is pandas' primary two-dimensional data structure—think of it as a **labeled table** with rows and columns, similar to an Excel spreadsheet or a SQL table.; Lesson 1040 — `pd.DataFrame` basics Lesson 1046 — Column selection
DataFrame integration: Seaborn works seamlessly with pandas DataFrames, letting you reference columns by name rather than extracting arrays manually.; Lesson 1099 — Why seaborn
DataFrame-native: Designed around pandas DataFrames.; Lesson 1107 — Plotly Express
DataFrames: (multiple columns):; Lesson 1064 — `.sum()`, `.mean()`, etc.
Debug: understand why something isn't working as expected; Lesson 85 — The `type()` function Lesson 959 — `logging` module basics Lesson 960 — Log levels
Debug toolbar: to step over (`F10`), step into (`F11`), or continue (`F5`); Lesson 956 — VS Code debugger
Debugging: see output immediately instead of waiting for the program to finish; Lesson 577 — Flushing buffers Lesson 597 — Pretty-printing JSON Lesson 790 — `random.seed()`
Debugging version conflicts: "Which version of this library do I have?; Lesson 711 — `pip list`
Decoder: generates the output (e.; Lesson 1191 — Transformers intro
Decorate the function: you want to profile with `@profile` (a special marker); Lesson 976 — Line profilers
Decorators are just functions: that accept a function and return a (usually modified) function.; Lesson 746 — Manual decoration
deep copy: it recursively duplicates *everything*, including all nested structures.; Lesson 351 — `copy.deepcopy()`Lesson 854 — `copy` module
default: that varies by operating system:; Lesson 561 — Encoding argument Lesson 603 — Pickle protocols Lesson 1076 — Join types
Default parameters: (with `=` values); Lesson 488 — Order of parameters
default value: or **starting point**:; Lesson 372 — Empty tuple Lesson 484 — Default parameter values Lesson 724 — `next()` built-in
Default values: that apply to all objects; Lesson 610 — Class attributes Lesson 669 — Field defaults
Define a declarative base: – a foundation class that tracks your models; Lesson 1251 — SQLAlchemy ORM
Define a Pydantic model: for input validation.; Lesson 1281 — Project: ML model API
DELETE: Remove data; Lesson 1196 — How HTTP works Lesson 1197 — Methods: GET/POST/PUT/DELETE Lesson 1201 — REST principles Lesson 1245 — SELECT, INSERT, UPDATE, DELETE Lesson 1252 — Sessions and transactions
Delete elements: `del my_tuple[0]` fails; Lesson 378 — Tuples are immutable
Demos: Show consistent examples in tutorials or documentation; Lesson 790 — `random.seed()`
dependency injection: means you can declare reusable functions (dependencies) that FastAPI will automatically call and pass into your route handlers.; Lesson 1230 — Dependency injection Lesson 1231 — Authentication patterns
Deploy models: to production environments; Lesson 1187 — Saving and loading models
Deployment: Dockerize both, run with Gunicorn/Uvicorn + Nginx reverse proxy; Lesson 1282 — Project: small SPA-backed web app
Detecting outliers: unusual points appear across multiple plots; Lesson 1104 — Pair plots
Determinants: Check invertibility or compute signed volume.; Lesson 1033 — Linear algebra (`np.linalg`)
Deterministic lookups: that won't explode memory (e.; Lesson 818 — `cache` (3.9+)
Development convenience: No need to manually set environment variables every time you start your app.; Lesson 1258 — `python-dotenv`
DevOps / Infrastructure: Lesson 1287 — Specialization paths
Diabetes dataset: contains 10 baseline medical measurements from 442 patients, with a target representing disease progression one year later.; Lesson 1137 — Loading a sample dataset
Dict of lists (column-oriented): Better when you already have full columns of data.; Lesson 1042 — Creating from a list of dicts
Dictionaries: Specify both key and value types:; Lesson 873 — Container hints
dictionary: (or `dict`) is Python's built-in mapping type that stores data as **key-value pairs**.; Lesson 424 — Dict literal `{}`Lesson 676 — `__slots__`Lesson 1039 — Creating a Series Lesson 1066 — Multiple aggregations
Dictionary access: The `.; Lesson 846 — Named groups
Dictionary keys: Lesson 419 — `frozenset()`
Dictionary mapping: Explicit, selective renaming.; Lesson 1059 — Renaming columns
different: .; Lesson 205 — `!=` inequality Lesson 224 — `^` bitwise XOR
Digits: (0-9); Lesson 33 — Naming rules
Dimensionality reduction: is the process of reducing the number of features (dimensions) in your data while retaining as much meaningful information as possible.; Lesson 1165 — PCA
Disable: `disable 1` (breakpoint #1 stays but won't trigger); Lesson 953 — Setting breakpoints
Discovers arbitrary shapes: (crescents, blobs, spirals); Lesson 1163 — DBSCAN
Discrete: PMF gives point probabilities → CDF accumulates them; Lesson 1117 — Probability distributions
Discrete random variables: take distinct, countable values; Lesson 1116 — Random variables
Discuss the design: with maintainers; Lesson 1286 — Contributing to open source
Docker: to ensure the server restarts if it crashes and starts automatically on boot.; Lesson 1272 — Uvicorn for ASGI
Docker Compose: lets you define and manage multi-container applications using a simple YAML file.; Lesson 1269 — Docker Compose
Docker Desktop: is the easiest way to get Docker on your local machine.; Lesson 1262 — Installing Docker
docstring: (documentation string) is a special type of multi-line comment that Python actually remembers and can display later.; Lesson 20 — Docstring preview Lesson 479 — Docstrings Lesson 480 — Reading `help(func)`
Docstring (`"""..."""`): Python stores it and makes it available as documentation; Lesson 20 — Docstring preview
Document: the response structure in the auto-generated API docs; Lesson 1227 — Response models
Document your intent: makes collaboration easier; Lesson 521 — Annotating parameters Lesson 885 — `Final`
Documentation: They tell other developers (and your future self) what types a function expects and returns; Lesson 525 — Type hints are not enforced Lesson 989 — Pull requests / merge requests
Documentation styles: clear docstrings, type hints used effectively, README patterns.; Lesson 1285 — Reading other people's code
Documenting your environment: "What's installed on this machine?; Lesson 711 — `pip list`
Documents: your API with the correct types; Lesson 1225 — Path and query parameters
Does it need neither: → Use a **static method**; Lesson 628 — When to use each
doesn't exist: .; Lesson 220 — `not in` operator Lesson 329 — `.remove(x)`
Doesn't overwrite by default: If an environment variable already exists (e.; Lesson 1258 — `python-dotenv`
domain knowledge: understanding what matters in your problem space helps you create meaningful features.; Lesson 1150 — Feature engineering Lesson 1162 — k-Means clustering
Domain-specific features: Lesson 1150 — Feature engineering
Don't overuse it: usually the full chain is helpful for debugging.; Lesson 543 — Suppressing chained context
dot notation: with the field name:; Lesson 392 — Accessing named fields Lesson 615 — Method definition Lesson 686 — `import` statement
Double line breaks: on Windows when writing; Lesson 593 — Newline handling on CSV
double quotes: (`"`).; Lesson 98 — Double-quote strings Lesson 1051 — `.query()` method
Double-check your comparison operator: matches your update direction (incrementing with `<`, decrementing with `>`); Lesson 280 — Avoiding infinite loops
Downcast for memory: `int64` → `int32` or `int16`; Lesson 1060 — Changing dtypes
Download Docker Desktop: from [docker.; Lesson 1262 — Installing Docker
Downloading: them to your computer; Lesson 706 — What is pip
Downloads: the package files; Lesson 707 — `pip install package`Lesson 1137 — Loading a sample dataset
DRY: (Don't Repeat Yourself).; Lesson 268 — OR patterns with `|`
dtype: (data type).; Lesson 1011 — Choosing a dtype Lesson 1060 — Changing dtypes
Dynamic decimal places: Lesson 187 — Nested f-strings
Dynamic graphs: The graph is rebuilt on each forward pass, allowing flexible control flow; Lesson 1180 — `autograd` engine
Dynamic padding: Lesson 187 — Nested f-strings

E

Each dict key: → becomes a column name; Lesson 1041 — Creating from a dict of lists
Each dict value: (a list) → becomes the data *down* that column; Lesson 1041 — Creating from a dict of lists
each line: instead of just the entire string.; Lesson 850 — Flags: IGNORECASE, MULTILINE, DOTALL Lesson 976 — Line profilers
Easier refactoring: Insert new members without renumbering; Lesson 684 — Auto values in enums
Easy sharing: Send an HTML file anyone can open in a browser; Lesson 1106 — Plotly intro
Easy to write: No test class setup needed; Lesson 947 — Doctests
EC2: (virtual servers you configure yourself), **Elastic Beanstalk** (managed app hosting), **Lambda** (serverless functions), and **ECS/EKS** (container orchestration).; Lesson 1274 — Cloud deployment options
Ecosystem: TensorFlow has strong mobile/web deployment tools (TensorFlow Lite, TensorFlow.; Lesson 1195 — TensorFlow / Keras preview
ECS/EKS: (container orchestration).; Lesson 1274 — Cloud deployment options
Editor integration: `pylance` provides real-time feedback directly in VS Code as you type; Lesson 890 — `pyright` and `pylance`
Efficiency: Leverage knowledge from massive datasets you couldn't access yourself; Lesson 1192 — Pretrained models with Hugging Face
Eigenvalues: and **eigenvectors** reveal the directions along which a matrix acts as simple scaling:; Lesson 1033 — Linear algebra (`np.linalg`)
Eigenvalues/vectors: Understand transformation behavior, stability, or dimensionality reduction.; Lesson 1033 — Linear algebra (`np.linalg`)
Elastic Beanstalk: (managed app hosting), **Lambda** (serverless functions), and **ECS/EKS** (container orchestration).; Lesson 1274 — Cloud deployment options
Elbow method: Plot inertia (within-cluster variance) for different k values; look for the "elbow" where improvement slows; Lesson 1162 — k-Means clustering
Elegant API: Clean, Pythonic syntax similar to matplotlib; Lesson 1108 — Bokeh intro
Elements inside other sets: Lesson 419 — `frozenset()`
Else: , you leave it at home.; Lesson 252 — `else` clauses
Email sending: Integrated email functionality; Lesson 1234 — Why Django
empty dictionary: , not an empty set!; Lesson 397 — Set literal `{}`Lesson 425 — Empty dict
Empty list: Lesson 311 — `list()` from iterable
Empty tuples: `()` is the only way to create one; Lesson 371 — Tuple literal `()`
Enable: `enable 1`; Lesson 953 — Setting breakpoints
Encapsulation: – Hiding helper logic that no one else needs to see; Lesson 511 — Inner functions
Enclosing: scope (in any outer function); Lesson 496 — Built-in scope
Encoder: processes the input (e.; Lesson 1191 — Transformers intro
Encoder-Decoder Structure: Original transformers have two stacks:; Lesson 1191 — Transformers intro
encoding: .; Lesson 190 — Encoding strings to bytes Lesson 1084 — Reading from URLs
encodings: are like different translation dictionaries—they map byte patterns to characters.; Lesson 561 — Encoding argument Lesson 1109 — Altair intro
Enforce immutability: by blocking certain changes; Lesson 667 — `__setattr__` / `__delattr__`
Enforcing strict rules: – You must validate that every class follows a pattern (all methods named certain ways, required attributes, etc.; Lesson 679 — Custom metaclasses
Enter `pipx`: it installs each CLI application in its own isolated virtual environment, but exposes the executable commands globally on your system.; Lesson 720 — `pipx` for tools
Epochs vs. Batches: This example uses the full dataset per step; real training typically loops over mini-batches; Lesson 1184 — Training loop
Equality comparison: Two `OrderedDict`s are equal only if their items match *and* are in the same order (regular dicts ignore order when comparing); Lesson 469 — `collections.OrderedDict`
Error: A broader, informal term for anything that goes wrong in your program—syntax mistakes, runtime problems, logical bugs, etc.; Lesson 526 — Exception vs error Lesson 959 — `logging` module basics Lesson 960 — Log levels
Error handling strategies: how professionals anticipate edge cases, raise meaningful exceptions, and fail gracefully.; Lesson 1285 — Reading other people's code
Errors: Exceptions and failures that need attention; Lesson 1276 — Monitoring and metrics
EuroPython: , **PyCon AU**, and regional PyCons around the world bring localized communities together with equally excellent content.; Lesson 1288 — Staying current
Even faster: than Parquet for read/write; Lesson 1085 — Parquet / Feather formats
Events: , two higher-level primitives that simplify patterns like "wait for a signal" and "notify waiting threads.; Lesson 898 — Conditions and Events
every character: is a digit (0–9); Lesson 156 — `.isdigit()`Lesson 158 — `.isspace()`
Everything else: becomes `True`; Lesson 95 — Explicit conversion to bool
Everything else becomes `True`: non-zero numbers, non-empty strings, etc.; Lesson 71 — `bool()` conversion
exactly: the kind of digits you'd type on a standard keyboard—no fancy Unicode symbols—use `.; Lesson 161 — `.isdecimal()`Lesson 193 — Unicode normalization preview Lesson 219 — `in` operator Lesson 508 — Lambdas in `sorted(key=...)`Lesson 709 — Installing a specific version Lesson 941 — `conftest.py`
exactly one character: .; Lesson 188 — `ord()`Lesson 841 — Character classes `[abc]`
Example `.env` file: Lesson 1257 — `.env` files
Example mistake: writing a decorator that assumes the first argument is a string or number, forgetting it's actually `self` when decorating a method.; Lesson 754 — Decorating methods
Example scenario: You have three tasks that each need to wait 2 seconds.; Lesson 918 — `asyncio.sleep`
Example script: (`greet.; Lesson 827 — `sys.argv`
Example structure: Lesson 705 — Namespace packages Lesson 1000 — Maintaining changelogs
Example URL: `/search?; Lesson 1215 — Query strings
Exception: A specific Python *object* that represents a runtime problem.; Lesson 526 — Exception vs error
Exception handling: (`try`/`except`, custom messages); Lesson 1278 — Project: CLI tool
Exception type: The name of the error (e.; Lesson 529 — Exception messages
Exceptions in `__del__`: are suppressed and hard to debug; Lesson 665 — `__del__`
Explicit dependencies: Readers know exactly what you're using from that module; Lesson 687 — `from ... import ...`
Explicit ordering API: Methods like `.; Lesson 469 — `collections.OrderedDict`
Exploratory data analysis: quickly spotting correlations; Lesson 1104 — Pair plots
Expression: "What's 2 + 2?; Lesson 13 — Statements and expressions Lesson 510 — Lambda limitations Lesson 740 — Generator expression syntax
Expressions: are pieces of code that evaluate to a value.; Lesson 13 — Statements and expressions
External tooling: Tools like `mypy`, PyCharm, or VS Code can *analyze* your code and warn you about type mismatches *before* you run it; Lesson 525 — Type hints are not enforced
Extracting datetime components: Year, month, day, hour from timestamps; Lesson 1150 — Feature engineering

F

F1-Score: = 2 × (precision × recall) / (precision + recall); Lesson 1153 — Accuracy, precision, recall, F1
factory function: as an argument.; Lesson 463 — `collections.defaultdict`Lesson 795 — `defaultdict` deep dive
Factory functions: – Return dynamically-created classes; Lesson 679 — Custom metaclasses
fail immediately: rather than letting the problem propagate.; Lesson 541 — Raising for input validation Lesson 559 — `'x'` exclusive create
False Negative (FN): wrongly said "No" (Type II error); Lesson 1154 — Confusion matrix
False Positive (FP): wrongly said "Yes" (Type I error); Lesson 1154 — Confusion matrix
falsy: counterparts (values that convert to `False`):; Lesson 72 — Truthy values Lesson 74 — `and` operator Lesson 102 — Empty strings
falsy values: .; Lesson 73 — Falsy values Lesson 95 — Explicit conversion to bool
Fancy indexing: is different: you pass an *array (or list) of integers* to select specific positions from your array, pulling out elements in whatever order you choose.; Lesson 1017 — Fancy indexing
Fast: optimized for analytics queries; Lesson 1085 — Parquet / Feather formats
Fast (if using NumPy): Lesson 978 — Common optimizations
FastAPI + Pydantic: Lesson 1280 — Project: REST API
FastAPI itself: – the framework library; Lesson 1222 — Installing FastAPI
Faster deployments: Less to upload and download; Lesson 1267 — Multi-stage builds
Faster installs: No need to run `setup.; Lesson 997 — Building wheels
Feather: (technically "Arrow IPC format") is designed for *language-agnostic data frames*.; Lesson 1085 — Parquet / Feather formats
Feature scaling: transforms all your features to similar ranges so the model weighs them fairly based on their actual predictive power, not their arbitrary units.; Lesson 1147 — Feature scaling
Features: – Key capabilities or highlights; Lesson 994 — `README.md`Lesson 1131 — Features and targets
Features (X): The input variables your model uses to make predictions (e.; Lesson 1138 — `train_test_split`
Feed-Forward Networks: After attention, each position passes through dense layers for additional transformation.; Lesson 1191 — Transformers intro
Fewer bugs: No accidental duplicate values; Lesson 684 — Auto values in enums
Figure: The entire window or canvas—think of it as the blank page; Lesson 1089 — Figure and axes objects
File handling: Lesson 928 — `setUp` / `tearDown`
File I/O: with `open()` or `Path.; Lesson 1278 — Project: CLI tool
File locking: On some systems, an open file can't be accessed by other programs—or even other parts of your own program; Lesson 562 — Closing files
File name: `CHANGELOG.; Lesson 1000 — Maintaining changelogs
File organizer: Move files from Downloads to categorized folders every day; Lesson 1284 — Project: automation script
File: `templates/hello.html`: Lesson 1218 — Templates with Jinja2
File: `templates/users.html`: Lesson 1218 — Templates with Jinja2
Filter: sensitive fields (like passwords) from the response; Lesson 1227 — Response models
Filter (keeps some items): `[x for x in lst if condition]`; Lesson 358 — Conditional expression in comprehension
Filter complete rows only: Lesson 1055 — `.isna()` / `.notna()`
Filtering values: Lesson 354 — Building a new list in a loop
Find all even numbers: Lesson 337 — Searching with comprehensions
Find all short words: Lesson 337 — Searching with comprehensions
Find positive numbers: Lesson 337 — Searching with comprehensions
Finding: packages on PyPI; Lesson 706 — What is pip
Finding all pairs: Lesson 805 — `combinations`
Finding files: Lesson 833 — `pathlib` recap
Finding patterns: identifying which features might be useful together; Lesson 1104 — Pair plots
first: , then you call `.; Lesson 143 — `.join()`Lesson 145 — `.rpartition(sep)`Lesson 149 — `.rfind(sub)`Lesson 809 — `takewhile` / `dropwhile`Lesson 1086 — Installing matplotlib Lesson 1237 — URL routing in Django
First request: You visit a site; the server creates a session and sends back a cookie with a unique session ID; Lesson 1207 — Sessions and cookies
Fixed records: You have a small, unchanging structure (e.; Lesson 792 — `namedtuple` recap
flake8: is a lightweight, fast linter that combines three tools:; Lesson 967 — Linting with flake8 / pylint Lesson 970 — `ruff` — the modern linter
Flask route: Lesson 1218 — Templates with Jinja2
Flexibility: Advanced users can still customize behavior; Lesson 484 — Default parameter values Lesson 1192 — Pretrained models with Hugging Face
floats: (short for "floating-point numbers").; Lesson 58 — Float literals Lesson 1010 — Array dtypes Lesson 1011 — Choosing a dtype
Flow: Lesson 535 — `else` after try
Folder structure: Lesson 1219 — Static files
For classification: (predicting categories):; Lesson 1171 — Loss functions
For counters/sums: `defaultdict(int)` – starts at `0`; Lesson 795 — `defaultdict` deep dive
For each dimension: , sizes must either:; Lesson 1026 — Broadcasting
For grouping into lists: `defaultdict(list)` – starts with empty list; Lesson 795 — `defaultdict` deep dive
For numbers: (integers and floats): `+` performs mathematical addition; Lesson 194 — `+` addition
For regression: (predicting continuous numbers):; Lesson 1171 — Loss functions
For sequences: (strings): `+` concatenates (joins) them together; Lesson 194 — `+` addition
Forget gate: Decides what information to discard from the cell state; Lesson 1190 — LSTMs and GRUs
Fork: the repository (create your copy); Lesson 1286 — Contributing to open source
Form handling: Validation, rendering, and security; Lesson 1234 — Why Django
Format: Markdown with a specific structure; Lesson 1000 — Maintaining changelogs
Format code (like black): Lesson 970 — `ruff` — the modern linter
Format validation: string patterns, regex, etc.; Lesson 634 — Validation in setters
Formatter: – decides *what* the message looks like; Lesson 961 — Configuring loggers
Formula: `f(x) = max(0, x)`; Lesson 1169 — Activation functions
Forward pass: feed inputs through the model; Lesson 1184 — Training loop
Forward pass logic: (defined in `forward`); Lesson 1181 — Defining a model with `nn.Module`
Foundation knowledge: Understanding matplotlib makes learning other libraries trivial; Lesson 1087 — Why matplotlib
Frames pane: The call stack (which functions called which); Lesson 957 — PyCharm debugger basics
Fraud detection: High recall (catch all fraud) even if precision suffers slightly.; Lesson 1153 — Accuracy, precision, recall, F1
Freedom to change: You can refactor `_balance` or `_calculate_fee()` internals without breaking external code that respects the convention.; Lesson 620 — Encapsulation by convention
From a range: Lesson 311 — `list()` from iterable
From a string: Lesson 311 — `list()` from iterable
From existing features: Lesson 1150 — Feature engineering
Frontend: Lesson 1282 — Project: small SPA-backed web app
Frontend scaffold: Initialize a React/Vue app in a separate folder; Lesson 1282 — Project: small SPA-backed web app
Full control: over every pixel: colors, labels, ticks, legends, annotations; Lesson 1087 — Why matplotlib
FULL OUTER JOIN: Returns all rows from both tables, with NULLs where there's no match.; Lesson 1246 — JOINs
Fully connected layers: Combine features for final classification; Lesson 1188 — Convolutional networks (CNNs)
function: that takes one list element and returns the value Python should use for comparison.; Lesson 341 — Sorting with `key=`Lesson 600 — Handling non-serializable types Lesson 816 — `reduce`Lesson 1059 — Renaming columns
Function returning a boolean: Lesson 522 — Annotating return types
Function returning a string: Lesson 522 — Annotating return types
Function returning an integer: Lesson 522 — Annotating return types
Function returning None: Lesson 522 — Annotating return types
Functions that need docstrings: Lesson 507 — Lambda vs def
Functions you'll reuse: multiple times; Lesson 507 — Lambda vs def
Future: imports (like `from __future__ import annotations`); Lesson 969 — Import sorting with isort
Future-proofing: The language was redesigned to handle modern computing needs better; Lesson 3 — Python 2 vs Python 3 Lesson 489 — Keyword-only arguments

G

Game development: Creating interactive entertainment; Lesson 1 — What is Python?
Generate an API token: under account settings (recommended over username/password).; Lesson 999 — Test PyPI
Generating sequences: Lesson 734 — `yield` from a loop
generator: of matching `Path` objects—you iterate over them or convert to a list.; Lesson 582 — `Path.glob()`Lesson 729 — `yield` keyword
generator expression: looks almost identical to a list comprehension, but uses **parentheses** instead of square brackets:; Lesson 740 — Generator expression syntax Lesson 741 — Comprehension vs generator
generator function: .; Lesson 730 — Generator function vs normal function Lesson 763 — `contextlib.contextmanager`
generator object: (an iterator):; Lesson 729 — `yield` keyword Lesson 735 — Generator state
Generators: they hold execution state that can't be captured; Lesson 905 — Pickling requirements
GET: Retrieve data (like loading a webpage); Lesson 1196 — How HTTP works Lesson 1197 — Methods: GET/POST/PUT/DELETE Lesson 1201 — REST principles
Get approval: before investing significant time; Lesson 1286 — Contributing to open source
GIL: is a mechanism in CPython (the standard Python implementation) that allows only **one thread to execute Python bytecode at a time**, even on multi-core processors.; Lesson 900 — The GIL
GitHub: as your primary portfolio platform:; Lesson 1289 — Building a portfolio
GitHub Actions: (runs workflows on GitHub); Lesson 1275 — CI/CD basics
GitHub Trending (Python): shows you what the community is building right now; Lesson 1288 — Staying current
GitLab CI: (built into GitLab); Lesson 1275 — CI/CD basics
global: to this module.; Lesson 495 — Global scope Lesson 496 — Built-in scope
Global Interpreter Lock (GIL): , which prevents multiple threads in a single Python process from executing Python bytecode at the same time.; Lesson 901 — Why multiprocessing
GNU GPLv3: "Copyleft" license.; Lesson 995 — LICENSE files
Good fit (balanced): Lesson 1133 — Overfitting and underfitting
GPL: .; Lesson 995 — LICENSE files
GPU: Fine-tuning a transformer typically requires GPU acceleration for practical speed.; Lesson 1193 — Fine-tuning a transformer
Graceful shutdowns: and signal handling; Lesson 1272 — Uvicorn for ASGI
Gradient boosting: `learning_rate`, `n_estimators`, `max_depth`; Lesson 1158 — Hyperparameters
Great for tutorials: Shows actual usage patterns; Lesson 947 — Doctests
Grouping alternatives: `(?; Lesson 847 — Non-capturing groups
Grouping operations: (you can now `.; Lesson 1070 — `.melt()`
groups: of items; Lesson 420 — Frozensets as dict keys Lesson 845 — Groups and capturing
Guidance: for backpropagation (which direction to adjust weights); Lesson 1171 — Loss functions
Gunicorn: (Green Unicorn) is a **production-grade WSGI server** that spawns multiple worker processes to handle concurrent requests efficiently and safely.; Lesson 1271 — Gunicorn for WSGI

H

Hacker News: often surfaces major Python announcements; Lesson 1288 — Staying current
Handle errors: Wrap risky operations in `try/except`; Lesson 1284 — Project: automation script
Handle timeouts gracefully: Lesson 910 — `as_completed` / `wait`
Handler: – decides *where* the message goes (console, file, network); Lesson 961 — Configuring loggers
Handles static files: (CSS, images) efficiently—no need to tie up Python workers.; Lesson 1273 — Reverse proxy with Nginx
Handling empty strings: Lesson 216 — Idiom: default value with `or`
Handling nested JSON: Lesson 1082 — Reading JSON
Handling None: Lesson 216 — Idiom: default value with `or`
hashable: they must be able to produce a consistent hash value and never change.; Lesson 401 — Set elements must be hashable Lesson 466 — `collections.Counter`
Hashable instances: frozen dataclasses can be used as dictionary keys or in sets; Lesson 671 — Frozen dataclasses
Hashing strings: Convert them to bytes first using `.; Lesson 859 — `hashlib`
Head: The latest migration in the chain; Lesson 1253 — Alembic migrations
Headers: (metadata like content type, authentication); Lesson 1196 — How HTTP works Lesson 1199 — Headers and bodies
Hello, Flask: displayed.; Lesson 1212 — Hello, Flask
Here's the catch: this fingerprint must stay constant.; Lesson 432 — Hashable keys only
Heterogeneous: Different columns can store different types; Lesson 1040 — `pd.DataFrame` basics
Hex codes: `'#FF5733'`; Lesson 1092 — Customizing styles
Hidden layers: Start with ReLU; Lesson 1169 — Activation functions
Hide implementation details: – If you might rename the parameter later, forcing positional-only keeps your API flexible.; Lesson 490 — Positional-only parameters `/`
High bias (underfitting): The student doesn't understand the material at all.; Lesson 1161 — Learning curves
High kurtosis: heavy tails, prone to outliers; Lesson 1115 — Skew and kurtosis
High p-value: Your data is consistent with the null hypothesis; **not enough evidence** to reject it.; Lesson 1123 — p-values explained
High variance (overfitting): The student memorizes every practice problem perfectly but can't generalize.; Lesson 1161 — Learning curves
Hover over variables: to see their values; Lesson 956 — VS Code debugger
How big: a step to take (learning rate); Lesson 1174 — Optimizers
How it works: Lesson 564 — `with open(...)` pattern Lesson 751 — Decorators with arguments Lesson 1162 — k-Means clustering Lesson 1167 — Anomaly detection Lesson 1183 — Loss functions in PyTorch Lesson 1289 — Building a portfolio
How many dimensions: does it have?; Lesson 1012 — Array shape and dim
How many elements: in total?; Lesson 1012 — Array shape and dim
HTTP methods: (verbs/actions), and **stateless communication** (each request is self-contained), creating predictable, scalable services that leverage HTTP's built-in features.; Lesson 1201 — REST principles
HTTP/2 support: More efficient connections (optional); Lesson 1210 — `httpx` for async HTTP
Hugging Face: provides a platform where you can instantly download and use thousands of pretrained models for tasks like text generation, sentiment analysis, translation, image classification, and more.; Lesson 1192 — Pretrained models with Hugging Face
Human readers: understanding what types a function expects; Lesson 870 — Hints don't enforce
Human-readable: You can inspect requests/responses as plain text; Lesson 1200 — JSON over HTTP
Hyperparameters: These are configuration settings you choose *before* training begins.; Lesson 1158 — Hyperparameters

I

I/O-bound operations: like querying a database, calling another API, reading a file, or waiting for external services—it spends most of its time *waiting* rather than computing.; Lesson 1229 — Async routes
I/O-bound tasks: reading files, making network requests, querying databases — anything where your program spends time waiting for external systems.; Lesson 891 — Why threads
I/O-bound work: (network requests, file reading, waiting for user input).; Lesson 900 — The GIL
IDE features: like autocomplete and inline warnings; Lesson 870 — Hints don't enforce
IDE settings: like `.; Lesson 990 — `.gitignore`
Idempotency: Script should be safe to run multiple times; Lesson 1284 — Project: automation script
Idempotent: Calling it multiple times has the same effect as calling it once—you just get the same data back.; Lesson 1197 — Methods: GET/POST/PUT/DELETE
identity: whether two names point to the exact same object in memory.; Lesson 81 — Comparing to None with `is`Lesson 89 — Identity with `id()`Lesson 90 — `is` vs `==`Lesson 217 — `is` operator Lesson 218 — `is not` operator Lesson 258 — `is None` checks
idiomatic Python: you'll see this pattern everywhere in real code.; Lesson 508 — Lambdas in `sorted(key=...)`Lesson 1285 — Reading other people's code
IEEE-754 standard: , which represents numbers in binary (base-2), not decimal (base-10).; Lesson 62 — Float precision
If: you're on the list, you can enter.; Lesson 250 — `if` basics Lesson 254 — Nested `if` statements Lesson 337 — Searching with comprehensions
If using Anaconda: You might prefer `conda install scikit-learn` instead of pip.; Lesson 1135 — Installing scikit-learn
Images: (PNG, JPG, SVG, etc.; Lesson 1219 — Static files
Immediate results: No training time required; Lesson 1192 — Pretrained models with Hugging Face
Immutability matters: You need hashable objects for dict keys or set members.; Lesson 792 — `namedtuple` recap
immutable: once a string object is created, you cannot modify its contents.; Lesson 126 — String immutability Lesson 170 — String concatenation with `+`Lesson 401 — Set elements must be hashable Lesson 658 — `__hash__`Lesson 671 — Frozen dataclasses Lesson 682 — Enums Lesson 769 — `datetime.time`
ImmutableMultiDict: (similar to a dictionary) that contains data sent via HTML forms with `Content-Type: application/x-www-form-urlencoded` or `multipart/form-data`.; Lesson 1217 — Request data
Impact or results: (if applicable—performance, users, insights); Lesson 1289 — Building a portfolio
import: one Python file into another.; Lesson 685 — Module concept Lesson 697 — `if __name__ == '__main__':`
Important details: Lesson 164 — `.zfill(n)`
Important note: This method only checks *format* rules.; Lesson 162 — `.isidentifier()`
Imported: Only defines `say_hello`, prints nothing; Lesson 697 — `if __name__ == '__main__':`
Imported as a module: `import my_script` from another file; Lesson 697 — `if __name__ == '__main__':`
Importing multiple similar items: Lesson 688 — `import as` alias
Imports: Grouped (standard library, third-party, local) and alphabetized within groups.; Lesson 966 — PEP 8 reminders
In `conftest.py`: Lesson 941 — `conftest.py`
In `test_users.py`: Lesson 941 — `conftest.py`
in order: , left to right, giving each name its corresponding value.; Lesson 30 — Multiple assignment Lesson 1237 — URL routing in Django
in place: it doesn't create a new list.; Lesson 325 — `.append(x)`Lesson 332 — `.clear()`Lesson 343 — `.reverse()`Lesson 788 — `random.shuffle(lst)`
In this lesson: , you'll learn how to configure the delimiter and quoting style when reading or writing CSV files with Python's `csv` module.; Lesson 592 — CSV dialects
Inception: (multi-scale filters) each introduced innovations that shaped modern deep learning.; Lesson 1188 — Convolutional networks (CNNs)
includes both endpoints: .; Lesson 786 — `random.randint(a, b)`Lesson 1007 — `np.linspace`
Incorrect parsing: of quoted fields containing embedded newlines; Lesson 593 — Newline handling on CSV
indentation: (the spaces or tabs at the start of a line) to show which lines belong together.; Lesson 14 — Indentation as syntax Lesson 251 — `if` body indentation Lesson 966 — PEP 8 reminders
Indentation as syntax: PEP 8 recommends 4 spaces per level; Lesson 25 — Intro to PEP 8
Indented body: contains the code that runs when you call the function; Lesson 471 — `def` keyword
independent: advancing one doesn't affect the others.; Lesson 812 — `tee`Lesson 1146 — Naive Bayes
Independent samples: .; Lesson 1121 — Central limit theorem
index: always starts at 0.; Lesson 118 — Positive indexing Lesson 148 — `.find(sub)`Lesson 149 — `.rfind(sub)`Lesson 315 — Indexing into a list Lesson 1079 — Writing CSV Lesson 1247 — Indexes
Index 0: The script name itself; Lesson 827 — `sys.argv`
Index 1+: Any arguments you passed; Lesson 827 — `sys.argv`
index labels: and rotates them **into columns** (making data "wider" and "shorter"); Lesson 1071 — `.stack()` / `.unstack()`Lesson 1073 — Sorting
IndexError: if the index is out of range; Lesson 331 — `.pop(i)`
IndexError on invalid indices: `arr[100]` will raise an error if the array doesn't have that many elements; Lesson 1013 — Indexing 1D arrays
Infinite indexing: Lesson 799 — `count`
Infinity (`inf`): Represents a value larger than any finite number—think of it as "unboundedly large"; Lesson 66 — Infinity and NaN
INFO: – Confirmation that things are working as expected; Lesson 959 — `logging` module basics Lesson 960 — Log levels
Inheritance and mixins: – Standard OOP patterns; Lesson 679 — Custom metaclasses
Initialization: Create a placeholder array before filling it with computed values; Lesson 1004 — `np.zeros` / `np.ones`
Injection: Attackers inserting malicious SQL, shell commands, or code into your queries (SQL injection is the classic example).; Lesson 1277 — Application security basics
Inner: When you need only complete records with matching keys on both sides.; Lesson 1076 — Join types
inner function: (or nested function) is simply a function defined inside the body of another function.; Lesson 511 — Inner functions Lesson 751 — Decorators with arguments
Inner join: Keep only rows where keys exist in *both* DataFrames.; Lesson 1076 — Join types Lesson 1246 — JOINs
Innermost function: the wrapper that runs when the decorated function is called; Lesson 519 — Decorators with arguments
Input gate: Decides what new information to store; Lesson 1190 — LSTMs and GRUs
Input layer: Raw pixels (e.; Lesson 1188 — Convolutional networks (CNNs)
Inputs arrive: You have multiple input values (features), like `[x₁, x₂, x₃]`; Lesson 1168 — Perceptrons and neurons
Insecure Design: Fundamental flaws in how your app is architected (missing authentication on critical routes).; Lesson 1277 — Application security basics
INSERT: → Create new records; Lesson 1245 — SELECT, INSERT, UPDATE, DELETE
Inside `__init__`: Call `super().; Lesson 1181 — Defining a model with `nn.Module`
Inside `forward`: Define how data flows through your network.; Lesson 1181 — Defining a model with `nn.Module`
Inspecting paths: Lesson 578 — `os.path` basics
Installation: Lesson 970 — `ruff` — the modern linter Lesson 994 — `README.md`
Installing: them so Python can import them; Lesson 706 — What is pip
Installs everything: into your Python environment's `site-packages` directory; Lesson 707 — `pip install package`
instance: is the actual house built from that blueprint.; Lesson 619 — Class as a blueprint Lesson 753 — Class-based decorators
instance method: .; Lesson 625 — Instance methods Lesson 628 — When to use each
integer: .; Lesson 196 — `*` multiplication Lesson 1049 — Row selection with `.iloc`
integer division: .; Lesson 50 — Integer division `//`Lesson 61 — True division `/`Lesson 198 — `//` floor division
Integers: Lesson 1010 — Array dtypes Lesson 1011 — Choosing a dtype
Integration: Works seamlessly with other NumPy functions; Lesson 1006 — `np.arange`Lesson 1087 — Why matplotlib
Interactivity: Users explore data dynamically; Lesson 1106 — Plotly intro
Interactivity by default: Every chart you create is interactive in browsers and Jupyter notebooks.; Lesson 1107 — Plotly Express Lesson 1108 — Bokeh intro
Internal implementation detail: Other parts of your code shouldn't depend on it; Lesson 41 — Leading underscore convention
Internal interpreter problems: that don't fit other categories; Lesson 555 — `RuntimeError`
Internal time: reveals "hot loops"—a simple string manipulation called a million times might top tottime even though it's a small function.; Lesson 974 — Reading profile output
Internationalization: Built-in support for multiple languages; Lesson 1234 — Why Django
Interpretation: On average, predictions are off by 10 units.; Lesson 1156 — MAE, MSE, R²
Invalid: Lesson 34 — Valid vs invalid identifiers Lesson 483 — Mixing positional and keyword
Invalid identifiers: break at least one rule.; Lesson 34 — Valid vs invalid identifiers
Inverses: Solve systems `Ax = b` as `x = A ¹ @ b` (though `np.; Lesson 1033 — Linear algebra (`np.linalg`)
Iris dataset: contains measurements of 150 iris flowers across three species.; Lesson 1137 — Loading a sample dataset
Isolation Forest: Faster, scales better, good for high-dimensional data; Lesson 1167 — Anomaly detection
isort: comes in.; Lesson 969 — Import sorting with isort Lesson 970 — `ruff` — the modern linter
It doesn't: Python completely ignores your type hints at runtime.; Lesson 870 — Hints don't enforce
It's a safety check: If you're unsure whether a name is allowed, you can verify it against this list rather than guessing.; Lesson 36 — Listing keywords
It's consistent: works the same way across many object types; Lesson 350 — `copy.copy()`
It's explicit: the intent to copy is crystal clear; Lesson 350 — `copy.copy()`
It's the foundation: for understanding Python's copy semantics in general; Lesson 350 — `copy.copy()`
iterable: meaning you can loop through them character by character using a `for` loop.; Lesson 282 — Looping over a string Lesson 571 — Iterating a file object Lesson 654 — `__getitem__` / `__setitem__`Lesson 722 — Iterable vs iterator Lesson 816 — `reduce`
iterate: (step through) any collection of items — strings, ranges, lists, or other sequences — executing the same block of code for each item.; Lesson 281 — `for` basics Lesson 378 — Tuples are immutable Lesson 1184 — Training loop
Iterating over a range: Lesson 281 — `for` basics
Iterating over a string: Lesson 281 — `for` basics
iterator: is the behind-the-scenes worker that actually steps through the iterable one item at a time.; Lesson 722 — Iterable vs iterator Lesson 723 — `iter()` built-in Lesson 724 — `next()` built-in Lesson 808 — `islice`

J

JavaScript: files (for interactivity); Lesson 1219 — Static files
Jenkins: Lesson 1275 — CI/CD basics
Jinja2-like: template engine to inject Python variables into HTML.; Lesson 1238 — Views and templates
JOIN: operation combines rows from two or more tables based on a related column between them—like matching a customer ID in an orders table to the customer ID in a customers table.; Lesson 1246 — JOINs
Joining paths: Use `os.; Lesson 578 — `os.path` basics
JSON over HTTP: is the standard pattern where APIs send and receive JSON in HTTP request and response bodies.; Lesson 1200 — JSON over HTTP
Jupyter notebooks: (or JupyterLab), you can configure matplotlib to render plots **inline**—meaning they appear directly beneath the code cell that generated them.; Lesson 1110 — Jupyter integration
Just right: (balanced): The string produces a clear note and handles small variations; Lesson 1133 — Overfitting and underfitting Lesson 1161 — Learning curves Lesson 1175 — Learning rate

K

Keep secrets secret: Never hard-code keys in your script.; Lesson 1206 — Headers and auth
Keras: started as a separate high-level API but is now integrated directly into TensorFlow as `tf.; Lesson 1195 — TensorFlow / Keras preview
Key differences: Lesson 1195 — TensorFlow / Keras preview
Key differences from `: `:**; Lesson 780 — `math.sqrt`, `math.pow`
Key point: Unlike many Python ranges, `randint` **includes both endpoints**.; Lesson 786 — `random.randint(a, b)`
Key points: Lesson 864 — `subprocess`
Key strategies: Lesson 1149 — Handling missing values
keys: , not values.; Lesson 430 — `in` on dicts Lesson 448 — Iterating keys Lesson 452 — Sorting dicts by value
Keyword arguments: let you specify which parameter gets which value by using the parameter's name, regardless of order.; Lesson 482 — Keyword arguments
Keyword format placeholders: let you use meaningful names inside the curly braces instead of numbers.; Lesson 175 — Keyword format placeholders
Keyword-only parameters: (after `*args` or after a bare `*`); Lesson 488 — Order of parameters
Knowledge sharing: Reviewers learn your approach; you learn from their suggestions; Lesson 989 — Pull requests / merge requests
Kurtosis ≈ 3: (or **excess kurtosis ≈ 0**): normal distribution; Lesson 1115 — Skew and kurtosis

L

Labeled axes: Rows have an index; columns have names; Lesson 1040 — `pd.DataFrame` basics
Labels (y): The target variable you want to predict (e.; Lesson 1138 — `train_test_split`
Labels everywhere: Every column has a name, every row has an index.; Lesson 1037 — Why pandas
Labels outliers as noise: (doesn't force them into clusters); Lesson 1163 — DBSCAN
lambda: is a shorthand way to define a function without giving it a name.; Lesson 505 — Lambda syntax Lesson 1274 — Cloud deployment options
Lambda functions: they're anonymous and Python can't reconstruct them; Lesson 905 — Pickling requirements
Language-agnostic: Every major language can parse JSON and speak HTTP; Lesson 1200 — JSON over HTTP
Large codebases: Split a massive package across repositories without conflicts.; Lesson 705 — Namespace packages Lesson 970 — `ruff` — the modern linter
Large datasets: Optimized for handling substantial amounts of data; Lesson 1108 — Bokeh intro
Large files: Text is verbose.; Lesson 1085 — Parquet / Feather formats
Large gap between curves: High variance → get more data, reduce model complexity, or add regularization; Lesson 1161 — Learning curves
Large sample sizes: reduce variance (by the law of large numbers, each mean gets closer to the population mean).; Lesson 1121 — Central limit theorem
last: slash, giving you exactly what you need.; Lesson 145 — `.rpartition(sep)`Lesson 149 — `.rfind(sub)`Lesson 462 — Handling key collisions
Latency: how long requests take (p50, p95, p99 percentiles); Lesson 1276 — Monitoring and metrics
Law of Large Numbers: says that as you increase your sample size, the **sample average** will get closer and closer to the **true population mean**.; Lesson 1120 — Sampling and the law of large numbers
Layers as attributes: (defined in `__init__`); Lesson 1181 — Defining a model with `nn.Module`
lazy: computes values *one at a time*, only when requested; Lesson 741 — Comprehension vs generator Lesson 848 — Greedy vs lazy quantifiers
lazy evaluation: work is deferred until absolutely necessary.; Lesson 732 — Generators are lazy Lesson 742 — Passing generators to functions
Learn: explore what Python considers different values to be; Lesson 85 — The `type()` function
learning rate: controls how big each step is.; Lesson 1172 — Gradient descent Lesson 1175 — Learning rate Lesson 1193 — Fine-tuning a transformer
left: , the value goes on the **right**.; Lesson 27 — Assignment with `=`Lesson 134 — `.lstrip()` / `.rstrip()`Lesson 145 — `.rpartition(sep)`Lesson 166 — `.rjust(n)`Lesson 1076 — Join types
Left join: Keep *all* rows from the left DataFrame; fill with `NaN` where the right has no match.; Lesson 1076 — Join types Lesson 1077 — Joining on the index Lesson 1246 — JOINs
Left to right: – if multiple parents exist, check them in the order you listed them; Lesson 641 — Method Resolution Order (MRO)
Left-justifying: means your text starts at the left edge and any extra space is added to the right to reach a target width.; Lesson 165 — `.ljust(n)`
legal: (valid identifiers) and which will cause errors.; Lesson 34 — Valid vs invalid identifiers Lesson 261 — Chained ternaries
LEGB rule: the exact order Python follows when searching for a variable name.; Lesson 497 — LEGB rule
LeNet: (digit recognition), **AlexNet** (ImageNet breakthrough), **VGG** (uniform design), **ResNet** (skip connections), and **Inception** (multi-scale filters) each introduced innovations that shaped modern deep learning.; Lesson 1188 — Convolutional networks (CNNs)
Less typing: No need to count and assign values manually; Lesson 684 — Auto values in enums Lesson 687 — `from ... import ...`
Letters: (a-z, A-Z); Lesson 33 — Naming rules
License: – How others can use your code; Lesson 994 — `README.md`
LightGBM: (Light Gradient Boosting Machine): Even faster, uses histogram-based algorithms, excellent for large datasets; Lesson 1143 — Gradient boosting
Lightweight: JSON is compact compared to older formats like XML; Lesson 1200 — JSON over HTTP
Lightweight environments: You prefer `venv` and don't need heavy system-level dependencies; Lesson 719 — pip vs conda
Line length: Target 79–99 characters (PEP 8 says 79, but many teams allow up to 99 for code).; Lesson 966 — PEP 8 reminders
Linear transformation: `z = (input × weight) + bias`; Lesson 1170 — Forward propagation
Linting: is the process of running a static analysis tool over your code to flag style issues, programming errors, suspicious constructs, and deviations from best practices—all *without* executing the program.; Lesson 967 — Linting with flake8 / pylint
Linux: Most Linux systems come with Python pre-installed, but you can install or update it using your package manager if needed.; Lesson 4 — Installing Python Lesson 1262 — Installing Docker
Linux/macOS: uses `cron`:; Lesson 1284 — Project: automation script
list: of the pieces.; Lesson 138 — `.split()`Lesson 142 — `.splitlines()`Lesson 283 — Looping over a list Lesson 307 — List literal `[]`Lesson 390 — Tuple vs list rule of thumb Lesson 570 — `.readlines()`Lesson 789 — `random.sample(pop, k)`Lesson 837 — `re.findall` (+3 more)
List all: `b` (no arguments); Lesson 953 — Setting breakpoints
list comprehension: lets you do the same thing in a single, readable expression.; Lesson 356 — Basic comprehension Lesson 741 — Comprehension vs generator
List of dicts (row-oriented): Natural when you receive data row-by-row (e.; Lesson 1042 — Creating from a list of dicts
list of strings: .; Lesson 588 — `csv.reader`Lesson 825 — `os.listdir`
Lists: work best for:; Lesson 390 — Tuple vs list rule of thumb Lesson 873 — Container hints
Lists/tuples: Python walks through *every element* until it finds a match (or reaches the end).; Lesson 423 — Fast membership tests
Load: a pre-trained model (e.; Lesson 1281 — Project: ML model API
Load balancing: can distribute requests across multiple Gunicorn/Uvicorn instances.; Lesson 1273 — Reverse proxy with Nginx
Load the model: at startup.; Lesson 1281 — Project: ML model API
local: to the function—it only exists while the function is running and cannot be accessed from outside.; Lesson 493 — Local scope Lesson 496 — Built-in scope
Local application: imports (your own modules); Lesson 969 — Import sorting with isort
Locked files: Other programs can't access them; Lesson 565 — Why `with` is preferred
Locks: prevent simultaneous access, **Conditions** and **Events** help threads *communicate* and wait for specific states:; Lesson 898 — Conditions and Events
Log: changes for debugging or auditing; Lesson 667 — `__setattr__` / `__delattr__`
Log analyzer: Parse logs, count errors, post metrics to a dashboard; Lesson 1284 — Project: automation script
Log everything: Use the `logging` module to track what happened; Lesson 1284 — Project: automation script
Log files: Make JSON logs human-scannable; Lesson 597 — Pretty-printing JSON
Log levels: let you categorize messages by severity, so you can control what gets recorded and where.; Lesson 960 — Log levels
Log rotation: solves this by automatically creating new log files based on rules you define.; Lesson 964 — Rotating logs
Logger: – decides *if* the message should be processed; Lesson 961 — Configuring loggers
Logging and monitoring: capabilities; Lesson 1272 — Uvicorn for ASGI
Logging critical events: before a long-running or risky operation; Lesson 577 — Flushing buffers
Logging structured data: Make complex data human-readable; Lesson 595 — `json.dumps`
Logistic regression: `C` (regularization strength); Lesson 1158 — Hyperparameters
Logs: Text records of events (requests, errors, debug info); Lesson 1276 — Monitoring and metrics
Loop body: The indented block that runs each time; Lesson 273 — `while` basics
Loop control: Understanding how many iterations you need; Lesson 363 — `len(lst)`
loss function: (or cost function) is a mathematical formula that quantifies the difference between your model's predictions and the actual target values.; Lesson 1171 — Loss functions Lesson 1183 — Loss functions in PyTorch
Low kurtosis: light tails, fewer outliers; Lesson 1115 — Skew and kurtosis
Low p-value: (< 0.; Lesson 1123 — p-values explained

M

Machine learning: is a field of computer science where programs *learn patterns from data* instead of following explicitly coded rules.; Lesson 1128 — What is machine learning
Machine Learning / AI: Lesson 1287 — Specialization paths
Machine Learning & AI: Those recommendation systems on Netflix?; Lesson 2 — Why learn Python
macOS: Open the downloaded file and follow the installation wizard.; Lesson 4 — Installing Python Lesson 1262 — Installing Docker
MAE: Use when all errors matter equally and you want easy interpretation; Lesson 1156 — MAE, MSE, R²
Maintainability: Update code in one place; Lesson 685 — Module concept Lesson 744 — Why decorators Lesson 846 — Named groups Lesson 878 — `TypeAlias`Lesson 1250 — SQLAlchemy Core
Maintenance: Changes to one piece of logic stay isolated.; Lesson 623 — Helper methods
MAJOR: (leftmost): Increment when you make **incompatible API changes**; Lesson 996 — Versioning your package
Make commits: with clear messages; Lesson 989 — Pull requests / merge requests
Make it configurable: Use environment variables or config files; Lesson 1284 — Project: automation script
Make revisions: push additional commits addressing feedback; Lesson 989 — Pull requests / merge requests
Make the edit: (fix the typo, improve the example); Lesson 1286 — Contributing to open source
Managers: when you need shared mutable objects like lists or dicts.; Lesson 904 — Sharing data across processes
Managing: versions and dependencies; Lesson 706 — What is pip
Many samples: reveal the underlying distribution of those means.; Lesson 1121 — Central limit theorem
Map attributes to columns: using special objects; Lesson 1251 — SQLAlchemy ORM
Masking: Start with all ones, then set specific values to zero; Lesson 1004 — `np.zeros` / `np.ones`
Match built-ins: – Many built-in functions (like `len(obj)`, `abs(x)`) enforce positional-only semantics.; Lesson 490 — Positional-only parameters `/`
Match object: .; Lesson 840 — Match objects
Mathematical functions: Built-in optimized implementations written in C; Lesson 1002 — Why NumPy
Mathematical operations: Begin calculations with a neutral element; Lesson 1004 — `np.zeros` / `np.ones`
Mathematical transforms: Log, square root, polynomial features; Lesson 1150 — Feature engineering
matplotlib: is Python's *foundational* plotting library—the oldest, most established tool for creating static charts.; Lesson 1087 — Why matplotlib Lesson 1106 — Plotly intro
mean: is the sum of all values divided by the count.; Lesson 855 — `statistics` module Lesson 1066 — Multiple aggregations Lesson 1111 — Mean, median, mode
Mean (μ): The center of the distribution.; Lesson 1118 — Normal distribution
Mean Absolute Error (MAE): Absolute difference.; Lesson 1171 — Loss functions
Mean Squared Error (MSE): Squares the difference between predictions and targets.; Lesson 1171 — Loss functions Lesson 1183 — Loss functions in PyTorch
Mean/median: Numerical features where the average is meaningful; Lesson 1149 — Handling missing values
Measure with profiling tools: get real data about where time is spent; Lesson 979 — When to optimize
median: is the middle value when data is sorted.; Lesson 855 — `statistics` module Lesson 1111 — Mean, median, mode Lesson 1113 — Quantiles and percentiles
Medical screening: High recall (catch all cases) for serious diseases.; Lesson 1153 — Accuracy, precision, recall, F1
Memoization: works the same way: when a function is called with specific arguments, Python stores the result.; Lesson 817 — `lru_cache`
Memory: NumPy arrays use far less memory (no object overhead per element); Lesson 1002 — Why NumPy
Memory efficiency: Only one value exists at a time; Lesson 742 — Passing generators to functions
Memory efficient: Doesn't build a full list upfront; Lesson 838 — `re.finditer`
Memory-efficient: generates values lazily, one at a time; Lesson 811 — `accumulate`
Memory-efficient generator: Lesson 733 — Memory efficiency of generators
Memory-hungry approach: Lesson 733 — Memory efficiency of generators
Message: Human-readable text explaining the specific problem; Lesson 529 — Exception messages
method: is simply a function defined inside a class.; Lesson 615 — Method definition Lesson 1196 — How HTTP works
Method called on `None`: Lesson 551 — `AttributeError`
method resolution order: .; Lesson 635 — Single inheritance Lesson 640 — Multiple inheritance Lesson 642 — `Class.__mro__`
Method Resolution Order (MRO): – the sequence Python follows when searching for a method or attribute.; Lesson 641 — Method Resolution Order (MRO)Lesson 643 — Diamond inheritance
Methods: Lesson 1201 — REST principles
Middle function: accepts the function to be decorated (the actual decorator); Lesson 519 — Decorators with arguments Lesson 751 — Decorators with arguments
MINOR: (middle): Increment when you **add functionality** in a backward-compatible way; Lesson 996 — Versioning your package
Miss: Lines not executed; Lesson 942 — Coverage with `pytest-cov`
Missing file extension: `"config"` instead of `"config.; Lesson 552 — `FileNotFoundError`
Misspelled method names: Lesson 551 — `AttributeError`
MIT: is the default choice.; Lesson 995 — LICENSE files
MIT License: The most popular.; Lesson 995 — LICENSE files
Mixed types: different columns can hold different data types (strings, ints, floats); Lesson 1041 — Creating from a dict of lists
ML workflow: consists of five essential phases:; Lesson 1134 — The ML workflow
Mnemonic: The axis number tells you *which index changes* as you move along that direction.; Lesson 1028 — `axis` argument
Mocking: means replacing those real dependencies with fake "mock" objects that you control completely.; Lesson 943 — Mocking with `unittest.mock`
mode: argument determines whether you're reading existing content, writing new content, or adding to the end of a file.; Lesson 557 — File modes: r, w, a Lesson 1111 — Mean, median, mode
model: by subclassing `django.; Lesson 1239 — Django ORM models Lesson 1254 — NoSQL preview
Model parameters: (learned parameters): These are the values the algorithm *learns* from your training data.; Lesson 1158 — Hyperparameters
Modern: (Python 3.; Lesson 872 — Union types
Modern aesthetics: Professional, web-native styling out of the box; Lesson 1106 — Plotly intro
Modern features: Early support for new Python typing features (like `Self`, `TypeAlias`, etc.; Lesson 890 — `pyright` and `pylance`
Modern rules: Built-in support for type hints, f-strings, walrus operators, and Python 3.; Lesson 970 — `ruff` — the modern linter
Modern syntax (Python 3.10+): Lesson 872 — Union types
Modifications don't auto-reload: If you edit `config.; Lesson 692 — Re-imports & caching
Modified files: you've edited since the last commit; Lesson 983 — `git status` / `git diff`
modify: the existing list; Lesson 343 — `.reverse()`Lesson 1252 — Sessions and transactions
Modifying the wrong variable: Lesson 280 — Avoiding infinite loops
Modularity: Each app handles one concern (blog, user authentication, shopping cart); Lesson 1236 — Apps within a project
Module-level names: are simply the names defined directly in your file—not nested inside any function.; Lesson 495 — Global scope
Monitoring: means collecting data about your application's behavior, while **metrics** are the specific measurements you track.; Lesson 1276 — Monitoring and metrics
More readable: The intent is clearer at a glance; Lesson 460 — `d1 | d2`Lesson 482 — Keyword arguments
Most frequent: Categorical variables (strings or codes); Lesson 1149 — Handling missing values
Move the model once: ; move each batch of data every iteration.; Lesson 1186 — GPU acceleration
MSE: Use when large errors are especially costly (training often minimizes this); Lesson 1156 — MAE, MSE, R²
Multi-class output: Softmax; Lesson 1169 — Activation functions
Multi-Head Attention: Instead of one attention mechanism, transformers use multiple "heads" that each learn different relationships—one might focus on grammar, another on semantics.; Lesson 1191 — Transformers intro
Multi-line logic: or complex expressions; Lesson 507 — Lambda vs def
Multi-plot grids: Creating small multiples (like comparing distributions across categories) is straightforward with seaborn's grid functions.; Lesson 1099 — Why seaborn
MultiIndex: (also called a hierarchical index) is a pandas structure that allows you to have multiple levels of row or column labels.; Lesson 1072 — Hierarchical indexes
multiple arguments: at the same time.; Lesson 237 — Printing multiple values Lesson 814 — `starmap`
Multiple columns: `df[['col1', 'col2']]` → returns a **DataFrame**; Lesson 1046 — Column selection
Multiple fallbacks: Lesson 216 — Idiom: default value with `or`
Multiple worker processes: for handling concurrent requests; Lesson 1272 — Uvicorn for ASGI
must: indent the next line.; Lesson 251 — `if` body indentation Lesson 373 — Single-element tuple Lesson 399 — Empty set Lesson 489 — Keyword-only arguments Lesson 536 — `finally` clause Lesson 604 — `shelve` module Lesson 649 — Forcing subclasses to override Lesson 658 — `__hash__` (+2 more)
mutable: means an object's contents can be changed in-place without creating a new object.; Lesson 324 — Lists are mutable Lesson 420 — Frozensets as dict keys

N

Name shadowing: happens when you create a variable with the same name as one of these built-ins.; Lesson 37 — Built-in name shadowing
Named colors: `'red'`, `'blue'`, `'green'`, `'orange'`, etc.; Lesson 1092 — Customizing styles
Named groups: let you assign descriptive labels to captured text, making your code self-documenting and easier to maintain.; Lesson 846 — Named groups
Namespace: Keep related code grouped together; Lesson 685 — Module concept
Naming: Lesson 966 — PEP 8 reminders
NaN (`nan`): Stands for "Not a Number"—indicates an undefined or unrepresentable result; Lesson 66 — Infinity and NaN
Navigate to the folder: where your `hello.; Lesson 11 — Running a .py script
Negative indexing works: `-1` gets the last element, `-2` the second-to-last, etc.; Lesson 1013 — Indexing 1D arrays
Negative indices work too: `colors.; Lesson 331 — `.pop(i)`
Negative steps (counting backwards): Lesson 287 — `range(start, stop, step)`
Nested approach: Lesson 566 — Opening multiple files
Nested/local functions: defined inside other functions; Lesson 905 — Pickling requirements
never: a valid index.; Lesson 148 — `.find(sub)`Lesson 402 — Sets are unordered Lesson 791 — `secrets` module Lesson 1255 — Project structure for deploy
new: empty list:; Lesson 332 — `.clear()`Lesson 559 — `'x'` exclusive create Lesson 1044 — Index objects
new DataFrame: .; Lesson 1045 — Setting an index Lesson 1059 — Renaming columns Lesson 1061 — Removing duplicates Lesson 1073 — Sorting
New projects: Start with `ruff` instead of juggling three tools.; Lesson 970 — `ruff` — the modern linter
new set: containing only the elements that exist in both original sets.; Lesson 411 — Intersection `&`Lesson 412 — Difference `-`
new string: where every occurrence of the `old` substring has been replaced by the `new` substring.; Lesson 136 — `.replace(old, new)`Lesson 165 — `.ljust(n)`
no: .; Lesson 679 — Custom metaclasses Lesson 1148 — Encoding categoricals
No behavior needed: You don't need methods beyond field access.; Lesson 792 — `namedtuple` recap
No data duplication: The underlying dicts remain separate.; Lesson 470 — `collections.ChainMap`
No installation needed: Available wherever Python is installed; Lesson 690 — Standard library imports
No manual transform tracking: The pipeline remembers fitted parameters; Lesson 1151 — Pipelines
No metadata: Column types, indexes, categories — all lost.; Lesson 1085 — Parquet / Feather formats
No reassignment: You don't have to repeat the function name.; Lesson 516 — Function decoration syntax `@`
Non-capturing groups: let you group without the overhead of storing the match.; Lesson 847 — Non-capturing groups
Non-empty containers: We haven't covered containers yet, but the pattern holds; Lesson 72 — Truthy values
Non-empty strings: Any string with at least one character; Lesson 72 — Truthy values
Non-linear activation: `a = activation_function(z)`; Lesson 1170 — Forward propagation
Non-zero: (typically 1) means an error occurred; Lesson 828 — `sys.exit`
Non-zero numbers: Any integer or float except zero; Lesson 72 — Truthy values
Normal: (Gaussian): values cluster around a mean in a bell curve (like human heights); Lesson 1034 — Random sampling
Normal distribution: skew ≈ 0, kurtosis ≈ 0 (excess); Lesson 1115 — Skew and kurtosis Lesson 1118 — Normal distribution Lesson 1121 — Central limit theorem
NoSQL databases: offer flexible, non-relational storage models.; Lesson 1254 — NoSQL preview
not: text.; Lesson 69 — `True` and `False`Lesson 218 — `is not` operator Lesson 258 — `is None` checks Lesson 261 — Chained ternaries Lesson 305 — Labeling alternatives Lesson 494 — Enclosing (nonlocal) scope Lesson 574 — `.writelines(lst)`Lesson 665 — `__del__` (+9 more)
Not compressed: by default (bigger files, but instant I/O); Lesson 1085 — Parquet / Feather formats
Not idempotent: Sending the same POST twice might create two separate items.; Lesson 1197 — Methods: GET/POST/PUT/DELETE
Not safe: POST changes data on the server.; Lesson 1197 — Methods: GET/POST/PUT/DELETE
Notice the `?` placeholders: they prevent SQL injection attacks.; Lesson 1248 — SQLite with `sqlite3`
Notifications: Send alerts (email, Slack) on failures; Lesson 1284 — Project: automation script
Null checking: `if value is None`; Lesson 634 — Validation in setters
Number of epochs: Often 2–5 epochs are enough; more can lead to overfitting.; Lesson 1193 — Fine-tuning a transformer
Numeric types mix freely: You can compare `int` with `float` because Python considers them compatible numeric types.; Lesson 210 — Comparing different types
NumPy array: .; Lesson 1006 — `np.arange`

O

O(1): constant time, no matter how large the set.; Lesson 423 — Fast membership tests
O(n): slower as the collection grows.; Lesson 423 — Fast membership tests
O(n²) complexity: doubling the data quadruples the time.; Lesson 978 — Common optimizations
objects: that combine:; Lesson 605 — Why OOP Lesson 745 — First-class function recap
Old Mac: `\r` (carriage return only); Lesson 593 — Newline handling on CSV
once: at a specific separator and keep track of what came before it, the separator itself, and what came after.; Lesson 144 — `.partition(sep)`Lesson 485 — Mutable default argument trap Lesson 696 — Module-level code Lesson 821 — `cached_property`Lesson 915 — `asyncio.run(main())`
one: `None` object in your entire Python program (it's a singleton), `is` tests whether your variable points to that specific object.; Lesson 81 — Comparing to None with `is`Lesson 261 — Chained ternaries Lesson 325 — `.append(x)`Lesson 820 — `total_ordering`
one line: by separating both the names and values with commas:; Lesson 30 — Multiple assignment Lesson 569 — `.readline()`
One-Class SVM: More flexible with kernels, but slower on large datasets; Lesson 1167 — Anomaly detection
One-sided: "Group A is *greater than* Group B" (specific direction); Lesson 1122 — Hypothesis testing intro
only: letters and digits—no spaces, punctuation, or special characters—using `.; Lesson 157 — `.isalnum()`Lesson 158 — `.isspace()`Lesson 676 — `__slots__`Lesson 679 — Custom metaclasses Lesson 699 — `__all__` list
Open a pull/merge request: targeting the main branch; Lesson 989 — Pull requests / merge requests
Open an issue: proposing the feature; Lesson 1286 — Contributing to open source
Open file handles: you can't serialize a connection to a file; Lesson 905 — Pickling requirements
Open VS Code: (the application you installed in the previous lesson); Lesson 8 — Installing VS Code for Python
Open your terminal: (Command Prompt on Windows, Terminal on macOS/Linux); Lesson 11 — Running a .py script
OpenAPI specification: (formerly Swagger) under the hood, which is an industry-standard way to describe REST APIs.; Lesson 1228 — Automatic OpenAPI docs
Optimized: Lesson 978 — Common optimizations
Optional filter: You can add `if` conditions just like in comprehensions; Lesson 740 — Generator expression syntax
Optional flags: start with `--` or `-`, users can omit them; Lesson 863 — `argparse`
Optional function arguments: (e.; Lesson 871 — `Optional[X]`
Order independence: The order of keyword arguments in `.; Lesson 175 — Keyword format placeholders
Order matters: Earlier dicts in the chain have priority.; Lesson 470 — `collections.ChainMap`
Order-aware equality: two `OrderedDict` instances are equal only if they have the same items *in the same order*; Lesson 796 — `OrderedDict` features
Organization: Constants are easy to spot and update in one place; Lesson 39 — Constants by convention Lesson 685 — Module concept Lesson 1000 — Maintaining changelogs Lesson 1220 — Flask Blueprints Lesson 1236 — Apps within a project
Organize code: into logical files instead of one giant script; Lesson 695 — Creating your own module
OS clutter: like `.; Lesson 990 — `.gitignore`
Other developers: instantly see what types the function expects and returns; Lesson 867 — Why type hints
Outer: When you want a full picture of all data, even incomplete matches.; Lesson 1076 — Join types
Outer function: accepts the decorator's arguments; Lesson 751 — Decorators with arguments
Outer join: Keep *all* rows from *both* DataFrames; fill with `NaN` wherever a match is missing.; Lesson 1076 — Join types
Outer parentheses: Signal this is a generator expression; Lesson 740 — Generator expression syntax
Outermost function: accepts the decorator's arguments; Lesson 519 — Decorators with arguments
Outliers or extreme events: High kurtosis; Lesson 1115 — Skew and kurtosis
Output: Lesson 107 — Newline `\n`Lesson 108 — Tab `\t`Lesson 183 — Expressions in f-strings Lesson 237 — Printing multiple values Lesson 252 — `else` clauses Lesson 253 — `elif` chains Lesson 265 — Literal patterns Lesson 272 — Pattern guards with `if` (+56 more)
Output gate: Decides what to output based on the cell state; Lesson 1190 — LSTMs and GRUs
Overriding: means defining a method with the *same name* in the subclass, which replaces the parent's version for that subclass.; Lesson 637 — Overriding methods
Overwrites the file: Like opening in `'w'` mode, this replaces any existing content.; Lesson 584 — `Path.write_text()`
overwritten: with the new one.; Lesson 444 — `.update()`Lesson 458 — `d1.update(d2)`
OWASP Top Ten: is a regularly updated list of the most critical security risks facing web applications.; Lesson 1277 — Application security basics

P

p-value: is the probability of observing data **as extreme or more extreme** than what you actually got, **assuming the null hypothesis is true**.; Lesson 1123 — p-values explained Lesson 1124 — t-tests Lesson 1125 — Chi-squared tests
Pairing with another iterable: Lesson 799 — `count`
Parameter `nu`: Approximate fraction of anomalies expected (like `contamination`).; Lesson 1167 — Anomaly detection
Parametrized tests: let you define the test logic once, then feed it a table of test cases automatically.; Lesson 938 — Parametrized tests
Parent before grandparent: – respect the inheritance hierarchy; Lesson 641 — Method Resolution Order (MRO)
parentheses: instead of square brackets:; Lesson 740 — Generator expression syntax Lesson 741 — Comprehension vs generator Lesson 1052 — Combining conditions
Parquet: is a *columnar binary format* (stores data column-by-column instead of row-by-row).; Lesson 1085 — Parquet / Feather formats
Partial data: where some fields might be missing; Lesson 871 — `Optional[X]`
PATCH: (rightmost): Increment for **backward-compatible bug fixes**; Lesson 996 — Versioning your package Lesson 1196 — How HTTP works
Path components: Lesson 833 — `pathlib` recap
pattern: (like wildcards) and returning all matching files.; Lesson 582 — `Path.glob()`Lesson 839 — `re.sub`
Pause and resume training: without starting over; Lesson 1187 — Saving and loading models
pauses: at each `yield` statement, returns a value to the caller, and *remembers where it left off*.; Lesson 729 — `yield` keyword Lesson 730 — Generator function vs normal function
PCA: Fast, linear, interpretable—use first; Lesson 1166 — t-SNE and UMAP
PDF: – Vector format, perfect for print and academic papers:; Lesson 1096 — Saving figures Lesson 1117 — Probability distributions
PEP 8: stands for "Python Enhancement Proposal 8" — it's Python's official style guide.; Lesson 25 — Intro to PEP 8
PEP 8 compliance: Following the standard makes your code look professional; Lesson 39 — Constants by convention
Per-group filtering: Keep only top *n* rows per group.; Lesson 1068 — `.apply()` on groups
Perfect pandas fidelity: indexes, multi-indexes, categoricals; Lesson 1085 — Parquet / Feather formats
Performance: Often implemented in C for speed; Lesson 690 — Standard library imports Lesson 847 — Non-capturing groups Lesson 1006 — `np.arange`Lesson 1223 — Why FastAPI Lesson 1273 — Reverse proxy with Nginx
Performance hacks: – You need `__slots__` applied automatically across many classes; Lesson 679 — Custom metaclasses
Philosophy: PyTorch feels Pythonic and explicit; Keras aims for minimal code; Lesson 1195 — TensorFlow / Keras preview
Pickling: is Python's way of *serializing* (converting to bytes) any Python object so you can save it to a file.; Lesson 601 — `pickle.dump` / `pickle.load`Lesson 905 — Pickling requirements
pip: is Python's default **package installer**.; Lesson 706 — What is pip Lesson 719 — pip vs conda Lesson 720 — `pipx` for tools Lesson 1233 — Installing Django
Pipes: for simple two-process communication, and **Managers** when you need shared mutable objects like lists or dicts.; Lesson 904 — Sharing data across processes
Pivot tables: Aggregated data across two categorical dimensions; Lesson 1105 — Heatmaps
Placeholder exceptions: – Define custom exception classes that don't need extra behavior yet; Lesson 607 — Empty class with `pass`
Platform-dependent behavior: that breaks when sharing files; Lesson 593 — Newline handling on CSV
Plotly: , a powerful library that creates **interactive, web-based visualizations** you can zoom, pan, and explore directly in your browser.; Lesson 1106 — Plotly intro
Plotly generates HTML-based charts: that respond to user interaction.; Lesson 1106 — Plotly intro
Plotting: with libraries like Seaborn or Plotly (they expect long data); Lesson 1070 — `.melt()`
Plugin architectures: Multiple plugins can extend the same package namespace independently.; Lesson 705 — Namespace packages
PMF: gives exact probabilities for discrete outcomes, the **PDF** gives probability density for continuous values (area = probability), and the **CDF** accumulates probability from left to right for any distribution type.; Lesson 1117 — Probability distributions
PNG: – Raster format, great for web and presentations:; Lesson 1096 — Saving figures
Poetry: and **uv** are next-generation dependency managers that bundle both responsibilities into one streamlined tool.; Lesson 721 — Poetry & uv preview
Poisson: Counting rare events over time or space with no fixed upper limit (e.; Lesson 1119 — Binomial and Poisson
Poisson distribution: models the number of events occurring in a fixed interval when events happen independently at a constant average rate (like the number of emails you receive per hour).; Lesson 1119 — Binomial and Poisson
Polite scraping: means adding delays between requests, respecting `robots.; Lesson 1283 — Project: web scraper
Polymorphism: means "one interface, many implementations.; Lesson 647 — Polymorphism
Pooling layers: Downsample spatial dimensions, retain important features; Lesson 1188 — Convolutional networks (CNNs)
Portability: Your code works the same everywhere; Lesson 779 — UTC vs local time Lesson 1250 — SQLAlchemy Core
position: of a substring within a string, or get `-1` if it's not there.; Lesson 148 — `.find(sub)`Lesson 335 — `.index(x)`Lesson 352 — Iterating with index via enumerate Lesson 840 — Match objects
Positional arguments: required values in order (like `name` above); Lesson 863 — `argparse`
Positional Encoding: Since transformers process words in parallel (not sequentially), they add position information so the model knows word order.; Lesson 1191 — Transformers intro
Positional format placeholders: let you number those braces—`{0}`, `{1}`, `{2}`, etc.; Lesson 174 — Positional format placeholders
positional parameters: .; Lesson 481 — Positional parameters Lesson 488 — Order of parameters
POST: Send data to create something new (like submitting a form); Lesson 1196 — How HTTP works Lesson 1197 — Methods: GET/POST/PUT/DELETE Lesson 1201 — REST principles
PostgreSQL: is a production-grade relational database management system (RDBMS) used by companies worldwide.; Lesson 1249 — PostgreSQL with `psycopg`
Powerful features: fixtures, parameterization (you'll learn these later); Lesson 932 — Why pytest
precision: show 2 digits after the decimal; Lesson 176 — Format spec mini-language Lesson 1011 — Choosing a dtype Lesson 1153 — Accuracy, precision, recall, F1
Preparing data for APIs: Web services expect JSON strings; Lesson 595 — `json.dumps`
Prevents data leakage: Transformations use only training statistics; Lesson 1151 — Pipelines
Principal Component Analysis (PCA): to reduce the number of features in your dataset while preserving the most important information.; Lesson 1165 — PCA
Print: the value of an expression.; Lesson 952 — `pdb` commands
Private: Names with a leading underscore like `_validate_input()` or `_cache`—these are internal details that might change or break between versions; Lesson 622 — Public vs private API
Pro tip: Use the `in` operator first to check if the item exists before calling `.; Lesson 335 — `.index(x)`Lesson 659 — Ordering with `__lt__` etc.
Process: Lesson 816 — `reduce`
Process requests: parse JSON, preprocess features, call `model.; Lesson 1281 — Project: ML model API
Project A: needs version 1.; Lesson 714 — Virtual environments
Project B: needs version 2.; Lesson 714 — Virtual environments
Project metadata: (defined by PEP 621):; Lesson 993 — `pyproject.toml`
Project Title & Description: – One sentence explaining what it does; Lesson 994 — `README.md`
Prompt for credentials: Your PyPI username and password (or API token); Lesson 998 — `twine` for publishing
Propagate through activation: Multiply by `∂activation/∂z` (derivative of activation function); Lesson 1173 — Backpropagation
Pros: Fast to compute, helps networks train faster, reduces vanishing gradient; Lesson 1169 — Activation functions Lesson 1174 — Optimizers
protocol: (format) to serialize the data.; Lesson 603 — Pickle protocols Lesson 651 — Protocols (typing)Lesson 882 — Protocols
Protocol 0: The original, human-readable ASCII format (slowest, largest files); Lesson 603 — Pickle protocols
Protocol 1: Old binary format (obsolete); Lesson 603 — Pickle protocols
Protocol 2: Efficient binary format (Python 2.; Lesson 603 — Pickle protocols
Protocol 3: Added support for bytes objects (Python 3.; Lesson 603 — Pickle protocols
Protocol 4: Support for large objects, more efficient (Python 3.; Lesson 603 — Pickle protocols
Protocol 5: Out-of-band data buffers for specialized use (Python 3.; Lesson 603 — Pickle protocols
Protocols: offer a different approach: **structural typing** (also called "static duck typing").; Lesson 651 — Protocols (typing)
Public: Normal names like `calculate_total()` or `price`—these are the stable, documented parts users should rely on; Lesson 622 — Public vs private API
Publication-quality: output for research papers and reports; Lesson 1087 — Why matplotlib
Push: to your fork; Lesson 1286 — Contributing to open source
Push your branch: to the remote repository; Lesson 989 — Pull requests / merge requests
Pushing: sends your committed changes to a remote server—typically GitHub or GitLab—where they're stored safely, backed up, and visible to collaborators.; Lesson 988 — Pushing to a remote
PUT: Update existing data completely; Lesson 1196 — How HTTP works Lesson 1197 — Methods: GET/POST/PUT/DELETE Lesson 1201 — REST principles
PyCoder's Weekly: is a curated digest of Python articles, tutorials, and projects sent every Tuesday.; Lesson 1288 — Staying current
PyCon: (especially PyCon US) is *the* global gathering—thousands of developers, hundreds of talks, and all videos posted free on YouTube.; Lesson 1288 — Staying current
PyCon AU: , and regional PyCons around the world bring localized communities together with equally excellent content.; Lesson 1288 — Staying current
Pydantic models: to handle this elegantly: you define a Python class describing what data you expect, and FastAPI does the rest.; Lesson 1226 — Request bodies with Pydantic
PyData: conferences focus on data science, NumPy, pandas, and ML—ideal if that's your path.; Lesson 1288 — Staying current
Pylance: extension from the VS Code marketplace.; Lesson 890 — `pyright` and `pylance`
PyPI: stands for the **Python Package Index**.; Lesson 718 — PyPI
PyPI exclusives: The package you need is only on PyPI (happens occasionally); Lesson 719 — pip vs conda
Pytest output: Lesson 935 — `assert` in pytest
Python 2: was released in 2000 and became wildly popular.; Lesson 3 — Python 2 vs Python 3
Python 3: arrived in 2008 as a major upgrade that intentionally broke backward compatibility to fix these issues.; Lesson 3 — Python 2 vs Python 3
Python 3 is stricter: .; Lesson 210 — Comparing different types
Python 3.x: (for example, Python 3.; Lesson 4 — Installing Python
Python Bytes: is a short, weekly news show—perfect for staying on top of releases and trends in ~15 minutes.; Lesson 1288 — Staying current
Python Discord servers: offer real-time discussions; Lesson 1288 — Staying current
Python Enhancement Proposals (PEPs): at python.; Lesson 1288 — Staying current
Python extension: .; Lesson 8 — Installing VS Code for Python
Python Package Index: .; Lesson 718 — PyPI
Python Weekly: is similar—another high-quality roundup of what's happening in the community.; Lesson 1288 — Staying current
Python-only projects: You're building web apps, scripts, or APIs that only need pure Python packages; Lesson 719 — pip vs conda
Pythonic: Comprehensions are idiomatic Python.; Lesson 356 — Basic comprehension
Pythonic default: for most cases.; Lesson 361 — Comprehensions vs map/filter
Pythonic trust: Python philosophy prefers readability and trust over rigid enforcement.; Lesson 620 — Encapsulation by convention
Pythonic way: to iterate with an index.; Lesson 352 — Iterating with index via enumerate

Q

Quality gate: Bugs, style issues, or design flaws are caught before deployment; Lesson 989 — Pull requests / merge requests
Queues: Add to the right, remove from the left.; Lesson 793 — `deque`Lesson 904 — Sharing data across processes
Quick file operations: Lesson 833 — `pathlib` recap
Quit: the debugger and terminate the program immediately.; Lesson 952 — `pdb` commands

R

R²: Use to understand overall model quality, but combine it with MAE or MSE for complete picture; Lesson 1156 — MAE, MSE, R²
Random forest: `n_estimators` (number of trees), `max_depth` (tree depth); Lesson 1158 — Hyperparameters
Random sampling: from the population.; Lesson 1121 — Central limit theorem
Random selection: Picks combinations randomly from the parameter space; Lesson 1160 — `RandomizedSearchCV`
Randomizing features: Each split in each tree considers only a random subset of features; Lesson 1142 — Random forests
Range checking: `if value < min_val or value > max_val`; Lesson 634 — Validation in setters
Rapid prototyping: Perfect for exploratory data analysis when you need to visualize trends quickly before deciding if deeper customization is needed.; Lesson 1107 — Plotly Express
Ratios and percentages: `income_to_debt_ratio = income / debt`; Lesson 1150 — Feature engineering
Re-measure: confirm your optimization actually helped; Lesson 979 — When to optimize
Read: elements: `my_tuple[0]` works; Lesson 378 — Tuples are immutable Lesson 495 — Global scope Lesson 512 — Capturing enclosing variables Lesson 589 — `csv.writer`Lesson 1081 — Writing Excel
Read the report: showing microseconds-per-line; Lesson 976 — Line profilers
Read-Eval-Print-Loop: .; Lesson 10 — The Python REPL
Readability: when the operation isn't obvious; Lesson 507 — Lambda vs def Lesson 516 — Function decoration syntax `@`Lesson 623 — Helper methods Lesson 744 — Why decorators Lesson 846 — Named groups Lesson 849 — Compiling patterns Lesson 878 — `TypeAlias`
readable: .; Lesson 14 — Indentation as syntax Lesson 356 — Basic comprehension Lesson 947 — Doctests Lesson 1041 — Creating from a dict of lists
Readable syntax: Lets you focus on the problem, not the code; Lesson 1128 — What is machine learning
Reading the comprehension: "For each sublist in nested, then for each item in that sublist, collect the item.; Lesson 360 — Flattening with comprehensions
Real Python Newsletter: includes tutorials from their deep library, plus community news and job postings.; Lesson 1288 — Staying current
Real Python Podcast: blends tutorials with interviews and is great for intermediate learners.; Lesson 1288 — Staying current
Real-time monitoring: another process needs to read the file while you're writing; Lesson 577 — Flushing buffers
Real-world analogy: Think of it like arithmetic: `2 + 3 * 4` gives you `14`, not `20`, because multiplication happens first.; Lesson 77 — Combining booleans Lesson 1197 — Methods: GET/POST/PUT/DELETE
Real-world use cases: Lesson 1167 — Anomaly detection
Reassign elements: `my_tuple[1] = 5` raises an error; Lesson 378 — Tuples are immutable
Recall: (Sensitivity) = (true positives) / (all actual positives); Lesson 1153 — Accuracy, precision, recall, F1
Receive feedback: reviewers comment on specific lines, suggest changes, or approve; Lesson 989 — Pull requests / merge requests
Recommendation engines: Balance both with F1 to avoid annoying users or missing opportunities.; Lesson 1153 — Accuracy, precision, recall, F1
Recurrent Neural Networks (RNNs): are designed for sequential data where order matters—like time series, text, audio, or video.; Lesson 1189 — Recurrent networks (RNNs)
Recursion issues: (though Python usually raises `RecursionError`, a subclass); Lesson 555 — `RuntimeError`
Recursive functions: with a known, small range of inputs (like Fibonacci).; Lesson 818 — `cache` (3.9+)
Recursively: copies all nested objects; Lesson 854 — `copy` module
Reddit's r/Python: and **Python Discord servers** offer real-time discussions; Lesson 1288 — Staying current
Redirect: assignments to alternative storage (like a dictionary); Lesson 667 — `__setattr__` / `__delattr__`
ReDoc: at `/redoc`; Lesson 1228 — Automatic OpenAPI docs
Reduce repetition: Create specialized functions without rewriting logic; Lesson 515 — Using closures for factories
Registry patterns: where the class maintains a list of all instances; Lesson 886 — `ClassVar`
regression: is when working code breaks later.; Lesson 926 — Why testing Lesson 1130 — Regression vs classification Lesson 1137 — Loading a sample dataset Lesson 1141 — Decision trees
Regression output: A number from a continuous range (infinite possibilities); Lesson 1130 — Regression vs classification
Regular comment (`#`): Python ignores it completely; Lesson 20 — Docstring preview
Regular function: Runs immediately when called; Lesson 912 — Coroutines with `async def`
Regular package: Has `__init__.; Lesson 705 — Namespace packages
Regular strings (`str`): are like a book written in any language — they represent *meaning* and characters.; Lesson 106 — Byte strings preview
relative: address might be "two doors down," but an **absolute** address is "123 Main Street, Springfield.; Lesson 703 — Absolute imports Lesson 969 — Import sorting with isort
Relative paths: start from your current working directory and might include `.; Lesson 587 — Relative vs absolute paths
Reliability: Battle-tested code maintained by the Python core team; Lesson 690 — Standard library imports
remainder: when one integer is divided by another.; Lesson 51 — Modulo `%`Lesson 199 — `%` modulo
Remember: All arguments come in as **strings**.; Lesson 827 — `sys.argv`
Remove a substring: by replacing it with an empty string:; Lesson 136 — `.replace(old, new)`
Remove elements: No `.; Lesson 378 — Tuples are immutable
Remove noise: By keeping only the most important information, models may generalize better.; Lesson 1165 — PCA
Repeat: Continue adding trees, each correcting the remaining errors; Lesson 1143 — Gradient boosting Lesson 1172 — Gradient descent
Replace all occurrences: Lesson 136 — `.replace(old, new)`
Replacing the document: in an existing folder with a new one; Lesson 426 — Adding keys
Report generator: Query a database, create a CSV, email it every Monday; Lesson 1284 — Project: automation script
Reports failures: if any output doesn't match; Lesson 948 — Running doctests
Reproducibility: – Every developer on your team gets the same versions; Lesson 709 — Installing a specific version
Reproducibility across platforms: conda environments are more portable between Windows/Mac/Linux for scientific software; Lesson 719 — pip vs conda
Request arrives: A user visits `/blog/post/42/`; Lesson 1238 — Views and templates
Request rates: How many operations per second/minute your app handles; Lesson 1276 — Monitoring and metrics
Request reviewers: teammates who'll inspect your code; Lesson 989 — Pull requests / merge requests
Requirements: – Python version, dependencies; Lesson 994 — `README.md`
Reset gate: Decides how much past information to forget; Lesson 1190 — LSTMs and GRUs
ResNet: (skip connections), and **Inception** (multi-scale filters) each introduced innovations that shaped modern deep learning.; Lesson 1188 — Convolutional networks (CNNs)
Resolves dependencies: (installs other packages this one needs); Lesson 707 — `pip install package`
Resource cleanup: is better handled with context managers (`__enter__` / `__exit__`); Lesson 665 — `__del__`
Resource leaks: Your operating system has a limit on how many files can be open at once.; Lesson 562 — Closing files Lesson 565 — Why `with` is preferred
Resources: Lesson 1201 — REST principles
Response models: let you explicitly declare the shape and type of data your endpoint will return.; Lesson 1227 — Response models
Response object: .; Lesson 1208 — Handling responses
Response sent: The final HTML travels back to the user's browser; Lesson 1238 — Views and templates
REST: (Representational State Transfer) is an architectural style for designing networked applications, particularly web APIs.; Lesson 1201 — REST principles
Restart your computer: if prompted; Lesson 1262 — Installing Docker
RESTful JSON API: .; Lesson 1243 — Django REST framework
Result: Threading gives you no speedup for CPU-bound tasks.; Lesson 900 — The GIL Lesson 1083 — Reading SQL
Resume: Continue until the next breakpoint; Lesson 957 — PyCharm debugger basics
Return: the predictions as JSON.; Lesson 1281 — Project: ML model API
Return `False`: or `None` (the default) → let the exception propagate normally; Lesson 761 — Exception handling in `__exit__`
Return `True`: (or any truthy value) → suppress the exception (don't re-raise it); Lesson 761 — Exception handling in `__exit__`
Return a dictionary directly: Flask automatically converts it to JSON (Flask 1.; Lesson 1216 — Returning JSON
Return dict: Cleaner for simple cases; Lesson 1216 — Returning JSON
Returns a clear error: if validation fails; Lesson 1225 — Path and query parameters
Returns the removed item: so you can use it immediately; Lesson 331 — `.pop(i)`
Reusability: You can use the same name multiple times:; Lesson 175 — Keyword format placeholders Lesson 623 — Helper methods Lesson 685 — Module concept Lesson 744 — Why decorators Lesson 849 — Compiling patterns Lesson 1220 — Flask Blueprints Lesson 1230 — Dependency injection Lesson 1236 — Apps within a project
Reuse functions: across multiple projects without copy-pasting; Lesson 695 — Creating your own module
Reversibility: You can iterate in reverse more explicitly; Lesson 469 — `collections.OrderedDict`
Reversible: Many migrations can be rolled back if something goes wrong.; Lesson 1240 — Migrations
Reverting Mistakes: Lesson 980 — Why version control
Review it: Migrations are stored as `.; Lesson 1240 — Migrations
Revision: A single migration file with a unique ID; Lesson 1253 — Alembic migrations
RGB tuples: `(0.; Lesson 1092 — Customizing styles
Rich ecosystem: Libraries like NumPy, pandas, scikit-learn, TensorFlow, and PyTorch; Lesson 1128 — What is machine learning
Rich information: Each match object has `.; Lesson 838 — `re.finditer`
right: .; Lesson 27 — Assignment with `=`Lesson 134 — `.lstrip()` / `.rstrip()`Lesson 141 — `.rsplit()`Lesson 165 — `.ljust(n)`Lesson 166 — `.rjust(n)`Lesson 167 — `.center(n)`Lesson 207 — `>` greater than Lesson 1076 — Join types
Right join: Keep *all* rows from the right DataFrame; fill with `NaN` where the left has no match.; Lesson 1076 — Join types Lesson 1246 — JOINs
right side: of the string instead.; Lesson 141 — `.rsplit()`Lesson 145 — `.rpartition(sep)`
right to left: .; Lesson 31 — Chained assignment Lesson 229 — `=` assignment
ROC: (Receiver Operating Characteristic) curves visualize performance across *all possible thresholds*.; Lesson 1155 — ROC and AUC
ROCm: For AMD GPUs (less common); Lesson 1177 — Installing PyTorch
Rollback: → all changes are discarded; Lesson 1252 — Sessions and transactions
route: a URL path like `/` or `/about` — and a function that returns what to display when someone visits that URL.; Lesson 1212 — Hello, Flask Lesson 1218 — Templates with Jinja2
Routers: automatically generate URL patterns for your API endpoints, saving you from manually writing each route.; Lesson 1243 — Django REST framework
row: to every row of a matrix, or a **column** to every column.; Lesson 1026 — Broadcasting Lesson 1042 — Creating from a list of dicts Lesson 1244 — SQL fundamentals
Row 0 (class 0): 2 correct, 0 mistakes; Lesson 1154 — Confusion matrix
Row 1 (class 1): 2 correct, 1 wrongly called class 2; Lesson 1154 — Confusion matrix
Row 2 (class 2): 1 correct, 1 wrongly called class 0; Lesson 1154 — Confusion matrix
Rows: the actual class; Lesson 1154 — Confusion matrix
run: a file directly, `__name__` equals `'__main__'`; Lesson 697 — `if __name__ == '__main__':`Lesson 915 — `asyncio.run(main())`Lesson 1266 — Running containers Lesson 1281 — Project: ML model API
Run and Debug: icon in the left sidebar (or press `Ctrl+Shift+D` / `Cmd+Shift+D`); Lesson 956 — VS Code debugger
Run directly: `python my_script.; Lesson 697 — `if __name__ == '__main__':`
Run inference: (make predictions) using the model.; Lesson 1281 — Project: ML model API
Run with `kernprof`: , the tool that comes with `line_profiler`; Lesson 976 — Line profilers
Running it: Lesson 827 — `sys.argv`
Runs the loop: until your coroutine completes; Lesson 914 — Event loop concept

S

Safe: GET doesn't modify anything on the server.; Lesson 1197 — Methods: GET/POST/PUT/DELETE
Safety: Prevents accidentally mixing up argument order; Lesson 489 — Keyword-only arguments Lesson 1250 — SQLAlchemy Core
same: .; Lesson 224 — `^` bitwise XOR Lesson 332 — `.clear()`Lesson 346 — Aliasing pitfall Lesson 485 — Mutable default argument trap
Same familiar API: If you know `requests`, you already mostly know `httpx`; Lesson 1210 — `httpx` for async HTTP
Same functionality: Your app runs identically; Lesson 1267 — Multi-stage builds
Sample output: Lesson 1120 — Sampling and the law of large numbers
Sample size matters: larger samples (n ≥ 30 is a common rule) make the normal approximation better.; Lesson 1121 — Central limit theorem
Sampling: is the act of drawing observations from a population.; Lesson 1120 — Sampling and the law of large numbers
Sampling without replacement: means grabbing several random items from a collection, but once an item is picked, it's removed from the pool.; Lesson 789 — `random.sample(pop, k)`
Scalability: As your app grows, keep it maintainable by dividing it logically; Lesson 1220 — Flask Blueprints
Scale up: As traffic grows or you need specific features (managed databases, caching, queues), AWS or GCP provide comprehensive ecosystems—at the cost of complexity.; Lesson 1274 — Cloud deployment options
Scan algorithms: (running max, min, or custom reductions); Lesson 811 — `accumulate`
Schedules your coroutine: (`main()`) onto that loop; Lesson 914 — Event loop concept
Science: Reproducibility is crucial in simulations and experiments; Lesson 790 — `random.seed()`
Scientific research: Solving complex math and physics problems; Lesson 1 — What is Python?
SciPy: provides a comprehensive toolkit for advanced statistics.; Lesson 1127 — SciPy for stats
Seaborn: makes statistical visualizations elegant.; Lesson 1106 — Plotly intro
Search for "Python": in the search box at the top; Lesson 8 — Installing VS Code for Python
Secrets: Lesson 1255 — Project structure for deploy Lesson 1260 — Secret management
Security: hides your app server's internal port and can filter bad requests.; Lesson 1273 — Reverse proxy with Nginx
Security / Ethical Hacking: Lesson 1287 — Specialization paths
Security features: Protection against common vulnerabilities (SQL injection, cross-site scripting, CSRF); Lesson 1234 — Why Django
Security Logging Failures: Not logging security events or failing to monitor logs for attacks.; Lesson 1277 — Application security basics
Security Misconfiguration: Default passwords, debug mode in production, exposed secret keys in environment variables checked into Git.; Lesson 1277 — Application security basics
See updated values: If the outer function modifies the variable, the closure sees the change; Lesson 513 — Closure cell objects
See values instantly: – What *is* that variable right now?; Lesson 950 — Print-debugging
SELECT: → Read data from tables; Lesson 1245 — SELECT, INSERT, UPDATE, DELETE
Select your preferences: Lesson 1177 — Installing PyTorch
Self-describing: Field names make data structure obvious; Lesson 1200 — JSON over HTTP
Self-documentation: Names like `Coordinates` or `UserID` convey meaning better than raw types.; Lesson 878 — `TypeAlias`
Sensitive data: like `.; Lesson 990 — `.gitignore`
Separation of concerns: Keep cross-cutting logic (logging, caching, validation) separate from core function logic.; Lesson 744 — Why decorators
sequentially: (one after another), your program spends most of its time just *waiting*: waiting for the server to respond, waiting for data to arrive over the network, waiting for the disk to write the file.; Lesson 891 — Why threads Lesson 1143 — Gradient boosting
Serialize: Python objects (like Pydantic models) into JSON; Lesson 1227 — Response models
Serializers: convert Django models to JSON (and validate incoming JSON back to models).; Lesson 1243 — Django REST framework
Series: Lesson 1046 — Column selection Lesson 1064 — `.sum()`, `.mean()`, etc.
Server capabilities: Can build full dashboard applications (advanced feature); Lesson 1108 — Bokeh intro
Server encodes: response data → JSON; Lesson 1200 — JSON over HTTP
Server processes: the data; Lesson 1200 — JSON over HTTP
Server processes the request: the server figures out what you need; Lesson 1196 — How HTTP works
Server reads: the session ID, retrieves your data, and "remembers" you; Lesson 1207 — Sessions and cookies
Server receives: JSON, decodes to its native data structures; Lesson 1200 — JSON over HTTP
Server sends: JSON back with `Content-Type: application/json` and HTTP status; Lesson 1200 — JSON over HTTP
Server sends a response: you get back data and a status message; Lesson 1196 — How HTTP works
Server-Side Request Forgery (SSRF): Allowing an attacker to make your server send requests to internal systems.; Lesson 1277 — Application security basics
Services: Each service is a container.; Lesson 1269 — Docker Compose
Session management: Maintain cookies and headers across multiple requests; Lesson 1202 — `requests` library
Session object: handles cookies automatically across multiple requests:; Lesson 1207 — Sessions and cookies
set: the nth bit (counting from the right, starting at 0), use bitwise OR with a "mask":; Lesson 228 — Bit manipulation idioms Lesson 397 — Set literal `{}`
Sets: Python uses a hash table to jump directly to where the element *should* be.; Lesson 423 — Fast membership tests
Setup and teardown hooks: for preparing and cleaning up test environments; Lesson 927 — `unittest.TestCase`
SGD: (Stochastic Gradient Descent) — the classic approach; Lesson 1182 — Optimizers in PyTorch
shadow: built-in names by creating variables with the same name (like `len = 5`).; Lesson 496 — Built-in scope Lesson 500 — Shadowing built-ins
shallow: because it only copies the top-level list structure.; Lesson 347 — Shallow copy with slice Lesson 348 — `list.copy()`
shallow copy: a new list object containing references to the same elements as the original.; Lesson 347 — Shallow copy with slice Lesson 446 — `.copy()`Lesson 854 — `copy` module
Share your work: with colleagues or the community; Lesson 1187 — Saving and loading models
Shared state: All parts of your program see the same module instance, including any variables or objects it creates.; Lesson 692 — Re-imports & caching
Short codes: `'r'`, `'b'`, `'g'`, `'k'` (black), `'c'` (cyan), `'m'` (magenta), `'y'` (yellow); Lesson 1092 — Customizing styles
short-circuiting: .; Lesson 78 — Boolean short-circuiting Lesson 211 — `and` operator Lesson 214 — Short-circuit semantics
Short, throwaway functions: passed as arguments; Lesson 507 — Lambda vs def
Shortcut for one-shot hashing: Lesson 859 — `hashlib`
Shortening long names: Lesson 688 — `import as` alias
Should we accelerate: in consistent directions?; Lesson 1174 — Optimizers
Should we adapt: the step size per weight?; Lesson 1174 — Optimizers
Show deployed projects: Live demos (a running API, a Jupyter notebook on Binder) are more impressive than code alone; Lesson 1289 — Building a portfolio
Show print statements: (`-s`):; Lesson 934 — Running pytest
Show variety: (e.; Lesson 1289 — Building a portfolio
Sign-based replacement: Lesson 1035 — `np.where`
Silently succeeds: if all tests pass (no output!; Lesson 948 — Running doctests
Simple API: Clear, readable method names that match HTTP verbs (`requests.; Lesson 1202 — `requests` library
Simple enough: to generalize to new, unseen data; Lesson 1133 — Overfitting and underfitting
Simple math: Time differences work without worrying about DST gaps; Lesson 779 — UTC vs local time
Simpler syntax: less boilerplate; Lesson 932 — Why pytest
Simulating probabilities: Lesson 785 — `random.random()`
Single column: `df['column_name']` → returns a **Series**; Lesson 1046 — Column selection
Single expressions: that fit comfortably on one line; Lesson 507 — Lambda vs def
Single inheritance: means one class (the **child** or **subclass**) extends another class (the **parent** or **superclass**), inheriting all its methods and attributes.; Lesson 635 — Single inheritance
Single linkage: minimum distance between any two points; Lesson 1164 — Hierarchical clustering
Single Page Application (SPA): loads one HTML page and dynamically updates content as the user interacts with it—no full page reloads.; Lesson 1282 — Project: small SPA-backed web app
Single-element tuples: `(5,)` — note the trailing comma!; Lesson 371 — Tuple literal `()`
Site-packages directories: (where pip installs third-party packages); Lesson 829 — `sys.path`
Size-mutable: You can add/remove columns and rows; Lesson 1040 — `pd.DataFrame` basics
Skew < 0: *left-skewed* (long tail to the left, mass on the right); Lesson 1115 — Skew and kurtosis
Skew = 0: symmetric (like a normal distribution); Lesson 1115 — Skew and kurtosis
Skew > 0: *right-skewed* (long tail to the right, mass on the left); Lesson 1115 — Skew and kurtosis
skipped: .; Lesson 278 — `while ... else`Lesson 297 — `for ... else`Lesson 940 — Marking and selecting tests
Slice: tuples: `my_tuple[1:3]` returns a new tuple; Lesson 378 — Tuples are immutable
Sliding window problems: Maintain a window of recent elements efficiently.; Lesson 793 — `deque`
Slow: Lesson 978 — Common optimizations Lesson 1085 — Parquet / Feather formats Lesson 1166 — t-SNE and UMAP
Small to medium files: where you need all lines at once; Lesson 570 — `.readlines()`
Smaller images: Often 50-70% size reduction; Lesson 1267 — Multi-stage builds
Solve real problems: or demonstrate technical depth; Lesson 1289 — Building a portfolio
Sort imports (like isort): Lesson 970 — `ruff` — the modern linter
Sorting by absolute value: Lesson 508 — Lambdas in `sorted(key=...)`
Sorting by multiple columns: Lesson 1073 — Sorting
Sorting dictionaries by values: Lesson 508 — Lambdas in `sorted(key=...)`
Sorting strings by length: Lesson 508 — Lambdas in `sorted(key=...)`
Spam filter: High precision (don't block real emails) even if some spam slips through.; Lesson 1153 — Accuracy, precision, recall, F1
Specifying the orientation: Lesson 1082 — Reading JSON
Speed: The pattern is compiled only once, not on every call; Lesson 849 — Compiling patterns Lesson 890 — `pyright` and `pylance`Lesson 970 — `ruff` — the modern linter Lesson 1002 — Why NumPy Lesson 1160 — `RandomizedSearchCV`Lesson 1165 — PCA
Splitting text: Extract domain from email addresses; Lesson 1150 — Feature engineering
SQL: (Structured Query Language) is a specialized language for managing and querying data stored in **relational databases**.; Lesson 1244 — SQL fundamentals
SQL databases: (like SQLite, PostgreSQL, MySQL, etc.; Lesson 1083 — Reading SQL
SQL query string: Any valid SQL statement—`SELECT`, `JOIN`, etc.; Lesson 1083 — Reading SQL
SSL verification: Secure connections enabled by default; Lesson 1202 — `requests` library
SSL/TLS termination: Nginx handles HTTPS certificates; your app sees plain HTTP.; Lesson 1273 — Reverse proxy with Nginx
Stability: – Prevents surprise breakage from automatic updates; Lesson 709 — Installing a specific version
Stability and performance: without file-watching overhead; Lesson 1272 — Uvicorn for ASGI
Stacks from either end: You can treat it like two stacks in one.; Lesson 793 — `deque`
Stage: changes with `git add`; Lesson 984 — `git add` / `git commit`
Staged files: ready for your next commit; Lesson 983 — `git status` / `git diff`
Standard deviation (σ): How spread out the data is.; Lesson 1118 — Normal distribution
standard error: (stderr).; Lesson 243 — Printing to stderr Lesson 1121 — Central limit theorem Lesson 1126 — Confidence intervals
standard library: , a vast collection of pre-written modules that handle everything from file operations to date manipulation, from regular expressions to HTTP requests.; Lesson 690 — Standard library imports Lesson 969 — Import sorting with isort
Standard library directories: (where built-in modules live); Lesson 829 — `sys.path`
Standard workflows: You want the official, widely-documented Python tooling; Lesson 719 — pip vs conda
Star unpacking: lets you use `*` before a variable name to collect all the "extra" values into a list:; Lesson 376 — Star unpacking
Start: must be *larger* than **stop**; Lesson 288 — Reverse iteration with range Lesson 836 — `re.search` vs `re.match`
Start simple: Begin with a weak initial prediction (often just the mean target value); Lesson 1143 — Gradient boosting Lesson 1274 — Cloud deployment options
State: (data/attributes) — what the object *knows*; Lesson 605 — Why OOP
State management: Track app state (tasks list, user auth) in frontend; Lesson 1282 — Project: small SPA-backed web app
State-of-the-art performance: Built by top researchers; Lesson 1192 — Pretrained models with Hugging Face
Statelessness: Lesson 1201 — REST principles
Statement: "Make me a coffee" — This *does* something.; Lesson 13 — Statements and expressions Lesson 510 — Lambda limitations
Statements: are instructions that *do* something or *make something happen*.; Lesson 13 — Statements and expressions
Static analysis tools: like `mypy` that read your code without running it; Lesson 870 — Hints don't enforce
Static analyzers: like `mypy` can catch `greet(123)` *before you run the code*; Lesson 867 — Why type hints
static method: is a plain function that lives inside a class namespace but doesn't receive `self` (the instance) or `cls` (the class) automatically.; Lesson 627 — Static methods Lesson 628 — When to use each
Statistical focus: Functions like distribution plots, violin plots, box plots, and regression plots are built-in and require minimal code.; Lesson 1099 — Why seaborn
Statistical models: that require one observation per row; Lesson 1070 — `.melt()`
status code: a three-digit number telling you what happened:; Lesson 1196 — How HTTP works Lesson 1198 — Status codes
step: (also called a **stride**) as a third value: `[start:stop:step]`.; Lesson 123 — Slice with step `[a:b:c]`Lesson 287 — `range(start, stop, step)`Lesson 288 — Reverse iteration with range Lesson 319 — Slice with step
Step Into: Dive into a function call; Lesson 957 — PyCharm debugger basics
Step of -2: Lesson 287 — `range(start, stop, step)`
Step Out: Finish the current function and return; Lesson 957 — PyCharm debugger basics
Step Over: Execute the current line, move to the next; Lesson 957 — PyCharm debugger basics
Step-by-step: Lesson 816 — `reduce`
Stmts: Total statements; Lesson 942 — Coverage with `pytest-cov`
Stop after first failure: (`-x`):; Lesson 934 — Running pytest
Stop when fast enough: perfection is the enemy of good; Lesson 979 — When to optimize
Stopping early: if selectors runs out:; Lesson 810 — `compress`
Streaming training data: means loading small batches of examples *on-the-fly*, processing them during training, then discarding them to make room for the next batch.; Lesson 1185 — DataLoader and Dataset
string: is a piece of text—like a word, sentence, or any sequence of characters.; Lesson 97 — Single-quote strings Lesson 246 — Casting input to int Lesson 595 — `json.dumps`Lesson 776 — `strptime` parsing Lesson 839 — `re.sub`
String to numeric: When numbers are loaded as text; Lesson 1060 — Changing dtypes
strings: , not integers.; Lesson 57 — `bin()`, `oct()`, `hex()`Lesson 190 — Encoding strings to bytes Lesson 827 — `sys.argv`
Strongly Typed: Lesson 1223 — Why FastAPI
structural typing: (also called "static duck typing").; Lesson 651 — Protocols (typing)Lesson 882 — Protocols
Structured logging: means emitting logs as JSON objects with consistent field names.; Lesson 965 — Structured logging
Stubbing during development: – Create the class structure first, fill in details later; Lesson 607 — Empty class with `pass`
subclass: that inherits attributes and methods from a **parent class** using Python's single-inheritance syntax.; Lesson 635 — Single inheritance Lesson 887 — `Self` type
Subject to change: You might rename or remove it later without warning; Lesson 41 — Leading underscore convention
Subplots: let you arrange multiple plots (called "axes" in matplotlib) in rows and columns within one figure —like dividing a canvas into panels.; Lesson 1090 — Subplots
Subsequent requests: Your browser automatically includes that cookie in the headers; Lesson 1207 — Sessions and cookies
subtract: with `-`, Python removes counts:; Lesson 468 — `Counter` arithmetic Lesson 773 — `timedelta`
Subtraction (`-`): Finds the difference between integers; Lesson 49 — Integer arithmetic
Success rate: percentage of non-error responses; Lesson 1276 — Monitoring and metrics
Sum everything: Add all weighted inputs together, plus a **bias** term: `z = w₁×x₁ + w₂×x₂ + w₃×x₃ + b`; Lesson 1168 — Perceptrons and neurons
Support `nonlocal`: The inner function can modify the shared variable using the `nonlocal` keyword; Lesson 513 — Closure cell objects
Supports groups: Access capturing groups via `.; Lesson 838 — `re.finditer`
SVG: – Vector format, scalable without quality loss, ideal for editing later:; Lesson 1096 — Saving figures
Swagger UI: at `/docs`; Lesson 1228 — Automatic OpenAPI docs
Syntax: Lesson 137 — `.replace(old, new, n)`Lesson 165 — `.ljust(n)`Lesson 238 — `sep` argument Lesson 394 — `._replace()` on namedtuples Lesson 813 — `zip_longest`Lesson 925 — `run_in_executor`
SyntaxError: happens when Python reads your code and finds something that breaks the language rules—like a typo, missing colon, or incorrect indentation.; Lesson 23 — SyntaxError vs runtime error Lesson 116 — Raw string limitations
System monitor: Check disk space, send an alert if it's low; Lesson 1284 — Project: automation script

T

Tabs vs spaces: PEP 8 says use spaces (and never mix them); Lesson 25 — Intro to PEP 8
Talk Python To Me: (hosted by Michael Kennedy) features deep-dive interviews with library authors, framework creators, and community leaders.; Lesson 1288 — Staying current
Target: (also called *labels*, *output*, or *y*): The answer you're trying to *predict*; Lesson 1131 — Features and targets
Target A: All arrows land within 1 inch of the bullseye (low variance).; Lesson 1112 — Variance and std dev
Target B: Arrows land anywhere within 10 inches (high variance).; Lesson 1112 — Variance and std dev
Team collaboration: Different developers can own different apps; Lesson 1236 — Apps within a project
Template engine: Generate HTML dynamically; Lesson 1234 — Why Django
Template generates HTML: Placeholders get replaced with actual values; Lesson 1238 — Views and templates
templates: you're describing the exact shape you expect, with slots that can either demand a specific value or capture whatever's there.; Lesson 269 — Sequence patterns Lesson 1218 — Templates with Jinja2 Lesson 1238 — Views and templates
TensorFlow: is Google's deep learning framework, originally released in 2015.; Lesson 1195 — TensorFlow / Keras preview
Test discovery: is unittest's ability to automatically find and execute all test files in your project.; Lesson 931 — Test discovery
Test files: typically start with `test_` (e.; Lesson 992 — `tests/` directory
Test functions: inside those files also start with `test_` (e.; Lesson 992 — `tests/` directory
Test manually first: Run it a few times before scheduling; Lesson 1284 — Project: automation script
Test PyPI: first:; Lesson 998 — `twine` for publishing Lesson 999 — Test PyPI
Test set: (~10-20%): Data held completely separate until the very end.; Lesson 1132 — Training, validation, test
Test with invalid keys: Make sure your error-handling works when auth fails (typically a 401 or 403 status code).; Lesson 1206 — Headers and auth
Test with small numbers: before scaling up; Lesson 280 — Avoiding infinite loops
Testability: Swap out dependencies in tests (e.; Lesson 1230 — Dependency injection
Testable: Run migrations on a staging database first.; Lesson 1240 — Migrations
Testing: Smaller methods are easier to verify individually.; Lesson 623 — Helper methods Lesson 709 — Installing a specific version Lesson 790 — `random.seed()`Lesson 1278 — Project: CLI tool
Testing approaches: how fixtures are structured, what gets mocked, how edge cases are covered.; Lesson 1285 — Reading other people's code
Text handling: Python 3 properly distinguishes between text (words, sentences) and raw data (bytes), preventing common errors; Lesson 3 — Python 2 vs Python 3
Text mode (`'r'`): – Python treats the file as containing text (strings).; Lesson 558 — Text vs binary mode
That's it: No imports, no classes, no special methods.; Lesson 932 — Why pytest
Think of it like: Teaching a child to identify animals by showing them pictures labeled "cat," "dog," "bird.; Lesson 1129 — Supervised vs unsupervised
Third-party: library imports (packages you installed with pip); Lesson 969 — Import sorting with isort
Third-party extensions: Allow external libraries to add modules to your package namespace.; Lesson 705 — Namespace packages
Third-party libraries: using it as a generic error; Lesson 555 — `RuntimeError`
Thread object: pointing to that function; Lesson 892 — `threading.Thread`
Thread safety: immutable objects are inherently safer in concurrent code; Lesson 671 — Frozen dataclasses
Threads: allow you to start multiple tasks that can run *concurrently*.; Lesson 891 — Why threads
three nested functions: Lesson 519 — Decorators with arguments Lesson 751 — Decorators with arguments
Throughput: requests per second (RPS); Lesson 1276 — Monitoring and metrics
Timeout handling: Prevent your program from hanging on slow servers; Lesson 1202 — `requests` library
Timing is unpredictable: – You don't know exactly *when* it will run; Lesson 665 — `__del__`
title: or **author** (the content), while `.; Lesson 1073 — Sorting Lesson 1091 — Labels, titles, legends
Too large: You *jump wildly* past the optimal setting, overshooting the minimum repeatedly.; Lesson 1175 — Learning rate
Too loose: (high bias): The string won't produce the right note — it's *underfitting* the musical pattern; Lesson 1133 — Overfitting and underfitting
Too small: You move *millimeters* at a time.; Lesson 1175 — Learning rate
Too tight: (high variance): The string breaks — it's *overfitting* by being too rigid and sensitive; Lesson 1133 — Overfitting and underfitting
Tool-specific settings: Lesson 993 — `pyproject.toml`
traceback: a detailed error report that shows exactly what happened and where.; Lesson 22 — Reading error tracebacks Lesson 527 — Reading a traceback
Track progress: through a calculation (partial sums, cumulative interest); Lesson 811 — `accumulate`
Tracking Changes: Lesson 980 — Why version control
Traditional: `Union[int, str]` (requires `from typing import Union`); Lesson 872 — Union types
Traditional programming: Lesson 1128 — What is machine learning
Traditional syntax: Lesson 872 — Union types
Train and save: your model using `pickle` or `joblib`.; Lesson 1281 — Project: ML model API
Training score: how well the model performs on the data it was trained on; Lesson 1161 — Learning curves
Training set: (~60-80%): The data your model learns from.; Lesson 1132 — Training, validation, test
Transform (keeps all items): `[x if condition else y for x in lst]`; Lesson 358 — Conditional expression in comprehension
Transforming strings: Lesson 354 — Building a new list in a loop
Transposition: flips an array along its diagonal — rows become columns, and columns become rows.; Lesson 1020 — `transpose` and `.T`
Travis CI: , **Jenkins**; Lesson 1275 — CI/CD basics
triple quotes: either `'''` or `"""`.; Lesson 99 — Triple-quoted strings Lesson 186 — Multi-line f-strings
true division: , which means it always returns a float—even when you divide two integers that could divide evenly.; Lesson 61 — True division `/`Lesson 91 — Implicit type coercion Lesson 197 — `/` true division
True Negative (TN): correctly predicted "No"; Lesson 1154 — Confusion matrix
True Positive (TP): correctly predicted "Yes"; Lesson 1154 — Confusion matrix
truncates: a number—meaning it chops off the decimal portion entirely and returns just the integer part.; Lesson 65 — `math.trunc`Lesson 67 — Float to int conversion Lesson 92 — Explicit conversion to int
truthy: , it returns the second value.; Lesson 74 — `and` operator Lesson 75 — `or` operator
tuple: , not a list.; Lesson 153 — `.startswith(tuple)`Lesson 371 — Tuple literal `()`Lesson 380 — Tuple indexing & slicing Lesson 390 — Tuple vs list rule of thumb Lesson 477 — Multiple return values Lesson 1004 — `np.zeros` / `np.ones`Lesson 1012 — Array shape and dim
tuple of types: as the second argument to `isinstance()`.; Lesson 87 — `isinstance` with tuples of types Lesson 533 — Catching multiple exceptions
Tuple packing: happens when you write comma-separated values without explicit parentheses, and Python automatically bundles them into a tuple.; Lesson 374 — Tuple packing
Tuple replacement: You want tuple performance but hate `data[0]`, `data[1]`.; Lesson 792 — `namedtuple` recap
tuple unpacking: Lesson 32 — Swapping variables Lesson 439 — `.items()`
Tuples: work best for:; Lesson 390 — Tuple vs list rule of thumb
two arguments: to `range()`, you can set both where to start and where to stop.; Lesson 286 — `range(start, stop)`Lesson 370 — `reduce()` from functools
Two characters combined: (decomposed): `e` (U+0065) + `´` (U+0301, a combining accent); Lesson 193 — Unicode normalization preview
Two-sided: "There *is* a difference" (could be higher *or* lower); Lesson 1122 — Hypothesis testing intro
Type checking: `isinstance(value, expected_type)`; Lesson 634 — Validation in setters
type hints: directly into the definition, making your code clearer and enabling better editor support.; Lesson 396 — `typing.NamedTuple` class syntax Lesson 1223 — Why FastAPI
Type loss: Everything is text.; Lesson 1085 — Parquet / Feather formats
Type this command: Lesson 11 — Running a .py script
Typed: stores exact dtypes; Lesson 1085 — Parquet / Feather formats Lesson 1225 — Path and query parameters
TypeError: Lesson 126 — String immutability
Typo in filename: `"dta.; Lesson 552 — `FileNotFoundError`

U

Ubiquity: Nearly every data science tutorial, research paper, and notebook uses it; Lesson 1087 — Why matplotlib
UMAP: (Uniform Manifold Approximation and Projection) are dimensionality reduction techniques designed specifically for **visualization**.; Lesson 1166 — t-SNE and UMAP
Unary `-`: (negative sign): Flips the sign of a number; Lesson 201 — Unary `+` and `-`
Unary `+`: (positive sign): Leaves the number unchanged (rarely used, but legal); Lesson 201 — Unary `+` and `-`
Unary `+` and `-`: (e.; Lesson 202 — Operator precedence
Underscores: (_); Lesson 33 — Naming rules Lesson 179 — Thousands separators
Understand code faster: see at a glance what types a function expects; Lesson 521 — Annotating parameters
Understanding distributions: seeing each variable's shape at a glance; Lesson 1104 — Pair plots
Unicode: string by default.; Lesson 105 — Strings are unicode
Uniform: every value in a range is equally likely (like rolling a fair die); Lesson 1034 — Random sampling
Union types: let you declare this possibility explicitly in your type hints.; Lesson 872 — Union types
unique: and **immutable**.; Lesson 682 — Enums Lesson 789 — `random.sample(pop, k)`
Universal: works with Spark, SQL engines, R, etc.; Lesson 1085 — Parquet / Feather formats
Unix/Linux/macOS: `\n` (line feed only); Lesson 593 — Newline handling on CSV
Unlicense: Public domain dedication.; Lesson 995 — LICENSE files
unsupervised learning: , you have **unlabeled data**—no correct answers provided.; Lesson 1129 — Supervised vs unsupervised Lesson 1167 — Anomaly detection
Unsupported operations between types: Lesson 549 — `TypeError`
Untracked files: Git doesn't know about yet (new Python scripts you created); Lesson 983 — `git status` / `git diff`
Update: You typically modify something inside the loop so it eventually stops (otherwise it runs forever!; Lesson 273 — `while` basics Lesson 560 — `'+'` read/write modes Lesson 1245 — SELECT, INSERT, UPDATE, DELETE
Update a specific package: Lesson 708 — `pip install --upgrade`
Update gate: Decides how much new information to add; Lesson 1190 — LSTMs and GRUs
Update pip itself: Lesson 708 — `pip install --upgrade`
Update predictions: Add this tree's predictions (scaled by a learning rate) to the ensemble; Lesson 1143 — Gradient boosting
Update weights: call `optimizer.; Lesson 1184 — Training loop
Upgrade/Downgrade: Moving forward or backward through versions; Lesson 1253 — Alembic migrations
Upgrading: Use `pip install --upgrade scikit-learn` to get the latest version.; Lesson 1135 — Installing scikit-learn
URL: (where you're sending the request); Lesson 1196 — How HTTP works
URL dispatcher: to map incoming web requests to the right code.; Lesson 1237 — URL routing in Django
URL prefix: to all routes in a Blueprint:; Lesson 1220 — Flask Blueprints
URL routing: Map web addresses to your Python functions; Lesson 1234 — Why Django Lesson 1238 — Views and templates
Usage: – Quick examples showing how to run your code; Lesson 994 — `README.md`
Use: Default choice for hidden layers in most modern networks; Lesson 1169 — Activation functions
Use `'a'`: when you're adding to a log file, appending new records, or building up data over time without losing history.; Lesson 576 — Truncating vs appending
Use `'w'`: when you're generating a completely new report, config file, or output—anything where old data is obsolete.; Lesson 576 — Truncating vs appending
Use `async def`: if your route calls `await` for database queries, HTTP requests, file operations, or any async library.; Lesson 1229 — Async routes
Use `def` for: Lesson 507 — Lambda vs def
Use `jsonify()`: Explicitly creates a JSON response with the correct headers; Lesson 1216 — Returning JSON
Use `lambda` for: Lesson 507 — Lambda vs def
Use `pyproject.toml`: to *declare* your project's direct dependencies and metadata.; Lesson 1256 — Pinning dependencies
Use `requirements.txt`: to *lock* exact versions for deployment, CI/CD, or reproducing a working environment.; Lesson 1256 — Pinning dependencies
Use a comprehension (brackets): when:; Lesson 741 — Comprehension vs generator
Use a generator (parentheses): when:; Lesson 741 — Comprehension vs generator
Use ASGI: for async frameworks like FastAPI, or when you need WebSockets, HTTP/2, or need to handle many concurrent I/O-bound requests efficiently.; Lesson 1270 — WSGI vs ASGI
Use regular `def`: if your route only does fast, synchronous work (e.; Lesson 1229 — Async routes
Use this first: to identify which high-level operations are slow.; Lesson 974 — Reading profile output
Use WSGI: for traditional frameworks like Flask or Django when you don't need async features.; Lesson 1270 — WSGI vs ASGI
User authentication: Login, logout, permissions, and password management; Lesson 1234 — Why Django
Users know what's safe: they won't depend on internal details you might change; Lesson 622 — Public vs private API
Using `and`: Both conditions must be `True` for the whole expression to be `True`.; Lesson 256 — Comparison with `and`/`or`
Using `or`: At least one condition must be `True` for the whole expression to be `True`.; Lesson 256 — Comparison with `and`/`or`
Using the loop variable: Lesson 281 — `for` basics
UTC (Coordinated Universal Time): is the universal reference point—no DST shifts, no regional quirks.; Lesson 779 — UTC vs local time
UTF-8: , which can represent all Unicode characters:; Lesson 190 — Encoding strings to bytes Lesson 561 — Encoding argument
UUID: (Universally Unique IDentifier) is a 128-bit number designed to be unique across space and time —even without coordination between systems.; Lesson 858 — `uuid` module
Uvicorn: – an ASGI server that runs your FastAPI application; Lesson 1222 — Installing FastAPI Lesson 1272 — Uvicorn for ASGI

V

Valid: Lesson 34 — Valid vs invalid identifiers Lesson 116 — Raw string limitations Lesson 483 — Mixing positional and keyword
Valid identifiers: follow all the rules:; Lesson 34 — Valid vs invalid identifiers
Validate: values before allowing assignment; Lesson 667 — `__setattr__` / `__delattr__`Lesson 998 — `twine` for publishing Lesson 1227 — Response models
Validates: the value matches that type; Lesson 1225 — Path and query parameters
Validation: Checking if a list is empty (`len(lst) == 0`) or has the expected number of items; Lesson 363 — `len(lst)`
Validation score: how well it performs on unseen validation data; Lesson 1161 — Learning curves
Validation set: (~10-20%): Data used to tune your model and make decisions during development.; Lesson 1132 — Training, validation, test
value: (most of the time):; Lesson 90 — `is` vs `==`Lesson 329 — `.remove(x)`
values: .; Lesson 90 — `is` vs `==`Lesson 449 — Iterating values Lesson 452 — Sorting dicts by value
Variables pane: Lesson 956 — VS Code debugger Lesson 957 — PyCharm debugger basics
variance: measures how spread out the data is from the mean.; Lesson 855 — `statistics` module Lesson 1112 — Variance and std dev Lesson 1133 — Overfitting and underfitting
Variations: Lesson 983 — `git status` / `git diff`
Vectorization: Operations apply to entire arrays at once without explicit loops; Lesson 1002 — Why NumPy
Verbose output: (`-v` or `--verbose`):; Lesson 934 — Running pytest
Verify: confirm a variable holds the kind of data you think it does; Lesson 85 — The `type()` function Lesson 587 — Relative vs absolute paths
Verify assumptions: – Is this list actually empty?; Lesson 950 — Print-debugging
Verifying an installation: "Did `pip install` actually work?; Lesson 711 — `pip list`
Version control: different training checkpoints; Lesson 1187 — Saving and loading models
VGG: (uniform design), **ResNet** (skip connections), and **Inception** (multi-scale filters) each introduced innovations that shaped modern deep learning.; Lesson 1188 — Convolutional networks (CNNs)
view: of all the (key, value) pairs in a dictionary.; Lesson 439 — `.items()`Lesson 1018 — `reshape`Lesson 1019 — `ravel` and `flatten`Lesson 1238 — Views and templates
View executes: The view fetches data (e.; Lesson 1238 — Views and templates
view object: containing all the keys in your dictionary.; Lesson 437 — `.keys()`Lesson 440 — Dict views are live
View renders template: The view passes data to a template file; Lesson 1238 — Views and templates
Views, not copies: Slicing returns a *view* on the original data when possible; Lesson 1015 — Slicing arrays
ViewSets: or **APIView** classes handle HTTP requests (GET, POST, PUT, DELETE) and return JSON responses.; Lesson 1243 — Django REST framework
Virtual environment folders: like `venv/` or `.; Lesson 990 — `.gitignore`
Virtual environments: solve this by creating isolated "bubbles" for each project—separate copies of Python and its own set of installed packages.; Lesson 714 — Virtual environments Lesson 720 — `pipx` for tools
Virtual Machines: emulate an entire computer.; Lesson 1261 — What is Docker
Visit pytorch.org: and navigate to the "Get Started" section; Lesson 1177 — Installing PyTorch
Visualization: You can't plot 50-dimensional data, but you can plot 2D or 3D.; Lesson 1165 — PCA Lesson 1166 — t-SNE and UMAP
VM: might take minutes to start and use gigabytes of disk/RAM; Lesson 1261 — What is Docker
VMs: like shipping separate houses to different locations — each house has its own foundation, walls, plumbing, and electrical system.; Lesson 1261 — What is Docker
Vulnerable and Outdated Components: Using old versions of libraries with known exploits.; Lesson 1277 — Application security basics

W

Wait for a subset: to complete; Lesson 910 — `as_completed` / `wait`
Web applications: Building websites and online services; Lesson 1 — What is Python?
Web Development: Companies like Instagram, Spotify, and YouTube use Python to build and run their websites.; Lesson 2 — Why learn Python Lesson 1287 — Specialization paths
Weights are applied: Each input is multiplied by a **weight** (importance factor): `[w₁, w₂, w₃]`; Lesson 1168 — Perceptrons and neurons
What: was changed (commit message); Lesson 986 — `git log`
What files have changed: (`git status`); Lesson 983 — `git status` / `git diff`
What happens: Lesson 588 — `csv.reader`
What it does: (one sentence); Lesson 1289 — Building a portfolio
What problems excite you: Predicting outcomes?; Lesson 1287 — Specialization paths
What type of error: occurred (`SyntaxError`); Lesson 22 — Reading error tracebacks
When: it was made (timestamp); Lesson 986 — `git log`
When to use which: Lesson 1182 — Optimizers in PyTorch
Which classes: your model struggles with (high off-diagonal counts); Lesson 1154 — Confusion matrix
Which file: had the problem (`hello.; Lesson 22 — Reading error tracebacks
Which line number: (`line 3`); Lesson 22 — Reading error tracebacks
Whitespace: Spaces around operators (`x = 1`, not `x=1`), no trailing whitespace.; Lesson 966 — PEP 8 reminders
Who: made the change (author); Lesson 986 — `git log`
why: decorators exist in Python: they let you cleanly wrap logic around many different functions without repeating yourself.; Lesson 744 — Why decorators Lesson 745 — First-class function recap Lesson 1174 — Optimizers
Why Adam is popular: Works well out-of-the-box on many problems with minimal tuning.; Lesson 1174 — Optimizers
Why does this fail: Even in raw strings, Python still uses backslashes to escape the closing quote character.; Lesson 116 — Raw string limitations
Why does this matter: It matches mathematical convention.; Lesson 200 — `**` exponentiation
Why it works: OR with 1 always produces 1; OR with 0 leaves the bit unchanged.; Lesson 228 — Bit manipulation idioms
Why this order: Docker caches each instruction as a layer.; Lesson 1264 — Writing a Python Dockerfile
Why you built it: (the problem or motivation); Lesson 1289 — Building a portfolio
width: make the output at least 10 characters wide; Lesson 176 — Format spec mini-language Lesson 1101 — `sns.boxplot` / `sns.violinplot`
Wildcard basics: Lesson 582 — `Path.glob()`
Windows: Double-click the installer file.; Lesson 4 — Installing Python Lesson 12 — Exiting the REPL Lesson 593 — Newline handling on CSV Lesson 1262 — Installing Docker Lesson 1284 — Project: automation script
With: it, you send only the 2 MB of actual source code you need.; Lesson 1268 — `.dockerignore`
With `and`: If the first lock is broken, you don't need to check the second — you already can't open the door.; Lesson 214 — Short-circuit semantics
With `end=''`: Lesson 242 — Printing without newline
With `or`: If the first lock opens, you don't need to check the second — you're already in.; Lesson 214 — Short-circuit semantics
With a number `n`: , it returns only the top `n` items:; Lesson 467 — `Counter.most_common()`
With decorators: , you write the wrapping logic *once* as a decorator, then "stamp" it onto any function with a single `@decorator_name` line.; Lesson 744 — Why decorators
Without: the tuple, you'd need:; Lesson 87 — `isinstance` with tuples of types Lesson 705 — Namespace packages
Without `end`: Lesson 242 — Printing without newline
Without arguments: , `most_common()` returns a list of *all* `(element, count)` tuples sorted from most to least frequent:; Lesson 467 — `Counter.most_common()`
Without context managers: , you have to remember cleanup manually:; Lesson 757 — Why context managers
Without decorators: , you'd have to manually wrap every function call or duplicate code inside each function body.; Lesson 744 — Why decorators
Workaround: Use module-level functions instead of lambdas, pass paths instead of file objects, or use serialization-friendly data structures.; Lesson 905 — Pickling requirements
Works with any framework: Flask, FastAPI, Django—just load it before initializing the app.; Lesson 1258 — `python-dotenv`
Works with cross-validation: Each fold refits the entire pipeline; Lesson 1151 — Pipelines
Write correct code first: clarity beats speed initially; Lesson 979 — When to optimize
Write for your audience: Tailor your portfolio if applying for data roles (emphasize ML projects) vs.; Lesson 1289 — Building a portfolio
Write mode (`'w'`): This *truncates* the file, meaning it **immediately erases all existing content** the moment you open it.; Lesson 576 — Truncating vs appending
Wrong: "There's a 98% chance the coin is biased.; Lesson 1123 — p-values explained
Wrong comparison operator: Lesson 280 — Avoiding infinite loops
Wrong path: `"files/report.; Lesson 552 — `FileNotFoundError`
WSGI: (Web Server Gateway Interface) is Python's original standard for synchronous web applications.; Lesson 1270 — WSGI vs ASGI

X

X-axis: False Positive Rate (FPR) = FP / (FP + TN); Lesson 1155 — ROC and AUC
XGBoost: (Extreme Gradient Boosting): Highly optimized, parallel processing, handles missing values, regularization built-in; Lesson 1143 — Gradient boosting

Y

Y-axis: True Positive Rate (TPR) = TP / (TP + FN) — this is just recall!; Lesson 1155 — ROC and AUC
you: (the client) did something wrong.; Lesson 1198 — Status codes Lesson 1225 — Path and query parameters
You can conditionally decorate: apply a decorator only under certain conditions by using if/else logic with manual decoration.; Lesson 746 — Manual decoration
You have freedom: you can refactor private methods without breaking anyone's code; Lesson 622 — Public vs private API
Your editor: knows `name` is a string, so it offers autocomplete for string methods; Lesson 867 — Why type hints

Z

Zero gradients: from the previous step; Lesson 1184 — Training loop
Zero-based: the first element is at index `0`; Lesson 1013 — Indexing 1D arrays
Zero-copy: reads (memory-mapped); Lesson 1085 — Parquet / Feather formats