Python Cheat Sheet

Updated 2026-03-31

Next Topic: Python Libraries Cheat Sheet

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

Quick Index266 entries · 22 tables

Mind Map

22 tables, 266 concepts. Select a concept node to jump to its table row.

Preparing mind map...

Table 1: Data Types

Type	Example	Description
int	`x = 42`	• Arbitrary-precision integers • no overflow limit unlike many languages.
float	`y = 3.14`	• Double-precision floating-point numbers (64-bit IEEE 754) • beware rounding errors.
complex	`z = 1 + 2j`	• Numbers with real and imaginary parts • `j` suffix denotes imaginary unit.
str	`s = "hello"`	• Immutable sequence of Unicode characters • supports f-strings, slicing, and rich methods.
bool	`flag = True`	Subclass of `int` with values `True` (1) or `False` (0).
list	`arr = [1, 2, 3]`	• Mutable ordered sequence • most versatile collection type.
tuple	`t = (1, 2, 3)`	• Immutable ordered sequence • hashable when elements are hashable, useful as dict keys.
dict	`d = {"key": "val"}`	• Mutable mapping of unique keys to values • insertion-ordered since Python 3.7.
set	`s = {1, 2, 3}`	• Mutable unordered collection of unique hashable elements • supports set operations.
frozenset	`fs = frozenset([1, 2])`	• Immutable version of `set` • hashable, can be dict key or set element.
None	`x = None`	• Singleton representing absence of value • distinct from empty collections or zero.
bytes	`b = b"data"`	• Immutable sequence of byte values (0-255) • for binary data.
bytearray	`ba = bytearray(b"x")`	• Mutable version of `bytes` • in-place modification of binary data.
range	`r = range(10)`	• Immutable sequence representing an arithmetic progression • memory-efficient for iteration.

Table 2: Operators

Operator	Example	Description
Arithmetic	`x + y`, `x - y`, `x * y`	• Addition, subtraction, multiplication • work on numbers and some sequences.
Division	`x / y`	• True division • always returns float even for integer operands.
Floor division	`x // y`	• Division rounded down to nearest integer • result type depends on operands.
Modulo	`x % y`	• Remainder of division • sign matches divisor unlike some languages.
Exponentiation	`x ** y`	• Raises `x` to power `y` • supports negative and fractional exponents.
Comparison	`x == y`, `x != y`, `x < y`	• Equality, inequality, less-than • chainable like `x < y < z`.
Identity	`x is y`	• Tests if objects are same instance • not value equality.
Membership	`x in y`	• Checks if `x` exists in container `y` • efficient for sets/dicts.
Logical AND	`x and y`	• Returns first falsy value or last value if all truthy • short-circuits.
Logical OR	`x or y`	• Returns first truthy value or last value if all falsy • short-circuits.
Logical NOT	`not x`	• Boolean negation • returns `True` if `x` is falsy.
Bitwise AND	`x & y`	• Bitwise AND of integers • also set intersection for sets.
Bitwise OR	`x \| y`	• Bitwise OR of integers • also set union for sets.
Bitwise XOR	`x ^ y`	• Bitwise exclusive OR • also symmetric difference for sets.
Bitwise NOT	`~x`	• One's complement • inverts all bits.
Left shift	`x << n`	• Shifts bits left by `n` positions • equivalent to multiplying by `2**n`.
Right shift	`x >> n`	• Shifts bits right by `n` positions • equivalent to floor dividing by `2**n`.
Dict merge operator	`d1 \| d2`	• Merges two dicts into new dict • `\|=` updates in-place (Python 3.9+).
Walrus operator	`(x := 5)`	• Assignment expression • assigns and returns value in single operation (Python 3.8+).

Table 3: String Operations

Method	Example	Description
f-strings	`f"{x} + {y} = {x+y}"`	• Formatted string literals • fastest and most readable formatting method • nested quotes and multiline expressions since 3.12.
format()	`"{} {}".format(a, b)`	• String formatting with positional/keyword arguments • more verbose than f-strings.
split()	`s.split(",")`	• Splits string into list by delimiter • default splits on whitespace.
join()	`",".join(items)`	• Concatenates iterable into single string with separator • preferred over += in loops.
strip()	`s.strip()`	• Removes leading and trailing whitespace • `lstrip()`/`rstrip()` for one side.
removeprefix() / removesuffix()	`s.removeprefix("pre")`	• Removes exact prefix or suffix if present • returns unchanged string otherwise (Python 3.9+).
replace()	`s.replace("old", "new")`	• Returns copy with all occurrences replaced • optional count parameter.
upper() / lower()	`s.upper()`	• Case conversion • `casefold()` for aggressive case-insensitive comparisons.
startswith() / endswith()	`s.startswith("pre")`	• Checks if string starts/ends with prefix/suffix • accepts tuple of options.
find() / index()	`s.find("sub")`	• Searches substring position • `find()` returns -1 if not found, `index()` raises exception.
isdigit() / isalpha()	`s.isdigit()`	• Character type checks • many variants like `isalnum()`, `isspace()`.
t-strings	`t"Hello {name}"`	• Template strings producing `Template` object for custom processing • generalization of f-strings (Python 3.14+).
%-formatting (legacy)	`"%s %d" % (s, n)`	• C-style formatting • replaced by f-strings but still commonly seen in older code.

Table 4: Slicing and Indexing

Pattern	Example	Description
Positive indexing	`s[0]`, `s[2]`	• Zero-based indexing from start • first element is `[0]`.
Negative indexing	`s[-1]`, `s[-2]`	• Indexes from end • -1 is last element, -2 second-to-last.
Basic slice	`s[1:4]`	Elements from index 1 up to (but not including) 4.
Omit start	`s[:3]`	• From beginning to index 3 • equivalent to `s[0:3]`.
Omit end	`s[2:]`	• From index 2 to end • includes last element.
Full copy	`s[:]`	Creates shallow copy of entire sequence.
Step slicing	`s[::2]`	• Every 2nd element • third parameter is step size.
Reverse	`s[::-1]`	• Reverses sequence • negative step iterates backward.
Negative step slice	`s[4:1:-1]`	From index 4 down to (but not including) 1.

Table 5: Control Flow

Statement	Example	Description
if	`if x > 0:` `print("pos")`	• Conditional execution • tests truthiness of expression.
elif	`elif x == 0:` `print("zero")`	• Chain multiple conditions • only first true branch executes.
else	`else:` `print("neg")`	Executes when all if/elif conditions are false.
Ternary expression	`x if cond else y`	• Inline conditional • returns `x` if cond is true, else `y`.
for loop	`for i in range(5):` `print(i)`	• Iterates over any iterable object • most common loop type.
while loop	`while x > 0:` `x -= 1`	• Repeats while condition is truthy • check happens before each iteration.
break	`break`	Exits innermost enclosing loop immediately.
continue	`continue`	Skips to next iteration of innermost loop.
else on loops	`for i in items:` `pass` `else:` `print("done")`	• Executes if loop completes without break • useful for search patterns.
pass	`pass`	• Null operation • syntactic placeholder where statement required.
match-case	`match x:` `case 1:` `print("one")`	• Structural pattern matching with guards, captures, and destructuring • switch-like statement (Python 3.10+).

Table 6: Functions

Technique	Example	Description
Function definition	`def func(a, b):` `return a + b`	• Creates reusable code block • `return` without value returns `None`.
Default arguments	`def f(x, y=10):`	• Parameters with default values • must come after required params.
Keyword arguments	`f(x=1, y=2)`	• Named parameters • allows any order and improves clarity.
*args	`def f(*args):`	• Variable positional arguments • collected as tuple.
**kwargs	`def f(**kwargs):`	• Variable keyword arguments • collected as dict.
Lambda	`lambda x: x * 2`	• Anonymous function • single expression only, no statements.
Docstring	`"""Description"""`	• First string in function • accessible via `__doc__` • used by help().
Type hints	`def f(x: int) -> int:`	• Optional annotations • not enforced at runtime but used by type checkers.
Unpacking in calls	`f(args, *kwargs)`	Expands sequences and mappings into function arguments.

Table 7: Comprehensions and Generators

Technique	Example	Description
List comprehension	`[x**2 for x in range(10)]`	• Creates list from iterable • faster and cleaner than for-loop append.
With condition	`[x for x in nums if x > 0]`	• Filters elements • condition acts as inline filter.
Nested comprehension	`[x+y for x in a for y in b]`	• Multiple `for` clauses • left-to-right nesting order.
Dict comprehension	`{k: v**2 for k, v in d.items()}`	• Creates dict from iterable • key-value pairs with unique keys.
Set comprehension	`{x**2 for x in nums}`	• Creates set • automatically deduplicates results.
Generator expression	`(x**2 for x in range(10))`	• Lazy evaluation • memory-efficient for large sequences.
Generator function	`def gen():` `yield x`	• Function with `yield` • pauses and resumes execution on each call.
yield from	`yield from iterable`	• Delegates to subiterator • simplifies nested generators (Python 3.3+).

Table 8: Classes and OOP

Concept	Example	Description
Class definition	`class Dog:` `pass`	• Creates new type • naming convention is PascalCase.
init	`def __init__(self, name):`	• Constructor • initializes instance when object created.
Instance attributes	`self.name = name`	• Per-object data • defined in `__init__` or other methods.
Class attributes	`class Dog:` `species = "Canis"`	• Shared across all instances • defined at class level.
Methods	`def bark(self):`	• Functions bound to instance • first param is `self` by convention.
Inheritance	`class Puppy(Dog):`	• Derives from parent class • inherits attributes and methods.
super()	`super().__init__(name)`	• Calls parent class method • handles multiple inheritance correctly.
@property	`@property` `def age(self):`	• Getter method • accessed like attribute but computed dynamically.
@property.setter	`@age.setter` `def age(self, val):`	• Setter method • allows validation and side effects on assignment.
@classmethod	`@classmethod` `def factory(cls):`	• Method receives class not instance • for alternative constructors.
@staticmethod	`@staticmethod` `def util():`	• Regular function in class namespace • no implicit first parameter.
Multiple inheritance	`class C(A, B):`	• Inherits from multiple classes • uses MRO (Method Resolution Order).
str / repr	`def __repr__(self):`	• String representations • `__repr__` for debugging, `__str__` for users.
slots	`__slots__ = ('x', 'y')`	• Declares fixed attributes • reduces memory and prevents `__dict__` creation.
init_subclass	`def __init_subclass__(cls):`	• Hook called when class is subclassed • modern alternative to metaclasses (Python 3.6+).

Table 9: Magic Methods (Dunder Methods)

Method	Example	Description
init	`def __init__(self):`	• Instance initialization • called when object is created.
str	`def __str__(self):`	• Informal string representation • used by `str()` and `print()`.
repr	`def __repr__(self):`	• Official string representation • should be valid Python when possible.
len	`def __len__(self):`	• Returns length • called by `len()` • must return non-negative int.
getitem	`def __getitem__(self, key):`	• Indexing operator `[]` • enables subscript access.
setitem	`def __setitem__(self, k, v):`	• Item assignment `[k] = v` • makes object mutable container.
iter	`def __iter__(self):`	• Returns iterator • enables for-loop support.
next	`def __next__(self):`	• Gets next value • raises `StopIteration` when exhausted.
enter / exit	`def __enter__(self):`	• Context manager protocol • enables `with` statement.
add	`def __add__(self, other):`	• Addition operator `+` • return new object, don't modify self.
eq	`def __eq__(self, other):`	• Equality operator `==` • default compares identity.
lt / gt	`def __lt__(self, other):`	• Comparison operators `<` and `>` • enables sorting.
call	`def __call__(self):`	• Makes instance callable like function • enables `obj()` syntax.
contains	`def __contains__(self, item):`	• Membership test `in` • should return boolean.

Table 10: Exception Handling

Technique	Example	Description
try-except	`try:` `risky()` `except ValueError:`	• Catches exceptions • specific types should precede general.
Multiple exceptions	`except (ValueError, KeyError):`	• Catches multiple types • tuple of exception classes.
except with variable	`except ValueError as e:`	• Captures exception object • access message and details.
else clause	`else:` `print("success")`	• Runs if no exception raised • before `finally`.
finally	`finally:` `cleanup()`	• Always executes • even if exception or return • for resource cleanup.
raise	`raise ValueError("msg")`	• Throws exception • can re-raise caught exception with bare `raise`.
Custom exceptions	`class MyError(Exception):`	• Define new exception types • inherit from Exception or subclass.
Exception chaining	`raise NewError() from e`	• Links exceptions • preserves original cause for debugging.
ExceptionGroup	`raise ExceptionGroup("msg",` `[ValueError(), KeyError()])`	• Groups multiple exceptions together • handled with `except*` syntax (Python 3.11+).
except*	`except* ValueError as eg:`	• Catches matching exceptions from an ExceptionGroup • multiple `except*` clauses can match different types (Python 3.11+).
Bare except (avoid)	`except:`	• Catches all exceptions • dangerous—can hide bugs, use sparingly.

Table 11: File Operations

Technique	Example	Description
open() for reading	`f = open("file.txt", "r")`	• Opens text file • mode "r" is default • must close manually.
with statement	`with open("f.txt") as f:`	• Context manager • auto-closes file even if exception occurs.
read()	`content = f.read()`	• Reads entire file as string • memory-intensive for large files.
readline()	`line = f.readline()`	• Reads single line • includes newline character.
readlines()	`lines = f.readlines()`	• Returns list of all lines • newlines preserved.
Iterate file	`for line in f:`	• Memory-efficient line iteration • preferred over readlines() for large files.
write()	`f.write("text")`	• Writes string to file • doesn't add newline automatically.
writelines()	`f.writelines(lines)`	• Writes sequence of strings • no newlines added.
Mode "w"	`open("f.txt", "w")`	• Write mode • truncates existing file or creates new.
Mode "a"	`open("f.txt", "a")`	• Append mode • adds to end of existing file.
Mode "b"	`open("f.bin", "rb")`	• Binary mode • for non-text files • returns bytes objects.
pathlib.Path	`Path("f.txt").read_text()`	• Object-oriented paths • cleaner API than os.path • `copy()` and `move()` methods added in 3.14.

Table 12: Modules and Imports

Technique	Example	Description
import module	`import math`	• Imports entire module • access via `math.func()`.
from import	`from math import sqrt`	• Imports specific names • directly accessible without prefix.
import as	`import numpy as np`	• Aliases module • shorter name for convenience.
from import *	`from math import *`	• Imports all public names • discouraged—pollutes namespace.
Relative imports	`from . import sibling`	• Within packages • dot notation for current/parent package.
init.py	`pkg/__init__.py`	• Makes directory a package • can initialize package and control imports.
if name == "main"	`if __name__ == "__main__":`	• Checks if script is run directly vs imported • guards executable code.
sys.path	`sys.path.append(dir)`	• Module search paths • modify to add custom locations.
importlib	`importlib.import_module(name)`	• Dynamic imports • import by string name at runtime.

Table 13: Common Built-in Functions

Function	Example	Description
len()	`len([1, 2, 3])`	• Returns length of sequence or collection • calls `__len__` method.
range()	`range(start, stop, step)`	• Generates arithmetic sequence • stop is exclusive.
enumerate()	`enumerate(items, start=0)`	• Adds counter to iterable • returns (index, value) pairs.
zip()	`zip(list1, list2)`	• Pairs elements from iterables • stops at shortest input • `strict=True` raises if lengths differ (3.10+).
map()	`map(func, iterable)`	• Applies function to each element • returns lazy iterator.
filter()	`filter(predicate, items)`	• Filters elements where predicate is truthy • lazy iterator.
sum()	`sum(numbers, start=0)`	• Sums numeric iterable • optional starting value.
sorted()	`sorted(items, key=func)`	• Returns new sorted list • doesn't modify original.
min() / max()	`min(items, key=func)`	• Returns smallest/largest element • optional key function.
all()	`all([True, True, False])`	Returns `True` if all elements truthy or iterable empty.
any()	`any([False, False, True])`	Returns `True` if any element truthy.
reversed()	`reversed(seq)`	• Returns reverse iterator • doesn't modify original.
isinstance()	`isinstance(obj, type)`	• Checks object type • accepts tuple of types.
type()	`type(obj)`	• Returns object's type • for checking use isinstance() instead.
input()	`input("Enter: ")`	• Reads line from stdin • always returns string.
print()	`print(*values, sep=" ")`	• Writes to stdout • customizable separator and ending.

Table 14: Itertools Module

Function	Example	Description
count()	`count(start=0, step=1)`	• Infinite counter • useful with `zip()` or `takewhile()`.
cycle()	`cycle([1, 2, 3])`	• Repeats iterable infinitely • saves copy of all elements.
repeat()	`repeat(10, times=3)`	• Repeats object n times • infinite if times omitted.
chain()	`chain(it1, it2)`	• Concatenates iterables • flattens into single iterator.
pairwise()	`pairwise([1, 2, 3])`	• Returns overlapping pairs of consecutive elements • yields `(1,2), (2,3)` (Python 3.10+).
batched()	`batched(range(10), 3)`	• Splits iterable into fixed-size tuples • last batch may be shorter (Python 3.12+).
combinations()	`combinations(items, r)`	• All r-length combinations • order doesn't matter, no repeats.
permutations()	`permutations(items, r)`	• All r-length permutations • order matters.
product()	`product(a, b)`	• Cartesian product • equivalent to nested for-loops.
groupby()	`groupby(items, key=func)`	• Groups consecutive elements by key • input must be sorted by same key.
islice()	`islice(it, start, stop)`	• Slices iterator • doesn't support negative indices.
accumulate()	`accumulate(nums, func)`	• Running totals or reductions • default is sum.
takewhile()	`takewhile(pred, it)`	• Yields elements while predicate true • stops at first false.
dropwhile()	`dropwhile(pred, it)`	• Skips elements while predicate true • yields rest.
zip_longest()	`zip_longest(a, b, fill=None)`	Like `zip()` but continues to longest input with fillvalue.

Table 15: Decorators

Technique	Example	Description
Function decorator	`@decorator` `def func():`	• Wraps function to modify behavior • syntax sugar for `func = decorator(func)`.
Simple decorator	`def deco(f):` `def wrap():` `return f()` `return wrap`	• Returns wrapper function • replaces original function.
functools.wraps	`@wraps(f)` `def wrapper():`	• Preserves function metadata (`__name__`, `__doc__`) • use in decorator wrappers.
Decorator with args	`@deco(arg)` `def func():`	• Returns decorator • three-level nesting: `deco(arg)(func)()`.
Class decorator	`@deco` `class MyClass:`	• Modifies or replaces class • callable returns class.
Method decorator	`@staticmethod` `def method():`	Built-in decorators like `@classmethod`, `@staticmethod`, `@property`.
Stacking decorators	`@deco1` `@deco2` `def f():`	• Multiple decorators • applied bottom-up: `deco1(deco2(f))`.
lru_cache	`@lru_cache(maxsize=128)`	• Memoizes function results • significant speedup for repeated calls.
functools.cache	`@cache`	• Simpler unbounded memoization • shorthand for `lru_cache(maxsize=None)` (Python 3.9+).

Table 16: Context Managers

Technique	Example	Description
with statement	`with open("f") as f:`	• Ensures resource cleanup • calls `__enter__` and `__exit__`.
Multiple contexts	`with open("a") as f1, open("b") as f2:`	• Manages multiple resources • left-to-right acquisition.
contextlib.contextmanager	`@contextmanager` `def ctx():`	• Creates context manager from generator • `yield` separates setup/teardown.
Custom enter / exit	`def __enter__(self):` `return self`	• Implement protocol manually • `__exit__` gets exception info.
contextlib.suppress	`with suppress(FileNotFoundError):`	• Ignores specified exceptions • cleaner than try-except pass.
contextlib.closing	`with closing(obj):`	• Calls `close()` on exit • for objects without context manager.
ExitStack	`with ExitStack() as stack:`	Manages variable number of context managers dynamically.

Table 17: Async/Await (Asyncio)

Technique	Example	Description
async def	`async def fetch():`	• Defines coroutine function • must be awaited or scheduled as task.
await	`result = await coro()`	• Suspends coroutine • yields control to event loop until result ready.
asyncio.run()	`asyncio.run(main())`	• Entry point • creates event loop and runs coroutine.
asyncio.create_task()	`task = create_task(coro())`	• Schedules coroutine • runs concurrently with other tasks.
asyncio.gather()	`await gather(coro1(), coro2())`	• Runs multiple coroutines concurrently • waits for all to complete.
asyncio.TaskGroup	`async with TaskGroup() as tg:` `tg.create_task(coro())`	• Structured concurrency • auto-cancels remaining tasks on failure (Python 3.11+).
asyncio.timeout()	`async with asyncio.timeout(5):`	• Context manager with deadline • raises `TimeoutError` if exceeded (Python 3.11+).
asyncio.wait_for()	`await wait_for(coro(), timeout=5)`	• Adds timeout to coroutine • raises TimeoutError if exceeded.
async for	`async for item in async_iter:`	• Iterates over async iterable • calls `__aiter__` and `__anext__`.
async with	`async with resource:`	• Async context manager • awaits `__aenter__` and `__aexit__`.
asyncio.sleep()	`await asyncio.sleep(1)`	• Non-blocking sleep • yields control to other coroutines.

Table 18: Type Hints

Technique	Example	Description
Basic types	`x: int = 5`	• Annotates variable type • not enforced at runtime.
Function annotations	`def f(x: int) -> str:`	• Parameter and return types • used by type checkers like mypy.
List[T]	`items: List[int]`	• Homogeneous list • generic type with element type.
Dict[K, V]	`d: Dict[str, int]`	Dictionary with specific key/value types.
Optional[T]	`x: Optional[int] = None`	• Shorthand for `Union[T, None]` • accepts value or None.
Union[T1, T2]	`x: Union[int, str]`	• Multiple allowed types • modern syntax `int \| str` (Python 3.10+).
Tuple[T, ...]	`t: Tuple[int, str]`	• Fixed-length tuple with specific types • `...` for variable length.
Callable	`f: Callable[[int], str]`	• Function type • list of param types, return type.
Any	`x: Any`	• Disables type checking • avoid when possible.
TypeVar	`T = TypeVar('T')`	• Generic type variable • for parametric polymorphism.
Protocol	`class Sized(Protocol):`	• Structural subtyping • duck typing with type hints.
Literal	`x: Literal["a", "b"]`	• Restricts to specific values • for constants.
type statement	`type Vector = list[float]`	• Declares type alias with lazy evaluation • replaces `TypeAlias` annotation (Python 3.12+).
Type parameter syntax	`def f[T](x: T) -> T:`	• Inline generic type variables on functions and classes • replaces `TypeVar` boilerplate (Python 3.12+).
TypeIs	`def is_str(x) -> TypeIs[str]:`	• Narrows type in both if/else branches • safer than `TypeGuard` (Python 3.13+).
@override	`@override` `def method(self):`	• Marks method as overriding parent • type checkers flag mismatches (Python 3.12+).

Table 19: Regular Expressions

Function	Example	Description
re.match()	`re.match(r"\d+", s)`	• Matches at start of string only • returns match object or None.
re.search()	`re.search(r"\d+", s)`	• Searches anywhere in string • returns first match.
re.findall()	`re.findall(r"\d+", s)`	• Returns list of all matches • non-overlapping.
re.finditer()	`re.finditer(r"\d+", s)`	• Returns iterator of match objects • memory-efficient for large inputs.
re.sub()	`re.sub(r"\d+", "X", s)`	• Replaces matches • accepts function as replacement.
re.split()	`re.split(r"\s+", s)`	• Splits by pattern • preserves groups in result.
re.compile()	`p = re.compile(r"\d+")`	• Precompiles pattern • faster for reuse.
Groups	`m.group(1)`	• Captures subpatterns • `group(0)` is entire match.
Named groups	`(?P<name>\d+)`	• Named capture • access via `m.group('name')`.
re.IGNORECASE	`re.search(r"a", s, re.I)`	• Case-insensitive matching • multiple flags with `re.I \| re.M`.
Raw strings	`r"\d+"`	• Prefix with `r` • avoids double-escaping backslashes.

Table 20: Dataclasses and Modern Class Features

Technique	Example	Description
@dataclass	`@dataclass` `class Point:`	• Auto-generates `__init__`, `__repr__`, etc. • less boilerplate (Python 3.7+).
Field with default	`x: int = 0`	• Default values • mutable defaults require `field(default_factory=...)`.
field()	`items: list = field(default_factory=list)`	• Customizes field behavior • prevents shared mutable defaults.
frozen=True	`@dataclass(frozen=True)`	• Makes instances immutable • enables hashing for use as dict keys.
slots=True	`@dataclass(slots=True)`	• Generates `__slots__` for reduced memory • prevents dynamic attribute creation (Python 3.10+).
kw_only=True	`@dataclass(kw_only=True)`	• Forces keyword-only arguments in `__init__` • prevents positional mistakes (Python 3.10+).
post_init	`def __post_init__(self):`	• Runs after `__init__` • for computed fields or validation.
InitVar	`temp: InitVar[int]`	• Init-only variable • not stored as field, available in `__post_init__`.
asdict() / astuple()	`asdict(obj)`	• Converts dataclass to dict/tuple • shallow copy by default.
attrs	`@define` `class C:`	• Third-party alternative • more features than dataclasses.
Pydantic	`class User(BaseModel):`	• Data validation library • runtime type checking and JSON schema.

Table 21: Virtual Environments and Package Management

Command	Example	Description
venv creation	`python -m venv myenv`	• Creates isolated environment • includes own Python and pip.
Activation (Unix)	`source myenv/bin/activate`	• Activates environment • modifies PATH to use venv Python.
Activation (Windows)	`myenv\Scripts\activate.bat`	• Windows activation • PowerShell uses activate.ps1.
Deactivation	`deactivate`	• Returns to system Python • works on all platforms.
pip install	`pip install package`	• Installs package • use -U for upgrade.
uv	`uv pip install package`	• Ultra-fast Rust-based package manager • drop-in replacement for pip, venv, and pip-tools.
pip freeze	`pip freeze > requirements.txt`	• Exports installed packages • pinned versions for reproducibility.
pip install -r	`pip install -r requirements.txt`	• Installs from requirements file • exact versions specified.
pip list	`pip list`	• Shows installed packages • `--outdated` flag checks for updates.
pip show	`pip show package`	• Package details • shows dependencies and install location.
pip uninstall	`pip uninstall package`	• Removes package • prompts for confirmation.

Table 22: Advanced Patterns and Idioms

Pattern	Example	Description
EAFP	`try:` `d[k]` `except KeyError:`	• Easier to Ask Forgiveness than Permission • Pythonic error handling.
LBYL	`if k in d:` `x = d[k]`	• Look Before You Leap • less Pythonic, can have race conditions.
Chained comparison	`1 < x < 10`	• Multiple comparisons • more readable than `1 < x and x < 10`.
Unpacking	`a, b, *rest = items`	• Extended unpacking • *`rest` captures remaining** (Python 3.0+).
Dict get() with default	`d.get(key, default)`	• Safe access • returns default if key missing, doesn't raise.
setdefault()	`d.setdefault(k, []).append(x)`	• Gets or creates • single lookup vs get + assignment.
defaultdict	`from collections import defaultdict`	• Auto-creates missing keys • cleaner than setdefault for repeated use.
Counter	`Counter(items)`	• Counts hashable objects • dict subclass with counting methods.
namedtuple	`Point = namedtuple('Point', 'x y')`	• Tuple with named fields • immutable, memory-efficient alternative to class.
StrEnum	`class Color(StrEnum):` `RED = auto()`	• Enum with string values • members usable directly as strings (Python 3.11+).
ChainMap	`ChainMap(dict1, dict2)`	• Groups multiple dicts • searches sequentially without copying.
functools.reduce()	`reduce(lambda x,y: x+y, nums)`	• Cumulative operation • apply function cumulatively to sequence.
functools.partial()	`partial(func, arg1)`	• Partially applies arguments • creates new callable with fixed params.
functools.singledispatch()	`@singledispatch` `def process(arg):`	• Type-based function overloading • dispatches on first argument type.
Singleton pattern	`class Singleton(type):`	• Ensures single instance • use metaclass or module for implementation.

Back to Programming Languages