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