← Back to Python

Python Glossary

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

84 terms.

A

authors
A list of tables specifying the name and email of the creators.
Lesson 535 — Defining Project Metadata in pyproject.toml

B

Booleans
These are known as Booleans (named after the mathematician George Boole).
Lesson 66 — Evaluating Boolean Truth Values
box plot
If your goal is diagnostic analysis—such as understanding why a mean is skewed or identifying inconsistent performance—the box plot is your best tool.
Lesson 979 — Comparing Categories with Bar and Box Plots
buffer
To improve performance, Python and the OS keep your data in a temporary memory area called a buffer.
Lesson 375 — Handling Partial Writes and Buffer Flushes
bug
Think of it this way: the bug is the hidden defect in your instructions, while the failure is the incorrect output or crash that happens when the computer follows those broken instructions.
Lesson 742 — Distinguishing Between Software Bugs and Failures
bytecode
It turns your human-readable code into something called bytecode.
Lesson 2 — Understanding the Python Interpreter and Bytecode Execution

C

caching
This process is called caching (or interning).
Lesson 27 — Understanding Python Integer Caching and Interning
Color
Color is excellent for partitioning categorical data, but be wary of "over-encoding"; too many distinct colors can make a chart difficult to read.
Lesson 976 — Mapping Data Variables to Visual Aesthetics
compilation
It reads your script and performs a translation process called compilation.
Lesson 2 — Understanding the Python Interpreter and Bytecode Execution
Concurrency
Concurrency is about structure; it is the ability to deal with multiple things at once by switching between them.
Lesson 855 — Distinguishing Concurrency From Parallelism
conditional expression
Python offers a shorthand called a conditional expression (often called a ternary operator).
Lesson 109 — Reducing Complexity with Conditional Expressions
constant time complexity
This is known as constant time complexity, or O(1) access.
Lesson 203 — Understanding Contiguous Memory in Python ListsLesson 244 — Optimizing Lookup Speed using Hash Tables
coroutine
However, a coroutine is a specialized generator that can also act as a "consumer." By using the .send() method instead of just next(), you can pause execution, pass a value into the generator, and let the generator resume while using that value as the result of its yield expression.
Lesson 310 — Implementing Coroutines with the Send MethodLesson 886 — Defining Coroutines with Async and Await
critical section
The code block where the modification occurs is called a critical section.
Lesson 864 — Ensuring Atomicity with Mutual Exclusion Locks
cumtime
The cumulative time spent in this function and all sub-functions.
Lesson 902 — Profiling CPU Usage with Deterministic Tools

D

data drift
Even a perfectly trained model will degrade if the real-world data it receives changes over time—a phenomenon known as data drift.
Lesson 994 — Handling Data Drift in Automated Systems
decorator
If you only need to inject a few methods or attach a behavior, the decorator is your best friend—it avoids the "magic" and complexity associated with inheritance-based metaclass configurations.
Lesson 666 — Dynamic Method Injection via Class Decorators
description
A short summary of your project's purpose.
Lesson 535 — Defining Project Metadata in pyproject.toml
descriptor
A descriptor is an object that defines how attribute access—getting, setting, or deleting—should behave by implementing one or more of the __get__, __set__, or __delete__ methods.
Lesson 478 — Applying Descriptor Protocols for Custom Logic
division
While adding or multiplying two integers will always result in an integer, division is special.
Lesson 31 — Performing Arithmetic with Mathematical Operators
docstring
While comments (starting with #) are great for explaining the "how" inside your code, a docstring is a special type of documentation used to explain the "what" and "why" of a function.
Lesson 61 — Documenting Functions with Docstrings
Duck Typing
Sometimes, you don't care what an object is, only that it "looks" and "acts" a certain way—a concept known as Duck Typing.
Lesson 650 — Defining Interfaces with Protocol Classes

E

edge cases
However, bugs frequently hide in the corners of our logic, known as edge cases.
Lesson 137 — Handling Edge Cases in Conditional Logic
Encapsulation
The tests/ directory allows you to validate your data ingestion and processing pipelines automatically. If a feature engineering function breaks, your tests will catch it before it invalidates your downstream visualizations.
Lesson 999 — Designing Scalable Python Project Directory Structures
every single time
__getattribute__(self, name): This method is the "gatekeeper." It is called every single time you try to access any attribute on an object.
Lesson 456 — Controlling Attribute Access Dynamically

F

f-strings
Python provides a much cleaner solution called f-strings (formatted string literals).
Lesson 44 — Formatting Strings with F-Strings
failure
Think of it this way: the bug is the hidden defect in your instructions, while the failure is the incorrect output or crash that happens when the computer follows those broken instructions.
Lesson 742 — Distinguishing Between Software Bugs and Failures
file descriptors
Instead, the OS maintains a table for every process that maps small, non-negative integers—called file descriptors—to open files or hardware devices.
Lesson 370 — Understanding Low-Level File Descriptors

G

garbage collection
This process is called garbage collection.
Lesson 28 — Tracking Object Lifecycles with Reference Counting
Garbage Collector
The Garbage Collector is a background process that periodically scans your program's memory.
Lesson 29 — Managing Memory with the Garbage Collector
guard clause
A guard clause is a simple check at the very beginning of a function that "guards" against invalid data.
Lesson 118 — Flattening Nested Logic with Guard Clauses
guard clauses
To make your code more maintainable, we use a technique called guard clauses.
Lesson 82 — Optimizing Conditional Structure for Readability

H

hash value
This algorithm performs a series of mathematical transformations to spit out a single, fixed-size integer called a hash value.
Lesson 213 — The Mechanics of Hash Functions
HTTP Connection Pooling
They use a technique called HTTP Connection Pooling.
Lesson 805 — Maintaining State with HTTP Session Objects

I

idempotency key
An idempotency key is a unique identifier (typically a UUID) generated by the client and sent as a custom HTTP header.
Lesson 817 — Implementing Idempotency Keys for Reliable Operations
Immutable objects
Immutable objects are "locked." Once you create them, their value can never change.
Lesson 24 — Handling Mutable and Immutable Object Types
in
Returns True if the item is found in the sequence.
Lesson 72 — Controlling Logic With Membership Operators
INNER JOIN
Returns records that have matching values in both tables. If a user has no orders, they are excluded from the results.
Lesson 834 — Joining Related Tables for Relational Data
inner loop
The outer loop is the hour hand, and the inner loop is the minute hand.
Lesson 112 — Visualizing Nested Loop Execution Flow
Instantiation
Instantiation is the process of using that blueprint to construct an actual, physical house.
Lesson 411 — Instantiating Objects from Class Blueprints
iterable
An iterable is any object (like a list or tuple) that can return an iterator.
Lesson 266 — Separating Iterables from Iterators

J

JSON
Serialization is the process of translating your Python data into a universal, text-based format called JSON (JavaScript Object Notation), which acts as a common language for software systems.
Lesson 384 — Serializing Python Objects with JSONLesson 738 — Choosing Between Text and Binary Formats

L

lag
A lag is a displacement of the data series.
Lesson 970 — Shifting and Lagging Data for Time-Dependent Features
lazy loading
It acts as a lightweight placeholder, only "waking up" the actual object the moment it is needed, a technique known as lazy loading.
Lesson 490 — Implementing the Proxy Pattern for Controlled Access
LEFT JOIN
Returns all records from the left table (users), and the matched records from the right table (orders). If there is no match, the order columns return None. This is useful for generating reports of all users, even those without activity.
Lesson 834 — Joining Related Tables for Relational Data
license
A clear declaration of the license, typically referencing a file or a standard identifier like MIT.
Lesson 535 — Defining Project Metadata in pyproject.toml
linter
A linter is a specialized tool that reads your Python files and compares them against the PEP 8 style guidelines we discussed earlier.
Lesson 65 — Automating Style Checks with Linters
list comprehension
Python provides a shorthand called a list comprehension.
Lesson 94 — Transforming Iterables with List Comprehensions
load factor
The load factor is simply the ratio of stored entries to the total size of the hash table.
Lesson 218 — Optimizing Performance with Load Factors

M

Maintainability Index
The Maintainability Index is a software metric that assigns a score between 0 and 100 to your code.
Lesson 599 — Identifying Technical Debt Through Maintainability Index
Memoization
Memoization is the strategy of "caching" these results.
Lesson 328 — Caching Results for Recursive Performance
metaclass
A metaclass is essentially the "class of a class." It defines the blueprint for how a class object is constructed.
Lesson 659 — Intercepting Class Creation with Metaclasses
Mutable objects
Mutable objects are "flexible." You can change their internal contents without creating a new object.
Lesson 24 — Handling Mutable and Immutable Object Types

N

name
The formal identifier for your package.
Lesson 535 — Defining Project Metadata in pyproject.toml
namespace
In Python, a namespace is essentially a dictionary that keeps track of all the names (variables, functions, etc.) you have defined and where they live.
Lesson 168 — Inspecting Namespaces Using Built-in Introspection Tools
ncalls
The number of times the function was called.
Lesson 902 — Profiling CPU Usage with Deterministic Tools
not in
Returns True if the item is not found in the sequence.
Lesson 72 — Controlling Logic With Membership Operators

O

operator precedence
Instead, it follows a strict set of rules called operator precedence.
Lesson 33 — Managing Operator Precedence and Parentheses
outer loop
The outer loop is the hour hand, and the inner loop is the minute hand.
Lesson 112 — Visualizing Nested Loop Execution Flow
over-allocation
To prevent this, Python uses a technique called over-allocation.
Lesson 215 — Internal Memory Allocation in Dictionaries

P

packages
In Python, these extra features are called packages (or libraries).
Lesson 5 — Installing Packages Using the Pip Package Manager
Position
Position is the most precise channel, making it ideal for the primary variables in your analysis.
Lesson 976 — Mapping Data Variables to Visual Aesthetics
Proxy
A Proxy is an object that mirrors the interface of the real object but intercepts requests to it.
Lesson 490 — Implementing the Proxy Pattern for Controlled Access
pure function
A pure function is a function that behaves like a mathematical formula: for the same input, it will always return the same output.
Lesson 155 — Defining Pure Functions and Side Effects

Q

quality gate
A quality gate is a CI/CD rule that evaluates your code against predefined thresholds.
Lesson 783 — Automating Quality Gates in CI Pipelines

R

reference count
Python keeps a running tally called a reference count.
Lesson 28 — Tracking Object Lifecycles with Reference Counting
resampling
To perform meaningful analysis, you must align these disparate timestamps into a common frequency—a process called resampling.
Lesson 968 — Resampling Frequency to Aggregate Temporal Observations

S

scatter plot
A scatter plot is our primary tool here: by placing one variable on the x-axis and another on the y-axis, we can immediately identify patterns, clusters, or outliers.
Lesson 980 — Revealing Relationships with Scatter and Regression Plots
sentinel value
A sentinel value is a specific piece of data chosen to act as a "stop sign." When the program encounters this value, it triggers a break statement to exit the loop immediately, ensuring that this specific "stop" signal isn't processed as valid data.
Lesson 125 — Implementing Sentinel Values for Loop Termination
Serialization
Serialization is the process of translating your Python data into a universal, text-based format called JSON (JavaScript Object Notation), which acts as a common language for software systems.
Lesson 384 — Serializing Python Objects with JSON
short-circuiting
It uses a technique called short-circuiting.
Lesson 68 — Implementing Short Circuit Evaluation Logic
stack trace
In production environments, you need this trail, known as a stack trace, to diagnose bugs without needing to replicate the crash on your own machine.
Lesson 404 — Capturing Stack Traces During Exception Handling
start
The index where the slice begins (inclusive).
Lesson 42 — Extracting Substrings Using Slicing Syntax
state flag
A state flag is a variable—usually set to True or False—that tracks whether a specific event has occurred.
Lesson 103 — Implementing State Flags for Control
State Table
A State Table is simply a grid where you record the values of your variables at the start and end of every iteration.
Lesson 123 — Tracing Program Execution with State Tables
static method
A static method is a function that lives inside your class namespace for organizational purposes, but it doesn't have access to the object's instance or the class itself.
Lesson 424 — Utilizing Static Methods for Utility Logic
Step
The amount to increment by each time.
Lesson 86 — Customizing Loop Intervals with Step Arguments
stop
The index where the slice ends (exclusive; the character at this position is not included).
Lesson 42 — Extracting Substrings Using Slicing Syntax
structural subtyping
This is called structural subtyping (or "duck typing" with type safety).
Lesson 201 — Using Protocols for Structural Subtyping
stub
A stub is a simple object that replaces the real implementation of a dependency.
Lesson 762 — Creating Simple Stubs for Predictable Inputs
Systemd
For tasks that must survive reboots or require dependency management (e.g., ensuring a network connection is up), Systemd is superior.
Lesson 1020 — Managing Scheduled Tasks with Cron and Systemd

T

test double
A test double is a generic term for any object used in place of a real dependency during testing.
Lesson 761 — Decoupling External Dependencies with Test Doubles
tottime
The total time spent in the function (excluding calls to sub-functions).
Lesson 902 — Profiling CPU Usage with Deterministic Tools

V

version
The current release stage of your project (e.g., 0.1.0).
Lesson 535 — Defining Project Metadata in pyproject.toml