Python is a high-level, interpreted programming language created by Guido van Rossum in 1991, emphasizing code readability through significant whitespace and a philosophy of "there should be one obvious way to do it." It's widely used across web development, data science, automation, machine learning, and systems programming, powered by a vast ecosystem of packages and an active global community. Python 3.14 (released October 2025) introduced deferred annotation evaluation, t-strings, and officially supported free-threading — marking one of the most significant runtime shifts in Python's history. The key to mastering Python isn't just knowing syntax — it's understanding when to use list comprehensions over loops, how duck typing works, and why context managers matter for resource safety.
26 tables, 362 concepts. Select a concept node to jump to its table row.
Table 1: Data Types
Python's built-in types are the foundation every program builds on. Knowing which are mutable, which are hashable, and how each behaves in memory keeps you out of the most common Python traps — like assuming bool is not an int, or that two distinct lists with equal contents are the same object.
| Type | Example | Description | |
|---|---|---|---|
x = 42 | Arbitrary-precision integers — no overflow limit unlike most languages. | ||
y = 3.14 | • Double-precision floating-point (64-bit IEEE 754) • beware rounding errors with exact comparisons. | ||
s = "hello" | • Immutable sequence of Unicode characters • supports f-strings, slicing, and a rich method surface. | ||
flag = True | • Subclass of int — True is 1 and False is 0• this surprises most newcomers | ||
arr = [1, 2, 3] | Mutable ordered sequence — the most versatile and commonly used collection type. | ||
d = {"key": "val"} | • Mutable mapping of unique keys to values • insertion-ordered since Python 3.7. | ||
t = (1, 2, 3) | • Immutable ordered sequence • hashable when elements are hashable — usable as dict keys. | ||
s = {1, 2, 3} | • Mutable unordered collection of unique hashable elements • O(1) membership test. | ||
fs = frozenset([1, 2]) | • Immutable version of set• hashable — can be a dict key or set element. | ||
x = None | • Singleton representing absence of value • distinct from empty collections or zero | ||
b = b"data" | • Immutable sequence of byte values (0–255) • for binary data and network protocols | ||
ba = bytearray(b"x") | Mutable version of bytes — for in-place modification of binary data. | ||
r = range(10) | Immutable sequence representing an arithmetic progression — memory-efficient for iteration. | ||
z = 1 + 2j | • Numbers with real and imaginary parts • j suffix denotes the imaginary unit |
Table 2: Operators
Every Python operator looks familiar from other languages, but most carry one or two Python-specific subtleties — true vs floor division, modulo whose sign follows the divisor, right-associative **, short-circuit and/or that return operands instead of booleans. The newer additions (:= walrus, | for dicts) reflect Python's continuing language design.
| Operator | Example | Description | |
|---|---|---|---|
x + y, x - y, x * y | Addition, subtraction, multiplication — work on numbers and some sequences (like str, list). | ||
x / y | Always returns float even for integer operands — true division since Python 3. | ||
x // y | • Rounds down to nearest integer • result type follows operands ( int//int → int). | ||
x % y | Remainder — sign matches divisor, unlike C/Java where it matches the dividend. | ||
x ** y | • Raises x to power y• right-associative and supports fractional/negative exponents | ||
x == y, x < y, x >= y | Equality and ordering — chainable like 1 < x < 10 (evaluates each pair once). | ||
x is y | Tests if objects are the same instance in memory — not value equality. | ||
x in y | • Checks if x exists in container y• O(1) for sets and dicts | ||
x and y | Returns first falsy value or last value if all truthy — short-circuits. | ||
x or y | Returns first truthy value or last value if all falsy — short-circuits. | ||
not x | Boolean negation — returns True if x is falsy. | ||
x & y | • Bitwise AND of integers • also set intersection for sets | ||
x | y | • Bitwise OR of integers • also set union for sets | ||
x ^ y | • Bitwise exclusive OR • also symmetric difference for sets | ||
~x | • One's complement — inverts all bits • result is -(x+1). | ||
x << n | • Shifts bits left by n• equivalent to multiplying by 2**n. | ||
x >> n | • Shifts bits right by n• equivalent to floor-dividing by 2**n. | ||
(x := 5) | Assigns and returns value in a single expression — useful in while and comprehensions (3.8+). | ||
d1 | d2 | • Merges two dicts into a new dict • |• = updates in-place (Python 3.9+). |
Table 3: String Operations
Strings are immutable Unicode sequences with a rich method surface for searching, splitting, joining, and formatting. Modern code reaches for f-strings for interpolation, str.join for performant concatenation, and the removeprefix/removesuffix pair for safe edge trimming — and always passes encoding="utf-8" to open() to avoid locale-dependent surprises.
| Method | Example | Description | |
|---|---|---|---|
f"{x} + {y} = {x+y}" | • Fastest and most readable formatting • supports expressions, format specs, and nested quotes since 3.12. | ||
"{} {}".format(a, b) | String formatting with positional/keyword arguments — more verbose than f-strings. | ||
s.split(",") | • Splits into list by delimiter • default splits on any whitespace and removes empty strings | ||
",".join(items) | Concatenates an iterable into a single string — preferred over += in loops for performance. | ||
s.strip() | • Removes leading and trailing whitespace • lstrip()/rstrip() for one side only | ||
s.removeprefix("pre") | • Removes exact prefix or suffix if present • returns unchanged string otherwise (Python 3.9+). | ||
s.replace("old", "new") | • Returns copy with all occurrences replaced • optional count parameter to limit replacements | ||
s.upper() | • Case conversion • casefold() for aggressive case-insensitive comparisons across locales | ||
s.startswith("pre") | Checks prefix/suffix — accepts a tuple of multiple options. | ||
s.find("sub") | • Finds substring position • find() returns -1 if not found, index() raises ValueError. | ||
s.count("x") | Returns the number of non-overlapping occurrences of a substring. | ||
s.partition(":") | • Splits into 3-tuple (before, sep, after)• always returns 3 parts even if separator not found | ||
s.isdigit() | • Character-type checks • many variants: isalnum(), isspace(), islower(), isupper(). | ||
s.encode("utf-8") | • Converts str → bytes via encoding • bytes.decode("utf-8") reverses it | ||
s.center(20, "*") | • Pads string to a given width with fill character • useful for formatting output | ||
"42".zfill(5) | Pads with leading zeros to specified width — "00042". | ||
s.title() | • title() capitalizes each word• capitalize() only the first character of the whole string | ||
s.translate(str.maketrans("abc","ABC")) | Replaces characters per a mapping table — efficient for multi-character substitution. | ||
t"Hello {name}" | Template strings producing a Template object for custom processing and safe interpolation (Python 3.14+). | ||
"%s %d" % (s, n) | C-style formatting — replaced by f-strings but still seen in legacy code. |
Table 4: Slicing and Indexing
Slice syntax [start:stop:step] is the unified way to index Python sequences — zero-based, half-open, and quietly forgiving of out-of-range indices. The same three components handle reversal ([::-1]), shallow copies ([:]), every-other-element selection ([::2]), and reverse walks, making slicing one of the highest-leverage pieces of syntax to master.
| Pattern | Example | Description | |
|---|---|---|---|
s[0], s[2] | Zero-based indexing from start — first element is [0]. | ||
s[-1], s[-2] | Indexes from end — -1 is last element, -2 is second-to-last. | ||
s[1:4] | Elements from index 1 up to (but not including) 4 — half-open interval. | ||
s[:3] | From beginning to index 3 — equivalent to s[0:3]. | ||
s[2:] | From index 2 to end — includes the last element. | ||
s[:] | Creates a shallow copy of the entire sequence. | ||
s[::2] | Every 2nd element — third parameter is step size. | ||
s[::-1] | Reverses sequence — negative step iterates backward. | ||
s[4:1:-1] | From index 4 down to (but not including) 1. |
Table 5: Control Flow
Python's control-flow keywords stay deliberately small: if/elif/else driven by truthiness, two loop forms with the unusual else clause, and (since 3.10) structural match with rich pattern types. The match statement goes far beyond a switch — it destructures sequences, mappings, class instances, and supports OR patterns, guards, and wildcard captures in one readable block.
| Statement | Example | Description | |
|---|---|---|---|
if x > 0: print("pos") | Conditional execution — tests truthiness of expression. | ||
elif x == 0: print("zero") | Chain multiple conditions — only the first true branch executes. | ||
else: print("neg") | Executes when all preceding conditions are false. | ||
x if cond else y | Inline conditional — returns x if cond is true, else y. | ||
for i in range(5): print(i) | Iterates over any iterable object — most common loop type. | ||
while x > 0: x -= 1 | • Repeats while condition is truthy • check happens before each iteration | ||
break | Exits innermost enclosing loop immediately. | ||
continue | Skips to the next iteration of the innermost loop. | ||
for i in items: passelse: print("done") | Executes if loop completes without break — useful for search patterns. | ||
pass | Null operation — syntactic placeholder where a statement is required. | ||
match x: case 1: print("one") | Structural pattern matching — compares against literal values (Python 3.10+). | ||
case 1 | 2 | 3: | • Matches multiple values in one case arm using |• (Python 3.10+). | ||
case Point(x=x, y=y): | Destructures class instances by attribute names into local variables (Python 3.10+). | ||
case [first, *rest]: | Matches and unpacks sequences — *rest captures remaining items (Python 3.10+). | ||
case {"action": a}: | Matches dicts by key presence — **rest captures remaining keys (Python 3.10+). | ||
case x if x > 0: | Adds a condition to any pattern — branch only executes if guard is true (Python 3.10+). | ||
case _: | Catch-all pattern that matches anything — like default in other languages (Python 3.10+). |
Table 6: Functions
Functions are first-class values in Python — they can be passed, returned, default-parameterized, decorated, and unpacked from iterables. Two non-obvious facts dominate the rough edges: default arguments are evaluated once at definition time (the source of the mutable-default trap), and the / and * separators in signatures enforce positional-only and keyword-only calling conventions explicitly.
| Technique | Example | Description | |
|---|---|---|---|
def func(a, b): return a + b | • Creates a reusable code block • return without value returns None. | ||
def f(x, y=10): | • Parameters with default values — must come after required params • evaluated once at definition. | ||
f(x=1, y=2) | Named parameters — allows any order at call site and improves call-site clarity. | ||
def f(a, b, /, c): | Parameters before / cannot be passed by keyword — enforces positional calling (Python 3.8+). | ||
def f(a, *, b): | Parameters after bare * must be passed by keyword — prevents accidental positional misuse. | ||
def f(*args): | Variable positional arguments — collected as a tuple. | ||
def f(**kwargs): | Variable keyword arguments — collected as a dict. | ||
lambda x: x * 2 | Anonymous function — single expression only, no statements. | ||
"""Description.""" | First string in function body — accessible via __doc__ and used by help(). | ||
def f(x: int) -> int: | Optional annotations — not enforced at runtime but used by type checkers. | ||
f(*args, **kwargs) | Expands sequences and mappings into function arguments at call time. |
Table 7: Comprehensions and Generators
List, dict, and set comprehensions build a collection from an iterable in one expression — typically faster than the equivalent for/append loop and easier to read. Generator expressions and yield-based functions use almost the same syntax but produce lazy iterators, which is what lets Python stream gigabytes without loading them into memory.
| Technique | Example | Description | |
|---|---|---|---|
[x**2 for x in range(10)] | Creates a list from an iterable — faster and cleaner than for-loop append. | ||
[x for x in nums if x > 0] | Filters elements — condition acts as an inline filter on the iterable. | ||
[x+y for x in a for y in b] | Multiple for clauses — left-to-right nesting order (outer loop first). | ||
{k: v**2 for k, v in d.items()} | Creates a dict from an iterable — key-value pairs with unique keys (later values win). | ||
{x**2 for x in nums} | Creates a set — automatically deduplicates results. | ||
(x**2 for x in range(10)) | • Lazy evaluation — memory-efficient for large sequences • not stored in memory | ||
def gen(): yield x | Function with yield — pauses and resumes execution on each next() call. | ||
yield from iterable | Delegates to a subiterator — simplifies nested generators (Python 3.3+). |
Table 8: Classes and OOP
Python's class model favors flexibility over enforcement — no private attributes, no compile-time type checks, no formal interfaces. What you do get is a predictable MRO via C3 linearization, descriptor-driven property access, real multiple inheritance, and abc.ABC for defining enforced interfaces without metaclass boilerplate.
| Concept | Example | Description | |
|---|---|---|---|
class Dog: pass | Creates a new type — naming convention is PascalCase. | ||
def __init__(self, name): | Constructor — initializes instance when object is created. | ||
self.name = name | Per-object data — defined in __init__ or other methods via self. | ||
class Dog: species = "Canis" | Shared across all instances — defined at class level. | ||
def bark(self): | Functions bound to instance — first param is self by convention. | ||
class Puppy(Dog): | Derives from parent class — inherits attributes and methods. | ||
super().__init__(name) | Calls parent class method — handles multiple inheritance via MRO correctly. | ||
def age(self): | Getter method — accessed like an attribute but computed dynamically. | ||
def age(self, val): | Setter method — allows validation and side effects on attribute assignment. | ||
def factory(cls): | Method receives class, not instance — for alternative constructors. | ||
def util(): | Regular function in class namespace — no implicit first parameter. | ||
class C(A, B): | Inherits from multiple classes — uses C3 MRO to resolve method order. | ||
from abc import ABC, abstractmethodclass Shape(ABC): def area(self): ... | Enforces interface — subclasses cannot be instantiated until all abstract methods are implemented. | ||
def __repr__(self): | String representations — __repr__ for debugging, __str__ for users. | ||
__slots__ = ('x', 'y') | Declares fixed attributes — reduces memory and blocks __dict__ creation. | ||
def __new__(cls): | • Static method that creates the instance before __init__• needed for immutable subclasses | ||
def __init_subclass__(cls): | Hook called when a class is subclassed — lightweight alternative to metaclasses (Python 3.6+). |
Table 9: Magic Methods (Dunder Methods)
Dunder methods are how custom classes plug into Python's syntax — len(), obj[key], for x in obj, ==, +, with, even calling an instance like a function. Implementing the right small set turns a class from "useful" to "feels built-in," and the data model documents every hook the language consults.
| Method | Example | Description | |
|---|---|---|---|
def __init__(self): | Instance initialization — called when object is created. | ||
def __str__(self): | Informal string representation — used by str() and print(). | ||
def __repr__(self): | • Official string representation — should be valid Python when possible • fallback for __str__. | ||
def __len__(self): | • Returns length — called by len()• must return non-negative int. | ||
def __bool__(self): | • Truthiness check — called by bool() and in boolean contexts• falls back to __len__. | ||
def __getitem__(self, key): | Indexing operator [] — enables subscript access. | ||
def __setitem__(self, k, v): | Item assignment [k] = v — makes object a mutable container. | ||
def __delitem__(self, key): | Deletion via del obj[key] — required for full mutable container protocol. | ||
def __iter__(self): | Returns an iterator — enables for-loop support and unpacking. | ||
def __next__(self): | Gets next value — raises StopIteration when exhausted. | ||
def __contains__(self, item): | Membership test in — should return boolean. | ||
def __enter__(self): | Context manager protocol — enables with statement. | ||
def __add__(self, other): | • Addition operator + — return new object• don't modify self. | ||
def __eq__(self, other): | • Equality operator == — default compares identity• defining it disables __hash__ by default | ||
def __hash__(self): | • Makes instance hashable — required to use as dict key or set element • must be consistent with __eq__. | ||
def __lt__(self, other): | Comparison operators < and > — enables sorting. | ||
def __call__(self): | Makes instance callable like a function — enables obj() syntax. | ||
def __format__(self, spec): | Custom format spec support — called by format() and f-string {obj:spec} syntax. | ||
def __class_getitem__(cls, item): | Enables generic alias syntax MyClass[T] — supports runtime type parameterization. |
Table 10: Exception Handling
Exceptions are Python's primary error-signalling mechanism, with a four-clause structure (try/except/else/finally) and clean chaining via raise ... from .... Python 3.11's ExceptionGroup and except* give the language a way to express multiple concurrent failures — essential for asyncio.TaskGroup and structured-concurrency designs.
| Technique | Example | Description | |
|---|---|---|---|
try: risky()except ValueError: | Catches exceptions — specific types should precede general ones. | ||
except (ValueError, KeyError): | Catches multiple types in one clause — tuple of exception classes. | ||
except ValueError as e: | Captures the exception object — access message and attributes via e. | ||
else: print("success") | Runs if no exception raised in the try block — before finally. | ||
finally: cleanup() | • Always executes — even if exception raised or return encountered• for resource cleanup | ||
raise ValueError("msg") | Throws an exception — bare raise re-raises the current active exception. | ||
class MyError(Exception): | Define new exception types — inherit from Exception or a more specific subclass. | ||
raise NewError() from e | Links exceptions — preserves original cause for debugging tracebacks. | ||
raise ExceptionGroup("msg", [ValueError(), KeyError()]) | Groups multiple exceptions together — handled with except* (Python 3.11+). | ||
except* ValueError as eg: | Catches matching exceptions from an ExceptionGroup — multiple except* clauses can match (Python 3.11+). | ||
except: | • Catches all exceptions including KeyboardInterrupt — dangerous, hides bugs• avoid |
Table 11: File Operations
File I/O uses a unified open() API parameterized by mode (r/w/a/b/+) and is best paired with with to guarantee cleanup on every exit path. Modern code increasingly leans on pathlib.Path for path manipulation and one-call read_text/write_text shortcuts — and remembers to pass encoding="utf-8" to dodge locale-dependent surprises across operating systems.
| Technique | Example | Description | |
|---|---|---|---|
with open("f.txt") as f: | Context manager — auto-closes file even if an exception occurs. | ||
for line in f: | Memory-efficient line iteration — preferred over readlines() for large files. | ||
content = f.read() | Reads entire file as string — memory-intensive for large files. | ||
line = f.readline() | Reads a single line — includes newline character. | ||
lines = f.readlines() | Returns list of all lines — newlines preserved in each element. | ||
f.write("text") | Writes string to file — doesn't add newline automatically. | ||
f.writelines(lines) | Writes a sequence of strings — no newlines added automatically. | ||
open("f.txt", "r") | Read mode — raises FileNotFoundError if file does not exist. | ||
open("f.txt", "w") | Write mode — truncates existing file or creates new. | ||
open("f.txt", "a") | • Append mode — adds to end of existing file • creates if absent | ||
open("f.bin", "rb") | • Binary mode — for non-text files • returns bytes objects | ||
open("f.txt", "x") | Exclusive creation — raises FileExistsError if file already exists. | ||
Path("f.txt").read_text(encoding="utf-8") | • Object-oriented path API — cleaner than os.path• copy()/move() added in 3.14. | ||
f = open("f.txt", encoding="utf-8") | Always specify encoding="utf-8" to avoid locale-dependent surprises on Windows. |
Table 12: Modules and Imports
Python's import system stitches code into namespaces using sys.path (search list), sys.modules (cache), and a finder/loader stack you can extend. Idiomatic code prefers explicit import over from X import *, uses relative imports inside packages, and guards script-only code behind if __name__ == "__main__": so the same file works as both a library and a script.
| Technique | Example | Description | |
|---|---|---|---|
import math | Imports entire module — access via math.func(). | ||
from math import sqrt | Imports specific names — directly accessible without module prefix. | ||
import numpy as np | Aliases module to a shorter name for convenience. | ||
if __name__ == "__main__": | Checks if script is run directly vs imported — guards executable code. | ||
from . import sibling | Within packages — dot notation for current/parent package. | ||
pkg/__init__.py | Makes directory a package — can initialize the package and control public API. | ||
sys.path.append(dir) | Module search paths — modify to add custom locations. | ||
importlib.import_module(name) | Dynamic imports — import by string name at runtime. | ||
from math import * | • Imports all public names — discouraged • pollutes namespace and hides origins |
Table 13: Common Built-in Functions
The built-ins show up in nearly every Python program — len, range, enumerate, zip, map, filter, sum, sorted, min/max, all/any, isinstance. Mastering their key= arguments, lazy-iterator returns, and edge cases (vacuous all([]), zip truncation, input always returning str) keeps day-to-day code short and correct.
| Function | Example | Description | |
|---|---|---|---|
len([1, 2, 3]) | Returns length of sequence or collection — calls __len__. | ||
range(start, stop, step) | Generates arithmetic sequence — stop is exclusive. | ||
enumerate(items, start=0) | Adds counter to iterable — returns (index, value) pairs. | ||
zip(list1, list2) | • Pairs elements from iterables — stops at shortest input • strict=True raises if lengths differ (3.10+). | ||
map(func, iterable) | Applies function to each element — returns lazy iterator. | ||
filter(predicate, items) | Filters elements where predicate is truthy — lazy iterator. | ||
sorted(items, key=func) | • Returns new sorted list — doesn't modify original • reverse=True for descending | ||
sum(numbers, start=0) | Sums a numeric iterable — optional starting value. | ||
min(items, key=func) | Returns smallest/largest element — optional key function. | ||
all([True, True, False]) | Returns True if all elements truthy or iterable is empty (vacuously true). | ||
any([False, False, True]) | Returns True if any element truthy. | ||
reversed(seq) | Returns a reverse iterator — doesn't modify original. | ||
isinstance(obj, type) | • Checks object type — accepts tuple of types • works with inheritance | ||
type(obj) | Returns object's exact type — for checking, prefer isinstance(). | ||
getattr(obj, "name", default) | Dynamic attribute access — getattr supports a default, avoids AttributeError. | ||
vars(obj) | • vars() returns __dict__• dir() lists all attributes and methods of an object | ||
abs(-5), divmod(17, 5) | • abs() returns magnitude• divmod(a, b) returns (quotient, remainder) as a tuple | ||
hex(255) → "0xff" | Converts integers to hexadecimal/octal/binary string representations. | ||
callable(func) | Returns True if object appears callable (has __call__). | ||
hash("hello") | • Returns integer hash of a hashable object • consistent within a process | ||
id(obj) | Returns object's memory address — guaranteed unique for its lifetime. | ||
input("Enter: ") | Reads a line from stdin — always returns string. | ||
print(*values, sep=" ", end="\n") | Writes to stdout — customizable separator and line ending. |
Table 14: Itertools Module
itertools is Python's grab-bag of iterator-combining building blocks — composable, lazy, and implemented in C for speed. The module covers infinite generators (count, cycle), combinatorics (combinations, permutations, product), grouping by adjacent runs (groupby), windowing (pairwise, batched), and reduction (accumulate).
| Function | Example | Description | |
|---|---|---|---|
chain(it1, it2) | Concatenates iterables — flattens multiple iterables into single iterator. | ||
chain.from_iterable(nested) | Flattens one level of nesting lazily — like chain(*nested) without unpacking. | ||
islice(it, start, stop) | Slices an iterator — doesn't support negative indices. | ||
compress('ABCDEF', [1,0,1,0,1,1]) | Filters data by a boolean selector iterable — yields A, C, E, F. | ||
filterfalse(lambda x: x<5, [1,4,6,3,8]) | Yields elements where predicate is false — opposite of filter(). | ||
starmap(pow, [(2,5), (3,2)]) | Applies function with arguments unpacked from each tuple in iterable. | ||
pairwise([1, 2, 3]) | Returns overlapping pairs of consecutive elements — (1,2), (2,3) (Python 3.10+). | ||
batched(range(10), 3) | Splits iterable into fixed-size tuples — last batch may be shorter (Python 3.12+). | ||
groupby(items, key=func) | Groups consecutive elements by key — input must be sorted by same key first. | ||
accumulate(nums, func) | • Running totals or reductions — default is addition • accepts any binary function | ||
takewhile(pred, it) | Yields elements while predicate is true — stops at first false. | ||
dropwhile(pred, it) | Skips elements while predicate is true — then yields all remaining. | ||
tee(iterable, n=2) | Splits one iterator into n independent iterators — use before an iterator is consumed. | ||
zip_longest(a, b, fillvalue=None) | Like zip() but continues to the longest input, filling shorter ones with fillvalue. | ||
combinations(items, r) | All r-length combinations — order doesn't matter, no repeated elements. | ||
combinations_with_replacement('AB', 2) | All r-length combinations allowing repeated elements — yields AA, AB, BB. | ||
permutations(items, r) | All r-length permutations — order matters, no repeated elements. | ||
product(a, b) | Cartesian product — equivalent to nested for-loops. | ||
count(start=0, step=1) | Infinite counter — useful with zip() or takewhile(). | ||
cycle([1, 2, 3]) | Repeats iterable infinitely — saves copy of all elements in memory. | ||
repeat(10, times=3) | Repeats object n times — infinite if times omitted. |
Table 15: Decorators
Decorators wrap a function or class to add behavior without changing the callsite. The syntax @decorator is sugar for func = decorator(func), extending naturally to parameterized decorators (three nesting levels) and to stacking multiple decorators (applied bottom-up). functools.wraps is mandatory in every wrapper to preserve the original's metadata.
| Technique | Example | Description | |
|---|---|---|---|
def func(): | Wraps function to modify behavior — sugar for func = decorator(func). | ||
def deco(f): def wrap(): return f() return wrap | Returns a wrapper function that replaces the original. | ||
def wrapper(): | Preserves function metadata ( __name__, __doc__, __wrapped__) — use inside every wrapper. | ||
def func(): | Returns a decorator — three-level nesting: deco(arg)(func). | ||
def f(): | Multiple decorators applied bottom-up: deco1(deco2(f)). | ||
class MyClass: | Modifies or replaces a class — callable receives and returns the class. | ||
| Memoizes function results with LRU eviction — cache_info() reports hits and misses. | ||
| Unbounded memoization — faster than lru_cache(None) as no eviction overhead (Python 3.9+). | ||
def value(self): | Computes property once per instance and caches as a normal attribute — delete attribute to reset (Python 3.8+). | ||
class C: | Generates all comparison methods from just __eq__ and one ordering method (__lt__, __le__, __gt__, or __ge__). | ||
def method(): | Built-in decorators: @classmethod, @staticmethod, @property. |
Table 16: Context Managers
Context managers — driven by __enter__/__exit__ (or __aenter__/__aexit__ for async) — guarantee deterministic resource cleanup even if the block raises. The contextlib module makes new managers trivial via the @contextmanager generator decorator and packages handy ones like suppress, closing, and the dynamic-composition ExitStack.
| Technique | Example | Description | |
|---|---|---|---|
with open("f") as f: | Ensures resource cleanup — calls __enter__ and __exit__. | ||
with open("a") as f1, open("b") as f2: | Manages multiple resources — left-to-right acquisition, right-to-left release. | ||
def ctx(): yield | Creates a context manager from a generator — yield separates setup from teardown. | ||
def __enter__(self): return self | Full protocol implementation — __exit__ receives (exc_type, exc_val, exc_tb). | ||
with suppress(FileNotFoundError): | Ignores specified exceptions — cleaner than try: ... except: pass. | ||
with closing(obj): | Calls close() on exit — for objects without a native context manager. | ||
with ExitStack() as stack: | Manages a variable number of context managers dynamically. |
Table 17: Async/Await (Asyncio)
asyncio delivers cooperative single-threaded concurrency: many waiting coroutines, one running at a time, no blocking. await is the only yield point — every awaited call must be non-blocking — and Python 3.11+ adds structured concurrency via TaskGroup plus deadline-based timeout(). The synchronization primitives (Lock, Event, Semaphore, Queue) mirror the threading module but are awaitable, not blocking.
| Technique | Example | Description | |
|---|---|---|---|
async def fetch(): | Defines a coroutine function — must be awaited or scheduled as a task. | ||
result = await coro() | Suspends coroutine — yields control to event loop until result is ready. | ||
asyncio.run(main()) | • Entry point — creates event loop and runs coroutine • closes loop on completion | ||
task = create_task(coro()) | Schedules coroutine to run concurrently with other tasks. | ||
async with TaskGroup() as tg: tg.create_task(coro()) | Structured concurrency — auto-cancels remaining tasks on failure (Python 3.11+). | ||
await gather(coro1(), coro2()) | Runs multiple coroutines concurrently — waits for all to complete. | ||
async with asyncio.timeout(5): | Context manager with deadline — raises TimeoutError if exceeded (Python 3.11+). | ||
await wait_for(coro(), timeout=5) | Adds timeout to a coroutine — raises TimeoutError if exceeded. | ||
async with asyncio.Lock(): | Mutex lock for async tasks — prevents concurrent access to shared state. | ||
event = asyncio.Event()await event.wait() | Notifies multiple tasks that something happened — set(), clear(), wait(). | ||
async with asyncio.Semaphore(10): | Limits number of concurrent coroutines accessing a resource. | ||
q = asyncio.Queue()await q.put(x)x = await q.get() | FIFO queue for producer-consumer patterns — task_done() + join() for completion tracking. | ||
await asyncio.sleep(1) | Non-blocking sleep — yields control to other coroutines. | ||
async for item in async_iter: | Iterates over an async iterable — calls __aiter__ and __anext__. | ||
async with resource: | Async context manager — awaits __aenter__ and __aexit__. |
Table 18: Type Hints
Type hints are runtime metadata that static checkers (mypy, pyright, pyre) consume to find bugs before they ship. PEP 585 (Python 3.9) made built-in generics work directly (list[int]), PEP 604 (3.10) introduced int | None unions, PEP 695 (3.12) added inline generic-parameter syntax, and PEP 649/749 (3.14) introduced deferred evaluation — annotations are no longer evaluated at import time, dramatically improving startup performance.
| Technique | Example | Description | |
|---|---|---|---|
x: int = 5 | Annotates variable type — not enforced at runtime. | ||
def f(x: int) -> str: | Parameter and return types — used by type checkers like mypy and pyright. | ||
items: list[int]d: dict[str, int] | Use built-in types directly as generics — no List/Dict imports needed (Python 3.9+). | ||
x: int | str | • Multiple allowed types — modern |• syntax replaces Union[int, str] (Python 3.10+). | ||
x: Optional[int] = None | • Shorthand for Union[T, None] — prefer T |• None in new code | ||
class Config(TypedDict): host: str port: int | Typed dict with specific key/value types — enables type checking on dict literals. | ||
f: Callable[[int], str] | Function type — list of param types then return type. | ||
class Sized(Protocol): def __len__(self): ... | Structural subtyping — duck typing with static type checking. | ||
x: Literal["a", "b"] | Restricts to specific values — useful for discriminated unions. | ||
T = TypeVar('T') | Generic type variable — for parametric polymorphism in functions and classes. | ||
def f[T](x: T) -> T: | Inline generic type variables on functions and classes — replaces TypeVar (Python 3.12+). | ||
type Vector = list[float] | Declares a type alias with lazy evaluation — replaces TypeAlias annotation (Python 3.12+). | ||
P = ParamSpec('P') | Captures the parameter types of a callable — essential for typing decorators that preserve signatures. | ||
def f(**kwargs: Unpack[Config]): | Types **kwargs using a TypedDict — enables per-key type checking (Python 3.12+). | ||
x: Any | • Disables type checking — avoid when possible • escape hatch | ||
def is_str(x) -> TypeIs[str]: | Narrows type in both if/else branches — safer than TypeGuard (Python 3.13+). | ||
def method(self): | Marks method as overriding parent — type checkers flag mismatches (Python 3.12+). | ||
def f(x: MyClass) -> None: | In Python 3.14+ annotations are not evaluated at import time — forward references work natively without quotes. |
Table 19: Regular Expressions
The re module exposes a single regex engine through both functional (re.search, re.findall, re.sub) and compiled (re.compile(...)) APIs. The biggest pitfalls are re.match vs re.search (anchored vs unanchored) and forgetting r"..." raw strings — without them, Python's own backslash processing eats half your pattern before the engine sees it.
| Function | Example | Description | |
|---|---|---|---|
re.search(r"\d+", s) | Searches anywhere in string — returns first match object or None. | ||
re.match(r"\d+", s) | Matches at start of string only — returns match object or None. | ||
re.fullmatch(r"\d+", s) | Matches entire string — both ^ and $ are implicit. | ||
re.findall(r"\d+", s) | Returns list of all matches — non-overlapping strings. | ||
re.finditer(r"\d+", s) | Returns iterator of match objects — memory-efficient for large inputs. | ||
re.sub(r"\d+", "X", s) | Replaces matches — accepts function as replacement for dynamic substitutions. | ||
re.split(r"\s+", s) | Splits by pattern — preserves groups in result if pattern has groups. | ||
p = re.compile(r"\d+") | Precompiles pattern — faster for reuse across many strings. | ||
m.group(1) | Captures subpatterns — group(0) is entire match, group(1) first capture. | ||
(?P<name>\d+) | Named capture — access via m.group('name') or m.groupdict(). | ||
r"\d+?" | ? after quantifier — matches as few characters as possible. | ||
r"\d+(?= px)" | Zero-width assertions — (?=...) lookahead, (?<=...) lookbehind — don't consume chars. | ||
re.search(r"a", s, re.I) | • Case-insensitive matching — combine flags with re.I |• re.M. | ||
re.search(r".+", s, re.S) | Makes . match newlines too — useful for multi-line text blocks. | ||
re.search(r"^word", s, re.M) | ^ and $ match start/end of each line, not just the string. | ||
r"\d+" | Prefix with r — avoids double-escaping backslashes in patterns. |
Table 20: Dataclasses and Modern Class Features
@dataclass (Python 3.7+) generates __init__, __repr__, and __eq__ from type-annotated attributes, with knobs for frozen, slots, and kw_only to fit specific use cases. For runtime validation and coercion at system boundaries, the ecosystem leans on pydantic; for richer feature sets without the validation cost, on attrs.
| Technique | Example | Description | |
|---|---|---|---|
class Point: x: float y: float | Auto-generates __init__, __repr__, __eq__ — less boilerplate (Python 3.7+). | ||
x: int = 0 | Default values — mutable defaults must use field(default_factory=...). | ||
items: list = field(default_factory=list) | Customizes field behavior — prevents shared mutable defaults across instances. | ||
| Makes instances immutable — enables hashing for use as dict keys. | ||
| Generates __slots__ for reduced memory — prevents dynamic attribute creation (Python 3.10+). | ||
| Forces keyword-only arguments in __init__ — prevents positional mistakes (Python 3.10+). | ||
def __post_init__(self): | Runs after __init__ — for computed fields or validation. | ||
temp: InitVar[int] | Init-only variable — not stored as field, available in __post_init__. | ||
asdict(obj) | Converts dataclass to dict/tuple — deep-copies nested dataclasses. | ||
class C: | Third-party alternative — more features than dataclasses (validators, converters, slots by default). | ||
class User(BaseModel): | Data validation library — runtime type checking, coercion, and JSON schema generation. |
Table 21: Enum Module
The enum module provides a way to define named constant sets with distinct identity, preventing typos and magic-string comparisons. Python 3.11 added StrEnum and IntEnum auto-values that produce the lowercased member name, and Python 3.12 improved the repr of enum members and simplified subclassing.
| Type | Example | Description | |
|---|---|---|---|
class Color(Enum): RED = 1 GREEN = 2 | Base class for enumerations — members have unique identity and are accessed as Color.RED. | ||
RED = auto() | Automatically assigns values — default is sequential integers starting at 1. | ||
class Status(IntEnum): OK = 200 | Enum whose members are also int — compatible with integer APIs. | ||
class Direction(StrEnum): NORTH = auto() | Members are also str — auto() generates the lowercased member name (Python 3.11+). | ||
class Perm(Flag): READ = auto() WRITE = auto() | • Members support bitwise operations — combine with |• , test with in. | ||
class Mode(IntFlag): R = 4 W = 2 | Flag + int compatibility — members behave as integers for system calls and bitmasks. | ||
list(Color) | Enumerates all members in definition order. | ||
Color(1), Color["RED"] | Access by value ( Color(1)) or by name (Color["RED"]). | ||
Color.RED.value, Color.RED.name | Access the raw value or the member name string. |
Table 22: Collections Module
The collections module provides specialized container datatypes that extend Python's built-in dict, list, set, and tuple. deque is the go-to for O(1) queue operations, OrderedDict retains its usefulness for LRU implementations despite regular dicts being ordered since 3.7, and Counter eliminates a common tally-building loop pattern entirely.
| Type | Example | Description | |
|---|---|---|---|
from collections import dequedq = deque([1,2,3], maxlen=5) | • Double-ended queue — O(1) append and pop on both ends • list.pop(0) is O(n). | ||
dq.appendleft(0)dq.popleft() | Efficient left-side operations — core advantage over list for queue usage. | ||
deque(maxlen=10) | • Bounded deque — oldest items auto-discarded when full • perfect for sliding windows | ||
defaultdict(list) | Dict that auto-creates missing keys using a factory function. | ||
Counter("abracadabra") | Dict subclass for counting hashable objects — most_common(n) returns top-n items. | ||
c1 + c2, c1 - c2, c1 & c2 | • Supports +, -, & (intersection), |• (union) — results keep only positive counts. | ||
c.total() | Returns sum of all counts (Python 3.10+). | ||
Point = namedtuple('Point', 'x y') | Tuple with named fields — immutable, memory-efficient alternative to a class. | ||
OrderedDict() | • Dict that remembers insertion order and supports move_to_end()• still useful for LRU caches | ||
od.move_to_end("key") | Moves key to end (or beginning with last=False) — key primitive for LRU cache implementation. | ||
ChainMap(local, global_, builtins) | • Groups multiple dicts — searches sequentially without copying • write goes to first map | ||
class MyDict(UserDict): | Subclass-friendly wrappers around dict/list — safer to subclass than the built-ins directly. |
Table 23: Concurrency
Python offers three concurrency models: threading (shared memory, GIL-limited for CPU work, good for I/O), multiprocessing (separate processes, true parallelism, higher overhead), and asyncio (cooperative single-thread, ultra-low overhead, requires async-aware code). concurrent.futures wraps both threading and multiprocessing behind one uniform executor interface; Python 3.14 adds InterpreterPoolExecutor for sub-interpreter concurrency without the IPC overhead of full processes.
| Technique | Example | Description | |
|---|---|---|---|
with ThreadPoolExecutor(max_workers=4) as ex: fut = ex.submit(func, arg) | • Thread pool — best for I/O-bound tasks • GIL limits CPU parallelism | ||
with ProcessPoolExecutor() as ex: fut = ex.submit(func, arg) | • Process pool — true CPU parallelism • data is pickled between processes | ||
list(ex.map(func, items)) | Parallel map — returns results in submission order, raises first exception encountered. | ||
fut.result(timeout=5) | Blocks until result available — re-raises any exception thrown by the worker. | ||
for f in as_completed(futures): | Yields futures as they complete — better throughput than waiting in submission order. | ||
with InterpreterPoolExecutor() as ex: | Runs tasks in sub-interpreters — true parallelism without pickle overhead (Python 3.14+). | ||
t = Thread(target=f, args=(1,))t.start(); t.join() | Spawns a native OS thread — use daemon=True to die with main thread. | ||
lock = Lock()with lock: | Mutex for shared state — with lock: is preferred (auto-releases on exceptions). | ||
e = Event()e.set(); e.wait() | Allows threads to signal each other — wait() blocks until set(). | ||
sem = Semaphore(3) | Limits concurrent access to n threads — acquire() decrements, release() increments. | ||
with Pool() as pool: pool.map(func, items) | Higher-level multiprocessing API — automatically manages worker process lifecycle. | ||
q = mp.Queue()q.put(x); q.get() | Process-safe queue — IPC via pickle across process boundaries. | ||
python3.14 -X gil=0 | Python 3.14 makes free-threading production-ready (PEP 779) — true thread parallelism possible. |
Table 24: Logging Module
Python's logging is a hierarchical system: every logger is a node in a tree rooted at the root logger, and events propagate upward unless propagate=False. Application code should always call logging.getLogger(__name__), let libraries configure nothing themselves, and leave root-level configuration to the application entry point.
| Technique | Example | Description | |
|---|---|---|---|
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s") | • Configures root logger — one-time call for simple scripts • must be before first log call | ||
logger = logging.getLogger(__name__) | • Gets or creates a named logger — hierarchy via dot notation • always use __name__. | ||
logger.debug("...")logger.info("...")logger.warning("...")logger.error("...")logger.critical("...") | Five levels: DEBUG < INFO < WARNING < ERROR < CRITICAL — only events at or above set level are emitted. | ||
h = logging.StreamHandler()logger.addHandler(h) | Outputs to stderr (default) or any stream — standard handler for console output. | ||
h = logging.FileHandler("app.log") | Writes to a file — use RotatingFileHandler for size-limited rotation. | ||
RotatingFileHandler("app.log", maxBytes=1e6, backupCount=3) | Rotates log file when it reaches maxBytes — keeps backupCount backups. | ||
fmt = Formatter("%(asctime)s - %(name)s - %(message)s")h.setFormatter(fmt) | Controls log record format — standard attributes include asctime, name, levelname, message. | ||
except Exception: logger.exception("Error") | Logs at ERROR level plus the full stack trace — use inside except blocks. | ||
logger.propagate = False | Stops log records bubbling up to parent loggers — avoids duplicate output. | ||
logging.config.dictConfig(cfg) | Configures logging from a dict or file — preferred for production over basicConfig. | ||
adapter = LoggerAdapter(logger, {"req_id": id}) | Adds contextual data to every log call without modifying the message format. |
Table 25: Virtual Environments and Packaging
Isolation is the first principle: one project, one environment, so dependency versions never interfere. venv is the built-in option (zero install, always available), while uv (Astral) is a fast Rust-based alternative that manages both environments and Python installations with near-instant dependency resolution.
| Tool | Example | Description | |
|---|---|---|---|
python -m venv .venv | Creates a virtual environment — installs pip + copies/symlinks interpreter. | ||
source .venv/bin/activate.venv\Scripts\activate | Activates environment — modifies PATH so python/pip point to venv. | ||
pip install requestspip install -r requirements.txt | Installs packages — -r installs from requirements file. | ||
pip freeze > requirements.txt | Snapshots current installed packages with pinned versions. | ||
uv init example | Creates a new project with pyproject.toml — fast Rust-based tool (Astral). | ||
uv run script.py | Runs script in an isolated, auto-created environment — no manual activation needed. | ||
uv add requests | Adds dependency to pyproject.toml and updates lockfile atomically. | ||
uv sync | Installs dependencies from lockfile — reproduces exact environment. | ||
uv python install 3.12 | Downloads and installs a specific Python version — managed alongside venv. | ||
[project]name = "myapp"requires-python = ">=3.11" | • Modern packaging standard — replaces setup.py• supported by pip, uv, poetry, flit | ||
pyenv install 3.11.5pyenv local 3.11.5 | Manages multiple Python versions side-by-side — sets .python-version file per directory. | ||
poetry new projectpoetry add requests | Package manager with lockfile and publishing support — poetry install reproduces env. |
Table 26: Advanced Patterns and Best Practices
These patterns represent idiomatic Python thinking: prefer iteration over indexing, exploit descriptors and __slots__ for performance-critical classes, compose with functools.partial (and Python 3.14's Placeholder for gap filling), and exploit generators for lazy pipelines that process data without materializing everything in memory.
| Technique | Example | Description | |
|---|---|---|---|
evens = (x for x in data if x%2==0)result = sum(evens) | • Chains generators lazily — never materializes intermediate lists • memory-efficient for large datasets | ||
double = partial(mul, 2) | Pre-fills arguments — creates specialized callable from a general function. | ||
f = partial(pow, ..., 2) | Marks positional gaps in partial() that callers must fill — ... is the Placeholder (Python 3.14+). | ||
reduce(lambda a,b: a+b, nums) | Folds a sequence left-to-right into a single value. | ||
def __get__(self, obj, type): | Implements per-attribute access — foundation for property, classmethod, staticmethod. | ||
__slots__ = ("x", "y") | Replaces per-instance __dict__ with fixed memory layout — reduces RAM and speeds attribute access. | ||
while chunk := f.read(8192): | • Assignment expression — assigns and evaluates in one step • avoids repeated calls | ||
def f(a, b, /, c): | • / separator — a, b can only be passed by position• prevents API-breaking renames | ||
def f(*, a, b): | * separator — a, b must be passed by keyword. | ||
class Meta(type): def __new__(mcs, ...): | Controls class creation — used by ORMs, ABCs, and plugin registries. | ||
def __init_subclass__(cls, **kw): | Hook called when a class is subclassed — simpler plugin registration than metaclasses. | ||
def __new__(cls): if not cls._instance: cls._instance = super().__new__(cls) return cls._instance | Ensures one instance via __new__ — thread-safe version requires a lock. | ||
tmpl = t"Hello {name}" | • Like f-strings but deferred — returns a Template object instead of a string• enables safe HTML/SQL generation (Python 3.14+). | ||
def f() -> MyClass: | • Annotations are not evaluated at import time in Python 3.14+ — forward references require no quotes • use annotationlib to evaluate explicitly | ||
import concurrent.interpreters | New in Python 3.14 (PEP 734) — runs code in isolated sub-interpreters with true parallelism via InterpreterPoolExecutor. |