Python Interview Questions — Coding & Theory

Lists are mutable (can grow, shrink, and have elements reassigned) and use square brackets []. Tuples are immutable (fixed once created) and use parentheses (). Because tuples are immutable, they are hashable, so they can be used as dict keys or set members — lists cannot. Tuples are slightly faster and use less memory; lists offer many more methods (append, pop, sort, etc.).

lst = [1, 2, 3]; lst.append(4)        # OK
tup = (1, 2, 3); tup[0] = 9           # TypeError
d = {(1, 2): 'point'}                  # OK — tuple is hashable

Mutable objects can be changed in place after creation: list, dict, set, bytearray, and most user-defined classes. Immutable objects cannot be modified: int, float, bool, str, bytes, tuple, frozenset, None. Only immutable objects (or objects that hash by identity) can be used as dict keys or stored in a set.

`==` compares values (calls `__eq__`); `is` checks identity — whether both names point to the same object in memory (same `id()`). Use `is` for singletons like `None`, `True`, `False`. Small integers (-5 to 256) and short strings may be interned, so `is` can accidentally appear to work on them — never rely on it for value comparison.

a = [1, 2]; b = [1, 2]
a == b   # True  (same value)
a is b   # False (different objects)
x = None
x is None  # always use this, not x == None

`None` is Python's singleton object representing the absence of a value, of type `NoneType`. Unlike `null` in some languages, there is exactly one `None` instance for the entire program, so comparison via `is None` is the idiomatic and fastest check. Functions that don't explicitly return anything implicitly return `None`.

Python 3 integers are arbitrary-precision — they grow as needed, limited only by available memory. There is no `INT_MAX`. `sys.maxsize` reports the largest size a container can hold on the platform (`2**63 - 1` on 64-bit), but plain `int` arithmetic can exceed it freely.

import sys
sys.maxsize     # 9223372036854775807 on 64-bit
2 ** 1000       # works fine — no overflow

`copy.copy(x)` creates a new outer object but its elements still reference the same inner objects — mutating a nested object affects both copies. `copy.deepcopy(x)` recursively copies every nested object, so the two are fully independent. Assignment (`y = x`) creates no copy at all — just another name for the same object.

import copy
a = [[1, 2], [3, 4]]
b = copy.copy(a);     b[0].append(9)   # also mutates a[0]
c = copy.deepcopy(a); c[0].append(9)   # a untouched

f-strings (PEP 498, Python 3.6+) embed expressions inside string literals using `f"...{expr}..."`. They are faster than `%` formatting and `str.format()`, more readable, and support format-spec, `=` for debug-style output (3.8+), and inline method calls.

name, n = 'Ada', 7
f'{name} ran {n*2} miles'        # 'Ada ran 14 miles'
f'{n=}, {n*2=}'                  # 'n=7, n*2=14'
f'{3.14159:.2f}'                 # '3.14'

`range(n)` is a lazy, immutable sequence object — it computes values on demand and uses constant memory regardless of size. A list of numbers stores every value, using O(n) memory. In Python 3, `range` replaced Python 2's `xrange`; there is no `xrange` anymore.

sys.getsizeof(range(10**9))      # 48 bytes
# list(range(10**9))             # would OOM the machine

`__new__(cls, ...)` is the actual constructor — it allocates and returns a new instance. `__init__(self, ...)` is the initializer — it configures the already-created instance and returns `None`. `__call__(self, ...)` makes an instance callable like a function (e.g., `obj()`). You rarely override `__new__` outside of metaclasses, immutable subclasses, or singletons.

class Adder:
    def __init__(self, x): self.x = x
    def __call__(self, y): return self.x + y

add5 = Adder(5)
add5(3)        # 8 — instance used like a function

Instance methods take `self` and operate on a specific instance. `@classmethod` takes `cls` and operates on the class itself — used for alternative constructors (`from_string`, `from_dict`) and factories. `@staticmethod` takes neither — it's a regular function living in the class namespace for grouping; use it when the logic is related to the class but doesn't need access to instance or class state.

class Date:
    def __init__(self, y, m, d): self.y, self.m, self.d = y, m, d
    @classmethod
    def from_iso(cls, s): return cls(*map(int, s.split('-')))
    @staticmethod
    def is_leap(y): return y % 4 == 0 and (y % 100 != 0 or y % 400 == 0)

MRO is the order Python searches base classes when looking up an attribute on a class that has multiple parents. Python 3 uses the C3 linearization algorithm, which guarantees that each class appears before its parents and that the order in the bases list is preserved. Inspect via `Cls.__mro__` or `Cls.mro()`. C3 also detects inconsistent hierarchies at class-creation time and raises `TypeError`.

class A: pass
class B(A): pass
class C(A): pass
class D(B, C): pass
D.__mro__   # (D, B, C, A, object)

Dunder (double-underscore) methods let your class integrate with Python's syntax and built-ins. Important ones: `__init__` (initialize), `__repr__` (debug string), `__str__` (user string), `__len__` (len()), `__iter__` (for-loop), `__eq__`/`__hash__` (equality and hashing), `__getitem__`/`__setitem__` (subscript), `__enter__`/`__exit__` (context manager), `__call__` (callable instances).

`__repr__` is for developers — should be unambiguous and ideally `eval()`-able to recreate the object; shown in the REPL and by `repr(x)`. `__str__` is for end users — readable and friendly; called by `print(x)` and `str(x)`. If only `__repr__` is defined, `str()` falls back to it.

class Point:
    def __init__(self, x, y): self.x, self.y = x, y
    def __repr__(self): return f'Point({self.x}, {self.y})'
    def __str__(self):  return f'({self.x}, {self.y})'

`super()` returns a proxy that delegates attribute lookups to the next class in the MRO — not necessarily the literal parent. Using `super().__init__(...)` instead of `Parent.__init__(self, ...)` makes cooperative multiple inheritance work correctly and lets you change the base class without rewriting calls. In Python 3 you can call `super()` with no arguments inside a method.

ABCs (`abc.ABC`, `@abc.abstractmethod`) define an interface that subclasses must implement; instantiating a class with unimplemented abstract methods raises `TypeError`. Python's `collections.abc` module provides reusable ABCs (`Iterable`, `Mapping`, `Sequence`, etc.). They enable `isinstance()` checks against an interface rather than a concrete class.

from abc import ABC, abstractmethod
class Storage(ABC):
    @abstractmethod
    def save(self, key, value): ...
# Storage()  -> TypeError: abstract

Inheritance models 'is-a' relationships and shares implementation through subclassing — but couples the child to the parent's internals and creates fragile hierarchies. Composition models 'has-a' relationships by holding instances of other classes — more flexible and easier to test. The widely-followed rule is 'favor composition over inheritance' — use inheritance only when subtypes truly substitute for the base type (Liskov Substitution).

A decorator is a callable that takes a function (or class) and returns a replacement. `@dec` above a definition is sugar for `f = dec(f)`. Decorators are used for cross-cutting concerns: logging, caching, timing, access control, registration. Use `functools.wraps` inside the wrapper to preserve the original `__name__`, `__doc__`, and signature.

from functools import wraps
def log(fn):
    @wraps(fn)
    def wrapper(*a, **kw):
        print(f'calling {fn.__name__}')
        return fn(*a, **kw)
    return wrapper

@log
def add(a, b): return a + b

A closure is an inner function that remembers (captures) variables from its enclosing scope even after the outer function has returned. The captured variables are stored in the function's `__closure__` cells. To modify a captured variable from the inner function, use the `nonlocal` keyword.

def make_counter():
    count = 0
    def inc():
        nonlocal count
        count += 1
        return count
    return inc

c = make_counter(); c(); c()   # 1, 2

`*args` collects extra positional arguments into a tuple; `**kwargs` collects extra keyword arguments into a dict. On the calling side, `*` and `**` unpack iterables and mappings into arguments. The names `args`/`kwargs` are convention — only the `*` and `**` are syntactically required.

def trace(*args, **kwargs):
    print(args, kwargs)

opts = {'verbose': True}
trace(1, 2, name='ada', **opts)
# (1, 2) {'name': 'ada', 'verbose': True}

A `lambda` is an anonymous, single-expression function. It's handy as a short callback to `sorted`, `map`, `filter`, or `key=...` arguments. Avoid lambdas when: the logic spans multiple statements, you need type hints or a docstring, or naming the function would make the code clearer — PEP 8 specifically discourages assigning a lambda to a name (use `def` instead).

`@lru_cache(maxsize=N)` memoizes a function's results in a dict keyed by its arguments, evicting least-recently-used entries when full. Arguments must be hashable. It's a one-line speedup for pure functions with repeated calls — recursive ones especially. Use `maxsize=None` for an unbounded cache, or `@functools.cache` (3.9+) as a shortcut.

from functools import lru_cache
@lru_cache(maxsize=None)
def fib(n):
    return n if n < 2 else fib(n - 1) + fib(n - 2)
fib(100)   # instant

`@property` turns a method into a read-only attribute accessed without parentheses. Pair it with `@<name>.setter` / `@<name>.deleter` to add write/delete behavior. Useful for computed attributes and for adding validation while keeping a clean attribute-style API.

class Circle:
    def __init__(self, r): self._r = r
    @property
    def area(self): return 3.14159 * self._r ** 2
    @property
    def r(self): return self._r
    @r.setter
    def r(self, v):
        if v < 0: raise ValueError
        self._r = v

When you wrap a function inside a decorator, the wrapper replaces the original's `__name__`, `__doc__`, `__module__`, `__qualname__`, and signature. `@functools.wraps(original)` on the wrapper copies that metadata back, which keeps debuggers, `help()`, stack traces, and tools like Sphinx working correctly.

An iterable is any object with `__iter__()` that returns an iterator — lists, tuples, strings, dicts, sets, files. An iterator is an object with both `__iter__()` (returns itself) and `__next__()` (returns the next value or raises `StopIteration`). Iterators are single-use; iterables can be iterated repeatedly by producing a fresh iterator each time.

nums = [1, 2, 3]
it = iter(nums)
next(it), next(it)   # 1, 2
for n in nums: pass  # works — list is iterable
for n in it:  pass   # only yields 3 — iterator is consumed

A generator is a function that contains `yield`; calling it returns a generator object (an iterator) rather than running the body. Each `next()` advances to the next `yield` and pauses, preserving local state. Generators produce values lazily — ideal for large or infinite sequences — and use O(1) memory regardless of length.

def squares(n):
    for i in range(n):
        yield i * i

list(squares(5))   # [0, 1, 4, 9, 16]

`return` exits a function and produces a single value. `yield` produces a value but pauses the function — the next call resumes right after the `yield`, with all locals intact. A function with any `yield` becomes a generator function; a bare `return` (or running off the end) raises `StopIteration` from a generator.

`yield from iterable` delegates iteration to another iterable or sub-generator — it yields every value the inner iterable produces and forwards `send()`, `throw()`, and the return value back to the caller. It's the idiomatic way to chain generators without writing a manual `for` loop.

def chain(*iters):
    for it in iters:
        yield from it

list(chain([1, 2], (3, 4)))   # [1, 2, 3, 4]

Use a generator with a `while True` loop and `yield`, or one of `itertools.count`, `itertools.cycle`, or `itertools.repeat`. Always combine with a finite construct like `itertools.islice` or `break` so the program terminates.

from itertools import count, islice
list(islice(count(10, 2), 5))   # [10, 12, 14, 16, 18]

The Global Interpreter Lock is a CPython mutex that allows only one thread to execute Python bytecode at a time. It exists because CPython's memory management (reference counting) isn't thread-safe — the GIL simplifies the C API and the interpreter implementation. The consequence: pure-Python CPU-bound code does not benefit from threading. Use `multiprocessing`, `concurrent.futures.ProcessPoolExecutor`, native extensions (NumPy, etc.) that release the GIL, or asyncio for I/O-bound work. Python 3.13 introduced an experimental free-threaded build (PEP 703) that can run without the GIL.

CPython uses two mechanisms together. (1) Reference counting: every object tracks how many references point to it; when the count drops to zero, it's immediately freed. (2) A generational cyclic GC (the `gc` module) periodically scans for reference cycles that pure refcounting cannot collect (e.g., a list containing itself). Objects survive across three generations, scanned with decreasing frequency. You can disable, tune, or force collection with `gc.disable()`, `gc.set_threshold()`, `gc.collect()`.

Every CPython object holds a counter of how many references point to it. Assigning the object to a new name, passing it to a function, or putting it in a container increments the count; rebinding, returning, or `del` decrements it. When the count reaches zero, the object is freed immediately. `sys.getrefcount(x)` exposes it (returns one more than the actual count because the argument itself is a reference).

Defining `__slots__ = ('a', 'b')` tells Python to store attributes in a fixed array instead of a per-instance `__dict__`. This saves significant memory (often 40–50%) and speeds attribute access for classes you instantiate millions of times. Trade-offs: you can no longer add new attributes at runtime, multiple inheritance with non-slotted parents gets tricky, and `__weakref__` must be listed explicitly if needed.

class Point:
    __slots__ = ('x', 'y')
    def __init__(self, x, y): self.x, self.y = x, y

Threading runs multiple threads in one process, sharing memory — but the GIL serializes Python bytecode, so it only helps for I/O-bound work (network, disk) where threads release the GIL while waiting. Multiprocessing spawns separate OS processes, each with its own GIL — true parallelism for CPU-bound work, at the cost of higher startup overhead and serialization between processes. For high-concurrency I/O, `asyncio` is usually a better fit than threads.

Python is interpreted, dynamically typed, and every operation goes through layers of object dispatch and refcount bookkeeping. To speed it up: profile first (`cProfile`), pick better algorithms/data structures, use built-ins and the standard library (they're written in C), use NumPy / Pandas for numerical work, cache with `functools.lru_cache`, JIT-compile hot loops with Numba or PyPy, or write C extensions with Cython / pybind11. Premature optimization is the usual mistake.

`try` wraps risky code. `except` catches matching exceptions (be specific, not bare). `else` runs only if `try` succeeded with no exception — use it to scope the 'success path' tightly so `except` doesn't accidentally catch unrelated errors. `finally` always runs (success, exception, or `return`) — use for cleanup like closing handles.

try:
    f = open('x.txt')
except FileNotFoundError:
    data = ''
else:
    data = f.read()
finally:
    if 'f' in dir(): f.close()

A `SyntaxError` is raised by the parser before any code runs — your source isn't valid Python, so nothing executes. Exceptions occur at runtime while valid code is running (`ZeroDivisionError`, `KeyError`, etc.) and can be caught with `try/except`. `SyntaxError` *technically* inherits from `Exception` but you generally cannot catch the parse-time form.

Subclass `Exception` (or a more specific built-in like `ValueError`). Keep the hierarchy shallow and meaningful — usually one base exception per package and subclasses for distinct failure modes. Override `__init__` only if you need extra context attributes.

class PaymentError(Exception):
    pass
class InsufficientFunds(PaymentError):
    def __init__(self, needed, have):
        super().__init__(f'Need {needed}, have {have}')
        self.needed, self.have = needed, have

`__init__.py` marks a directory as a regular Python package. It runs when the package is first imported, so it's the place to expose a curated public API (re-export names, define `__all__`, set `__version__`). Since Python 3.3, directories without `__init__.py` work as 'namespace packages', but most projects still ship one for clarity and to control imports.

`import x` binds the module object to the name `x`; access its members as `x.y`. `from x import y` binds only `y` in the current namespace — shorter to use, but loses the module context and risks shadowing. `from x import *` should be avoided in application code; it pollutes the namespace and obscures origins. Both run the module exactly once — subsequent imports return the cached module from `sys.modules`.

A virtual environment is an isolated Python installation with its own `site-packages`, so each project can pin its own dependency versions without conflicting with others or the system Python. Create one with `python -m venv .venv`, activate it, then `pip install`. Modern tools like `uv`, `poetry`, and `pipenv` automate this further with lockfiles.

python -m venv .venv
.venv\Scripts\activate          # Windows
source .venv/bin/activate         # macOS/Linux
pip install -r requirements.txt

`asyncio` is Python's standard library for cooperative concurrency using coroutines on a single thread. The event loop schedules thousands of awaitable tasks that pause at `await` points and yield to others while waiting for I/O. Use it for I/O-bound workloads with high concurrency (HTTP clients, sockets, database drivers that support async). It does NOT help CPU-bound code — the work still runs on one thread.

`async def` defines a coroutine function — calling it returns a coroutine object that doesn't execute until awaited or scheduled on the event loop. Inside, you can use `await`, `async for`, and `async with`. A regular `def` runs to completion synchronously when called. Mixing them naively (calling a coroutine without awaiting) is a common bug — you get a `RuntimeWarning: coroutine ... was never awaited`.

`await expr` suspends the current coroutine until `expr` (an awaitable — coroutine, Task, or Future) completes, returning control to the event loop so other tasks can run. When the awaited thing resolves, the coroutine resumes with the result. `await` is only legal inside `async def` functions.

import asyncio
async def fetch(n):
    await asyncio.sleep(1)
    return n * 2
asyncio.run(asyncio.gather(fetch(1), fetch(2), fetch(3)))   # ~1s total

Concurrency means structuring a program so multiple tasks can be in progress at the same time — interleaved on one CPU, taking turns. Parallelism means actually executing multiple tasks at the same instant on multiple CPUs. Python threads (under the GIL) and `asyncio` give you concurrency; `multiprocessing`, C extensions that release the GIL, and the free-threaded build give you true parallelism.

`defaultdict(factory)` is a dict subclass that automatically creates missing keys by calling the factory (e.g., `list`, `int`, `set`). It removes boilerplate `if key not in d: d[key] = ...` patterns. Note that simply accessing a missing key creates the entry — use `dict.get(k, default)` if you don't want that side effect.

from collections import defaultdict
groups = defaultdict(list)
for word in ['apple', 'ant', 'bee']:
    groups[word[0]].append(word)
# {'a': ['apple', 'ant'], 'b': ['bee']}

`Counter` is a dict subclass for counting hashable items. Built from any iterable, it exposes `most_common(k)`, supports arithmetic (`+`, `-`, `&`, `|`), and treats missing keys as count 0. It's the idiomatic tool for frequency tables, vote counts, and anagram detection.

from collections import Counter
c = Counter('mississippi')
c.most_common(2)              # [('i', 4), ('s', 4)]
Counter('listen') == Counter('silent')   # True

`chain(*iterables)` flattens one level — concatenates iterables lazily. `groupby(iterable, key)` yields (key, group) for runs of consecutive items with the same key — the input must be sorted by that key first if you want true grouping. `product(*iterables, repeat=n)` is the Cartesian product — useful for nested-loop replacement.

from itertools import chain, groupby, product
list(chain([1, 2], [3]))                       # [1, 2, 3]
[(k, list(g)) for k, g in groupby('aaabbc')]   # [('a', [...]), ('b', [...]), ('c', [...])]
list(product([0, 1], repeat=2))                # [(0,0),(0,1),(1,0),(1,1)]

EAFP ('Easier to Ask Forgiveness than Permission') — just try the operation and catch any exception. LBYL ('Look Before You Leap') — check preconditions first with explicit `if` tests. Python's culture and idioms strongly favor EAFP: it's race-free in concurrent code, often faster on the happy path, and reads more naturally.

# EAFP (Pythonic)
try:
    value = d[key]
except KeyError:
    value = default

# LBYL
if key in d:
    value = d[key]
else:
    value = default

'If it walks like a duck and quacks like a duck, it's a duck.' Python cares about an object's behavior (the methods/attributes it supports) rather than its concrete type. Any object with a `read()` method works where a file-like object is expected, regardless of its class. Modern Python formalizes this with `typing.Protocol` (PEP 544) for static type checking.

`__name__` is set to `'__main__'` when a file is run directly, and to the module's import name when imported. The `if __name__ == '__main__':` guard lets a file act both as a reusable module and as a script — code under the guard runs only when executed directly, not on import. It's also required for `multiprocessing` on Windows to avoid recursive process spawning.

def main():
    print('running directly')

if __name__ == '__main__':
    main()

Python is high-level, interpreted, dynamically typed, and garbage-collected. Key features: clean readable syntax with significant whitespace, batteries-included standard library, first-class functions, everything-is-an-object data model, extensive third-party ecosystem (NumPy, Pandas, Django, etc.), and broad portability across operating systems. It supports multiple paradigms — procedural, object-oriented, and functional.

PEP 8 is the official Python style guide that defines conventions: 4-space indentation, 79-char line length, snake_case for functions/variables, PascalCase for classes, two blank lines between top-level definitions. Following it makes Python code instantly readable to any other Python developer. Tools like `flake8`, `black`, and `ruff` auto-check or auto-format to PEP 8.

Both. Python source is first compiled to bytecode (the `.pyc` files in `__pycache__`), then executed by the CPython virtual machine. So it's compiled to bytecode and interpreted at runtime — usually called 'interpreted' informally. PyPy adds a JIT compiler on top of that bytecode for big speedups.

CPython is the reference implementation written in C — what you get from python.org. PyPy is a Python implementation written in RPython with a JIT, often 4–10× faster on pure-Python code. Jython compiles to JVM bytecode and runs on the JVM. IronPython targets .NET / CLR. They mostly share the language spec but differ in performance and C-extension compatibility (CPython has the richest ecosystem).

Dynamically typed — a variable has no fixed type; the type lives on the object, not the name. You can rebind the same name to different types in successive statements. Type hints (PEP 484) add optional static-checking via tools like mypy or pyright, but they don't change runtime behavior.

x = 5; x = 'hi'; x = [1, 2]   # all legal
from typing import Optional
def f(n: int) -> Optional[str]: ...   # hint only

Strongly typed — Python does not silently coerce unrelated types. `'5' + 3` raises `TypeError`; you must explicitly convert with `int()` or `str()`. Contrast with JavaScript (`'5' + 3 == '53'`). The combination 'dynamic + strong' is Python's typing profile.

Numeric: `int`, `float`, `complex`, `bool`. Sequence: `list`, `tuple`, `range`, `str`, `bytes`, `bytearray`. Set: `set`, `frozenset`. Mapping: `dict`. None: `NoneType`. Plus callables (`function`, `method`, `class`), `module`, and many more in the standard library.

`type(x) is C` is an exact-class check — fails for subclasses. `isinstance(x, C)` returns True for `C` and any subclass, and accepts a tuple `(A, B)` for multi-class checks. Idiomatic Python prefers `isinstance` because it respects inheritance and ABCs.

isinstance(True, int)   # True — bool is a subclass
type(True) is int      # False

A namespace is a mapping from names to objects (typically a `dict`). Python resolves a bare name using LEGB order: Local (current function), Enclosing (any outer functions), Global (module), Built-in (builtins module). The first match wins. `global` and `nonlocal` keywords let an inner scope rebind names in outer scopes.

x = 'global'
def outer():
    x = 'enclosing'
    def inner():
        print(x)   # 'enclosing' via E
    inner()

A `list` is heterogeneous and stores object references — flexible but uses more memory. The `array` module gives a homogeneous, compact, C-style typed array (`array('i', ...)`). NumPy `ndarray` is the standard for fast numeric work — contiguous memory, vectorized ops, broadcasting.

from array import array
arr = array('i', [1, 2, 3])   # compact ints
import numpy as np
a = np.array([1, 2, 3])        # vectorized math

Both store unique hashable items with O(1) membership. `set` is mutable (`.add`, `.remove`, `.update`); `frozenset` is immutable and therefore hashable — so it can live inside another set or be used as a dict key.

s = {1, 2}; s.add(3)             # OK
fs = frozenset({1, 2})
key = {fs: 'sets-of-sets ok'}     # OK — frozenset is hashable

`str` is an immutable sequence of Unicode code points. `bytes` is an immutable sequence of integers 0–255. `bytearray` is the mutable version of bytes. Encode with `s.encode('utf-8')` to convert str → bytes; decode the reverse direction.

'café'.encode('utf-8')          # b'caf\xc3\xa9'
bytearray(b'abc')[0] = 65         # mutable
# bytes(b'abc')[0] = 65           # TypeError

Yes — since Python 3.7 (and as a CPython implementation detail in 3.6), dictionaries preserve insertion order, and this is part of the language spec. `collections.OrderedDict` is now rarely needed, though it still offers extras like `move_to_end()` and equality that respects order.

Use the type itself as a constructor: `int(x)`, `float(x)`, `str(x)`, `list(x)`, `tuple(x)`, `set(x)`, `dict(pairs)`, `bool(x)`. These raise `ValueError` / `TypeError` for invalid conversions. `int('0xff', 16)` accepts a base. Implicit coercion happens only between numeric types (e.g., `int + float → float`).

`//` is floor division — returns the integer quotient (rounding toward negative infinity). `%` is the modulo (remainder). `**` is exponentiation; `pow(a, b, mod)` also exists for fast modular exponentiation.

7 // 2     # 3
-7 // 2    # -4 — floors toward -inf
7 % 2      # 1
2 ** 10    # 1024

It produces a reversed copy of any sequence. The slice is `[start:stop:step]` — leaving start/stop blank means the entire sequence, and step `-1` walks backward.

'hello'[::-1]      # 'olleh'
[1, 2, 3][::-1]   # [3, 2, 1]

Negative indices count from the end: `-1` is the last item, `-2` the second-last, etc. They work on any sequence (list, tuple, str). Slicing accepts negative bounds too: `s[-3:]` gets the last 3 items.

[10, 20, 30, 40][-1]     # 40
'hello'[-3:]              # 'llo'

`pass` is a no-op placeholder — useful where syntax requires a statement but you don't want to do anything (empty function, empty class). `break` exits the innermost loop immediately. `continue` skips the rest of the current iteration and proceeds to the next one.

for n in nums:
    if n < 0: continue   # skip
    if n == sentinel: break
    process(n)

Before 3.10, no — idioms were `if/elif`, a dict-of-callables, or `getattr` dispatch. Python 3.10 added `match/case` (PEP 634), which is a structural-pattern-matching statement (much richer than C's switch — it can destructure, bind names, and match types).

match command.split():
    case ['quit']:           print('bye')
    case ['move', x, y]:     move(int(x), int(y))
    case _:                  print('unknown')

Yes. `value`, `Value`, and `VALUE` are three distinct names. This applies to identifiers, attribute lookups, and module names. Filesystem case-sensitivity for module imports depends on the OS — Windows is case-insensitive on disk but Python itself isn't.

`id(x)` returns the memory address (identity) of `x` in CPython. `a is b` is true iff `id(a) == id(b)` — same object. `a == b` calls `__eq__` and compares values. Use `is` only with singletons (`None`, `True`, `False`).

CPython caches small integers (-5 to 256) and short, identifier-like strings in interpreter-wide tables so that equal values share the same object. This is why `a is b` can surprisingly return True for small ints — but it is an implementation detail you must never rely on for correctness; use `==` for values, `is` only for singletons.

a = 256; b = 256; a is b   # True (cached)
a = 257; b = 257; a is b   # False (usually)

`_name` = 'weak private' — convention saying 'internal, don't touch'. `__name` (two leading) = name-mangled to `_ClassName__name` to avoid collisions in subclasses. `__name__` (dunder) = reserved for Python's special protocol (e.g., `__init__`, `__str__`). Lone `_` = throwaway variable; in the REPL, it also holds the last result.

for _ in range(3): print('hi')
a, _, b = (1, 2, 3)   # ignore middle

A docstring is the first string literal inside a module, class, or function — it becomes the object's `__doc__` attribute and is accessible at runtime via `help()`. A comment (`# ...`) is stripped by the parser and exists only in source. Use docstrings for API documentation, comments for implementation notes.

def greet(name):
    """Return a friendly greeting for `name`."""
    return f'Hi, {name}!'
greet.__doc__   # the docstring

`False`, `None`, `0`, `0.0`, `0j`, empty containers (`''`, `[]`, `()`, `{}`, `set()`, `range(0)`), and instances whose class defines `__bool__()` returning False (or `__len__()` returning 0). Everything else is truthy. Idiomatic Python uses `if items:` rather than `if len(items) > 0:`.

Added in 3.8 (PEP 572), `:=` is an assignment expression — assigns a value and returns it inline. Useful to compute once and reuse in a `while` test or comprehension filter, replacing duplicated calls or pre-loop reads.

while (line := f.readline()):
    process(line)

[y for x in data if (y := f(x)) is not None]

Type hints (PEP 484, 526) declare expected types on function parameters, returns, and variables. They are NOT enforced at runtime — they live in `__annotations__` and are consumed by static checkers (mypy, pyright) and editors for autocomplete and bug detection. The `typing` module provides `Optional`, `Union`, `List`, `Dict`, `Callable`, `Protocol`, etc. Python 3.9+ allows `list[int]` directly; 3.10+ supports `X | Y` for union.

from typing import Optional
def parse(s: str) -> Optional[int]:
    try: return int(s)
    except ValueError: return None

Multi-line strings use triple quotes `"""..."""` (or `'''...'''`). Python has no real multi-line comment syntax — by convention you either prefix each line with `#`, or place a triple-quoted string literal whose value is ignored, but only at positions where a statement is legal.

Unpacking assigns each element of an iterable to its own name in one statement. Starred `*name` collects the leftovers into a list. Works in function signatures, `for` loops, and assignments.

a, b, c = (1, 2, 3)
first, *middle, last = [1, 2, 3, 4, 5]   # 1, [2,3,4], 5
for k, v in d.items(): ...

Three idiomatic ways: `{**a, **b}` (3.5+, returns a new dict, later keys win), `a | b` (3.9+, returns a new dict), or `a.update(b)` (mutates `a` in place). For deep merges (nested dicts), write a recursive helper — none of these do that for you.

a = {'x': 1, 'y': 2}
b = {'y': 9, 'z': 3}
{**a, **b}    # {'x': 1, 'y': 9, 'z': 3}
a | b          # same, Python 3.9+

A class is a blueprint for creating objects. Attributes are data bound to a class or instance (state); methods are functions defined inside the class that operate on that state. Class attributes are shared by all instances; instance attributes belong to one object and are normally set in `__init__`.

class Dog:
    species = 'Canis familiaris'   # class attribute
    def __init__(self, name):
        self.name = name              # instance attribute
    def bark(self):                    # method
        return f'{self.name} says woof'

`self` is the conventional name for the instance passed to a method. It's explicit because: (1) the Zen of Python prefers explicit over implicit, (2) it makes method-vs-function distinction syntactically clear, and (3) it lets you call methods as unbound functions when needed (`Klass.method(obj)`). Any name works, but using anything other than `self` is non-idiomatic.

Inheritance lets a subclass reuse and extend a parent class. Python supports single, multiple, multi-level, and hierarchical inheritance. Use `super()` to invoke the parent's method during overriding.

class Animal:
    def __init__(self, name): self.name = name
    def speak(self): return '...'

class Dog(Animal):
    def speak(self): return f'{self.name} barks'

Dog('Rex').speak()   # 'Rex barks'

Polymorphism = same interface, different behavior. Python achieves it via duck typing (objects with the right methods just work) and method overriding. Built-in example: `len()` works on any object that defines `__len__()` — strings, lists, dicts, sets, custom classes.

class Square:
    def area(self): return self.s ** 2
class Circle:
    def area(self): return 3.14 * self.r ** 2
for shape in shapes: print(shape.area())   # works for any 'shape'

Python has no truly private attributes. By convention: `name` = public, `_name` = 'protected, don't touch from outside', `__name` = name-mangled to `_ClassName__name` to avoid accidental override in subclasses. Encapsulation is enforced by convention and `@property` accessors, not by the language.

class Account:
    def __init__(self, bal):
        self._balance = bal      # 'protected'
    @property
    def balance(self): return self._balance

Not by signature like Java/C++ — defining the same method twice simply replaces the first. Instead Python uses default arguments, `*args`/`**kwargs`, or `functools.singledispatch` for type-based dispatch. You can simulate overloading by branching on argument types or counts inside one function.

from functools import singledispatch
@singledispatch
def area(shape): raise TypeError
@area.register
def _(s: int): return s * s          # square side
@area.register
def _(s: tuple): return s[0] * s[1]   # rectangle

When a subclass defines a method with the same name as one in its parent, the subclass version overrides it for instances of that subclass. Use `super().method()` to also invoke the parent's behavior — common in `__init__` chains.

Modifying or extending a class or module at runtime by reassigning its attributes from the outside. Useful in tests for stubbing out third-party functions and in libraries that need to patch behavior. Risky in production: silent, hard to debug, and tightly coupled to internals — prefer dependency injection or `unittest.mock`.

import requests
orig_get = requests.get
requests.get = lambda *a, **k: 'mocked'   # monkey patch
try:
    ...
finally:
    requests.get = orig_get

A singleton is a class that has exactly one instance. The cleanest Python implementations: a module (modules are already singletons), a class with `__new__` that caches, or a `@singleton` decorator. Be cautious — singletons are global state in disguise and complicate testing.

class Settings:
    _inst = None
    def __new__(cls):
        if cls._inst is None:
            cls._inst = super().__new__(cls)
        return cls._inst

A metaclass is 'the class of a class' — it controls how classes themselves are created, just as classes control how instances are created. The default metaclass is `type`. Subclass `type` and pass `metaclass=` in the class statement to customize. Used by ORMs (Django models), validators, and ABCs. The maxim: 'if you have to ask whether you need a metaclass, you don't.'

class Meta(type):
    def __new__(mcs, name, bases, ns):
        ns['created_by'] = 'Meta'
        return super().__new__(mcs, name, bases, ns)
class Foo(metaclass=Meta): pass
Foo.created_by   # 'Meta'

Class variables are defined inside the class body and shared by every instance. Instance variables are set on `self` (usually in `__init__`) and belong to that one object. Watch out: assigning to a class variable through `self` creates an instance shadow, not an update — and using a mutable class variable as default state is a common bug.

class Cart:
    items = []          # SHARED — bug!
    def __init__(self):
        self.items = []   # per-instance — correct

Implement the corresponding dunder methods. `__add__` for `+`, `__sub__` for `-`, `__mul__`/`__rmul__`, `__eq__`/`__lt__` for comparisons, `__getitem__` for `[]`, `__call__` for `()`, `__len__` for `len()`, `__iter__` for `for`, `__contains__` for `in`. Provide `__hash__` whenever you define `__eq__` if instances need to be set/dict keys.

class Vector:
    def __init__(self, x, y): self.x, self.y = x, y
    def __add__(self, o): return Vector(self.x + o.x, self.y + o.y)
    def __repr__(self):    return f'Vector({self.x}, {self.y})'

Python only allows one `__init__`. Idiom: keep `__init__` minimal and provide alternative constructors as `@classmethod` factories — `Date.from_iso(...)`, `Date.from_timestamp(...)`. Each returns `cls(...)` so subclasses get the right type.

class Date:
    def __init__(self, y, m, d): self.y, self.m, self.d = y, m, d
    @classmethod
    def from_iso(cls, s):  return cls(*map(int, s.split('-')))
    @classmethod
    def today(cls):
        from datetime import date
        t = date.today(); return cls(t.year, t.month, t.day)

`@dataclasses.dataclass` (3.7+) auto-generates `__init__`, `__repr__`, `__eq__` (and optionally `__hash__`, `__lt__`, etc.) from class-level type-annotated attributes. Eliminates boilerplate for plain-data containers. Pass `frozen=True` for an immutable dataclass.

from dataclasses import dataclass
@dataclass(frozen=True)
class Point:
    x: int
    y: int
p = Point(1, 2); p.x   # 1

`namedtuple` (from `collections`) creates an immutable tuple subclass with named fields — lightweight, indexable, tuple-equal, supports unpacking. `@dataclass` creates a regular mutable class with named fields — adds methods, supports defaults, type hints, and `field(...)` customization. Use namedtuple for tiny immutable records; dataclass when you want mutation, methods, or default-factory fields.

A descriptor is any class implementing `__get__`, `__set__`, and/or `__delete__`. When such an object lives on a class and you access it via an instance, Python invokes those methods instead of returning the descriptor itself. `@property`, `@classmethod`, `@staticmethod`, and ORM fields all use the descriptor protocol under the hood. Distinguishes data descriptors (with `__set__`) from non-data (only `__get__`) for attribute lookup priority.

class Positive:
    def __set_name__(self, owner, name): self.name = '_' + name
    def __get__(self, obj, owner): return getattr(obj, self.name)
    def __set__(self, obj, value):
        if value < 0: raise ValueError
        setattr(obj, self.name, value)
class Account:
    balance = Positive()

A mixin is a small class that provides reusable methods to be 'mixed into' other classes via multiple inheritance. It's not meant to be instantiated on its own and typically has no `__init__`. Example: `JsonSerializableMixin`, `LoggingMixin`. Mixins should be designed cooperatively (use `super()`) so MRO works cleanly.

class JsonMixin:
    def to_json(self): import json; return json.dumps(self.__dict__)
class User(JsonMixin):
    def __init__(self, name): self.name = name
User('Ada').to_json()

Abstraction = hiding *complexity* — exposing only the essential interface (what an object does). Encapsulation = hiding *internal state* — bundling data with the methods that operate on it and restricting direct access. ABCs / interfaces enable abstraction; `_private` + properties enable encapsulation. They reinforce each other but are not the same idea.

If class D inherits from B and C, both of which inherit from A, the question is: when calling D's method, which A is in play? Python's C3 linearization (the MRO) produces a deterministic order — each class appears before its parents, and the order in the bases list is preserved. `super()` follows the MRO, so cooperative `super().__init__()` chains call A exactly once.

Use a `pass` body, or a docstring, or `...`. Empty classes can be useful as namespaces, sentinels, or quick attribute bags.

class Empty:
    pass

class Sentinel: ...

class Config:
    """Bag of attributes."""

`__getattribute__` is invoked on EVERY attribute access — easy to break the class if you override it incorrectly (infinite recursion is the classic trap; call `super().__getattribute__(name)`). `__getattr__` is the fallback that runs only when normal lookup fails — much safer place to add dynamic attributes or proxy behavior.

class Proxy:
    def __init__(self, target): self._t = target
    def __getattr__(self, name):   # only on miss
        return getattr(self._t, name)

Neither, strictly — Python is 'pass-by-object-reference' (sometimes called pass-by-assignment). The function receives a new local name bound to the same object. Mutating the object inside (e.g., `lst.append(x)`) is visible outside; rebinding the local (`lst = [...]`) is not.

def f(lst, n):
    lst.append(99)   # caller sees this
    n = 42           # caller does NOT see this

Names assigned inside a function are local by default. `global x` tells Python the name refers to the module-level `x` (assignments go there). `nonlocal x` (3.0+) targets the nearest enclosing function scope — used inside closures to mutate a captured name.

count = 0
def inc():
    global count
    count += 1

def counter():
    n = 0
    def step():
        nonlocal n
        n += 1
        return n
    return step

A higher-order function takes a function as argument and/or returns a function. Built-ins: `map`, `filter`, `sorted(..., key=...)`, `min`/`max(..., key=...)`, `functools.reduce`. Decorators are also higher-order functions.

sorted(words, key=str.lower)
list(map(str.upper, words))
list(filter(str.isalpha, tokens))

`map(fn, iter)` applies `fn` to each item, producing an iterator of results. `filter(pred, iter)` keeps items where `pred(item)` is truthy. `reduce(fn, iter, init)` (in `functools`) folds the iterable into a single value by repeated application. List comprehensions and generator expressions are usually clearer than `map`/`filter` in Python.

list(map(lambda x: x*x, [1,2,3]))        # [1,4,9]
list(filter(lambda x: x>1, [1,2,3]))      # [2,3]
from functools import reduce
reduce(lambda a,b: a+b, [1,2,3,4], 0)     # 10

`zip(*iters)` pairs items position-wise into tuples, stopping at the shortest. `zip_longest` (in `itertools`) fills with a default. `enumerate(iter, start=0)` yields `(index, item)` pairs — the Pythonic alternative to `range(len(...))`.

for i, name in enumerate(names, 1):
    print(i, name)

list(zip([1, 2], ['a', 'b']))   # [(1, 'a'), (2, 'b')]

Default arguments are evaluated ONCE, at function-definition time. A mutable default (list, dict, set) is shared across every call. Fix: use `None` and create a fresh container inside.

def buggy(item, bag=[]):       # BAD
    bag.append(item)
    return bag
buggy(1); buggy(2)   # [1, 2] — surprise!

def fixed(item, bag=None):
    if bag is None: bag = []
    bag.append(item)
    return bag

Closures capture variables by reference, not by value — when the inner function runs, it looks up the current value of the captured name. Inside a loop this often surprises people: every closure sees the loop variable's final value. Fix by capturing the value as a default argument: `lambda x=x: ...`

fs = [lambda: i for i in range(3)]
[f() for f in fs]   # [2, 2, 2] — all see final i

fs = [lambda x=i: x for i in range(3)]
[f() for f in fs]   # [0, 1, 2] — fixed

Recursion = a function calling itself, with a base case to stop. Python sets `sys.getrecursionlimit()` to ~1000 by default to prevent runaway recursion blowing the C stack. Raise with `sys.setrecursionlimit(N)` — but heavy recursion in Python is slow; iterative or `functools.lru_cache` solutions usually win.

import sys; sys.getrecursionlimit()   # 1000
sys.setrecursionlimit(10_000)

`partial(fn, *args, **kwargs)` returns a new callable with some arguments pre-filled. Useful to adapt a function's signature for callbacks or `key=` parameters without writing a lambda.

from functools import partial
int2 = partial(int, base=2)
int2('1010')        # 10

A decorator with arguments is a 3-level function: outer accepts the args, middle accepts the function, inner is the wrapper. The outer is called first to produce the actual decorator.

from functools import wraps
def retry(times):
    def deco(fn):
        @wraps(fn)
        def wrap(*a, **kw):
            for _ in range(times - 1):
                try: return fn(*a, **kw)
                except Exception: pass
            return fn(*a, **kw)
        return wrap
    return deco

@retry(times=3)
def flaky(): ...

Yes — any callable can decorate. A class decorator stores the wrapped function in `__init__` and acts as the wrapper via `__call__`. Useful when you need stateful decoration (counters, registries) without nested closures.

class Counter:
    def __init__(self, fn):
        self.fn = fn; self.calls = 0
    def __call__(self, *a, **kw):
        self.calls += 1
        return self.fn(*a, **kw)

@Counter
def hi(): print('hi')
hi(); hi(); hi.calls   # 2

Decorators apply bottom-up: the one closest to `def` runs first, then the next outward wraps the result. Calling the final function runs them in the reverse (top-down) order.

@A   # applied last → runs first on call
@B
@C   # applied first → innermost
def f(): ...
# Equivalent to: f = A(B(C(f)))

A list comprehension builds a list from an iterable in a single expression: `[expr for x in iter if cond]`. Faster and clearer than a manual loop with `append`. Avoid them when the body has side effects or grows past one line of logic.

[x*x for x in range(10) if x % 2 == 0]   # [0, 4, 16, 36, 64]

`{key_expr: val_expr for x in iter if cond}` — same shape as list comp but with `:` instead of comma.

{w: len(w) for w in ['a', 'bb', 'ccc']}   # {'a': 1, 'bb': 2, 'ccc': 3}
{v: k for k, v in d.items()}                # invert a dict

`{expr for x in iter if cond}` — same as list comp but with curly braces and no key:value.

{w.lower() for w in words}   # unique lowercased

Same syntax with `( )` instead of `[ ]`. A list comp builds the full list eagerly (O(n) memory). A genexp yields lazily (O(1) memory) — perfect for streaming, large data, or feeding into reducers like `sum`, `any`, `max`. If you need indexing, slicing, or repeated iteration, you need a list.

sum(x*x for x in range(10**8))   # genexp — constant memory
[x*x for x in range(10**8)]      # list — likely OOM

`.send(value)` resumes a paused generator and makes its `yield` expression evaluate to `value` instead of None. `.throw(exc)` raises the exception inside the generator at its yield point — used to signal it to clean up or change state. These are the foundation of pre-asyncio coroutines.

def echo():
    while True:
        msg = yield
        print('got:', msg)
g = echo(); next(g); g.send('hi')   # got: hi

`StopIteration` signals the end of an iterator — `next()` raises it when there is nothing more to yield, and `for` loops catch it silently. In a generator function, `return` (or running off the end) raises `StopIteration`. Returning a value from a generator stores it on the exception (`e.value`).

`iter(obj)` returns an iterator — it calls `obj.__iter__()`. `next(it)` advances it — it calls `it.__next__()`. `next(it, default)` returns `default` instead of raising `StopIteration`. The two-argument `iter(callable, sentinel)` form keeps calling `callable()` until it returns `sentinel`.

with open('log') as f:
    for line in iter(f.readline, ''):   # read until EOF
        process(line)

Implement `__iter__` (returns self) and `__next__` (returns next value or raises `StopIteration`). A generator is almost always shorter — but custom iterator classes shine when you need extra methods or rich internal state.

class Counter:
    def __init__(self, n): self.i, self.n = 0, n
    def __iter__(self): return self
    def __next__(self):
        if self.i >= self.n: raise StopIteration
        self.i += 1; return self.i

`permutations(iter, r)` yields every ordered arrangement of r items — n! / (n-r)!. `combinations(iter, r)` yields every unordered selection — n choose r. `combinations_with_replacement` allows repeats. All are lazy iterators.

from itertools import permutations, combinations
list(permutations([1, 2, 3], 2))   # [(1,2),(1,3),(2,1),(2,3),(3,1),(3,2)]
list(combinations([1, 2, 3], 2))   # [(1,2),(1,3),(2,3)]

`all(iter)` is True iff every item is truthy (vacuously True on an empty iterable). `any(iter)` is True iff at least one item is truthy (False on empty). Both short-circuit — they stop as soon as the answer is known.

all(x > 0 for x in nums)
any(s.startswith('!') for s in lines)

Some objects with circular references or module-level cleanup ordering issues may not be reclaimed — the interpreter relies on the OS to free that memory at process exit. Other reasons: C-extension globals, the small-object allocator's arenas, and objects held by `atexit` handlers. For long-running services, tracking real leaks needs `tracemalloc` or `objgraph`, not exit-time inspection.

`gc` exposes Python's cyclic garbage collector — the one that catches reference cycles refcounting can't. APIs: `gc.collect()` to force a run, `gc.disable()/enable()`, `gc.get_threshold()` / `set_threshold()` for generational tuning, `gc.get_objects()` for inspection. Disabling can speed up tight allocation loops; tuning helps long-running servers.

import gc
gc.collect()                # force a cycle collection
gc.set_threshold(700, 10, 10)

A weak reference points to an object without preventing it from being garbage-collected. Useful for caches, observer patterns, and breaking reference cycles. When the target is freed, the weakref becomes `None`.

import weakref
class Big: ...
obj = Big(); r = weakref.ref(obj)
r()        # <Big object>
del obj
r()        # None — gc'd

Time: `cProfile` for function-level breakdown, `timeit` for micro-benchmarks, `pyinstrument` for flamegraphs, `line_profiler` for line-by-line, `Scalene` for combined CPU+memory. Memory: `tracemalloc` (stdlib) or `memory_profiler`. Always profile before optimizing — intuition about Python performance is usually wrong.

import cProfile
cProfile.run('main()', sort='cumulative')

It reports the size of the object itself, NOT the objects it references. A list of strings reports its own array overhead, not the strings inside. Use `pympler.asizeof` for deep size accounting.

import sys
sys.getsizeof([])         # 56 (empty list overhead)
sys.getsizeof([1, 2, 3])  # 88 — but doesn't count the ints

Root: `BaseException` → `Exception` (catch this in `except:`, never `BaseException`) → standard categories like `ArithmeticError`, `LookupError`, `OSError`. `BaseException` also covers `SystemExit`, `KeyboardInterrupt`, and `GeneratorExit` — exceptions you generally do NOT want to catch with a bare `except:`.

`raise X` raises a new exception. `raise X from Y` does the same but explicitly sets `X.__cause__` to `Y`, producing a clean chained traceback ('The above exception was the direct cause of...'). Use it when translating a low-level error into a domain-specific one.

try:
    int(s)
except ValueError as e:
    raise InvalidInput(f'bad: {s}') from e

`assert expr [, message]` raises `AssertionError` if `expr` is falsy. Use it for invariants and developer-time sanity checks — never for user-facing input validation, because asserts are stripped when Python is run with `-O` (optimize). For validation, raise `ValueError` / `TypeError` explicitly.

def divide(a, b):
    assert b != 0, 'b must be non-zero'   # dev check
    return a / b

Use a tuple of exception classes: `except (TypeError, ValueError) as e:`. You can chain `except` blocks; the first matching one runs. Python 3.11 added `except*` for exception groups (PEP 654) used by asyncio's `gather`.

try:
    int(s)
except (TypeError, ValueError) as e:
    log.warning(e)

`finally` runs ALWAYS — even if the `try` block returned, raised, or `continue`'d. Use for cleanup that must happen no matter what (closing handles, releasing locks). `else` runs only if no exception was raised in `try` — use it to scope the success path tightly so it isn't accidentally caught by `except`.

When you import a module, CPython compiles the source to bytecode and caches it as a `.pyc` file in `__pycache__/`. On subsequent imports, if the source hasn't changed (mtime check), the cached bytecode is loaded directly — skipping the parse step. Safe to delete; will be regenerated.

An environment variable listing additional directories Python searches for modules, prepended to `sys.path` at startup. Setting it lets you import code outside the current directory or installed packages. In modern projects, installing your package (`pip install -e .`) is preferred over manipulating `PYTHONPATH`.

A module is a single `.py` file. A package is a directory containing an `__init__.py` (or treated as a namespace package since 3.3) that groups related modules. Packages can be nested, forming dotted import paths like `mypkg.submod.thing`.

A package split across multiple directories — no `__init__.py` required. Python collects all matching paths from `sys.path` and merges them into one logical package. Used by plugin ecosystems (e.g., `zope.*`) where multiple distributions contribute submodules to the same top-level name.

The standard library's import machinery exposed as a module. `importlib.import_module('a.b')` imports by a string name (useful for plugins, config-driven dispatch). `importlib.reload(mod)` re-imports a module after editing — handy in notebooks and REPLs.

import importlib
mod = importlib.import_module(cfg['driver'])

`pip` installs Python packages from PyPI into the active Python environment. `conda` is a cross-language package + environment manager from Anaconda — handles non-Python binaries (CUDA, BLAS, R) and creates isolated environments without needing `venv`. Modern alternative: `uv` (very fast pip replacement) and `poetry` (deps + venv + publishing).

`requirements.txt` is a flat list of dependencies for `pip install -r` — for apps, not for libraries. `setup.py` was the historical way to declare package metadata (executable Python). `pyproject.toml` (PEP 517/518/621) is the modern declarative replacement — works with any build backend (setuptools, hatch, poetry, flit). New projects should use `pyproject.toml` alone.

A `Lock` is a mutex — only one thread can hold it at a time. Use it to guard a critical section that mutates shared state, preventing races. Prefer `with lock:` over manual acquire/release so the lock is freed even on exceptions. `RLock` allows the same thread to re-acquire; `Semaphore` allows N holders.

import threading
lock = threading.Lock()
with lock:
    shared.append(x)

Both provide a uniform `submit` / `map` API for parallel work. `ThreadPoolExecutor` shares memory and is ideal for I/O-bound tasks (sockets, files). `ProcessPoolExecutor` spawns processes — true CPU parallelism, but objects must be picklable and there's serialization overhead. Workers are reused, unlike raw `threading.Thread` / `multiprocessing.Process`.

from concurrent.futures import ThreadPoolExecutor
with ThreadPoolExecutor(8) as ex:
    results = list(ex.map(fetch, urls))

`gather(*tasks)` returns results in input order; can `return_exceptions=True` to swallow errors. `wait(...)` returns (done, pending) sets and is more flexible (`FIRST_COMPLETED`, timeouts). `as_completed(tasks)` is an iterator that yields each task as it finishes — useful for streaming results. Python 3.11 added `asyncio.TaskGroup` (PEP 654) as a structured-concurrency-friendly replacement for `gather`.

Thread-safe FIFO/LIFO/priority queues for producer-consumer patterns between threads — `Queue`, `LifoQueue`, `PriorityQueue`. `multiprocessing.Queue` is the analog for processes. `asyncio.Queue` is the awaitable version. Each pops items via `.get()` and pushes via `.put()`, with `.join()` and `.task_done()` for completion tracking.

A thread whose presence does NOT keep the program alive — when only daemon threads remain, the interpreter exits and they are killed abruptly. Set with `t.daemon = True` (before `start()`). Use for background workers like log shippers or heartbeats; never for tasks that need to clean up (they get no chance).

import threading
t = threading.Thread(target=heartbeat, daemon=True)
t.start()

Since 3.7, regular dicts preserve insertion order, so OrderedDict is rarely needed. It still offers `move_to_end(key, last=True)`, equality that respects key order, and `popitem(last=False)` to pop from the front — useful for LRU-cache-style structures.

A factory for immutable tuple subclasses with named, indexable fields. Lightweight (no `__dict__`), tuple-equal, unpackable. Replaced in many places by `@dataclass(frozen=True)` for richer features.

from collections import namedtuple
Point = namedtuple('Point', 'x y')
p = Point(1, 2); p.x, p[0]   # both 1

A double-ended queue with O(1) `append`, `pop`, `appendleft`, `popleft`. Use it whenever you need queue or sliding-window behavior — a `list.pop(0)` is O(n) but `deque.popleft()` is O(1). Also supports a maxlen for fixed-size sliding windows.

from collections import deque
q = deque(maxlen=3)
for x in [1,2,3,4]: q.append(x)
list(q)   # [2, 3, 4]

`reduce(fn, iter, init)` repeatedly applies `fn(accum, x)` left-to-right, folding the iterable into a single value. Built-ins like `sum`, `max`, `''.join` are usually clearer for the common cases. Useful when those don't fit (e.g., merging multiple dicts).

from functools import reduce
reduce(lambda a, b: {**a, **b}, list_of_dicts, {})

Provides `date`, `time`, `datetime`, `timedelta`, and `timezone` classes for date/time arithmetic. Always prefer timezone-aware `datetime` (`tz=timezone.utc`) over naive ones — naive datetimes mixed with aware ones raise `TypeError`. For richer parsing/formatting, the third-party `arrow`, `pendulum`, or `dateutil` libraries are popular.

from datetime import datetime, timezone, timedelta
now = datetime.now(timezone.utc)
tomorrow = now + timedelta(days=1)

`json.dumps(obj)` → string; `json.loads(s)` → object; `json.dump(obj, f)` / `json.load(f)` for files. JSON supports only str-keyed dicts, lists, strings, numbers, booleans, and None — custom objects need `default=...` (or `cls=`) for serialization and `object_hook=...` for deserialization.

import json
json.dumps({'a': 1, 'b': [1, 2]})
json.loads('{"a": 1}')

`pickle` serializes Python objects to bytes and back — handles cyclic refs, custom classes, etc. NEVER unpickle data from an untrusted source: a malicious pickle can execute arbitrary code on `loads`. For interchange between systems or untrusted input, use JSON, MessagePack, or Protocol Buffers.

import pickle
b = pickle.dumps(obj)
obj2 = pickle.loads(b)   # only on trusted input!

Object-oriented filesystem paths — `Path('a/b').exists()`, `p / 'subdir' / 'file.txt'`, `p.read_text()`, `p.glob('*.py')`. Modern replacement for most `os.path` string-juggling. Cross-platform: same code works on Windows and POSIX.

from pathlib import Path
root = Path(__file__).parent
for py in root.rglob('*.py'):
    print(py.relative_to(root))

Regex engine. `re.match` checks beginning, `re.search` scans anywhere, `re.findall` returns all matches, `re.sub` replaces. `re.compile(pat)` builds a reusable pattern (cheaper if used in a loop). Use raw strings `r'\d+'` to avoid double-escaping.

import re
re.findall(r'\d+', 'a1 b22 c333')   # ['1', '22', '333']
re.sub(r'\s+', ' ', '  hi   there ')   # ' hi there '

Levels (DEBUG/INFO/WARNING/ERROR/CRITICAL), per-module loggers, structured formatters, handlers that route logs to files / stdout / syslog / Sentry, and runtime-tunable verbosity. `print` is fine for scripts; any non-trivial app or library should use `logging`.

import logging
logging.basicConfig(level=logging.INFO)
log = logging.getLogger(__name__)
log.info('starting up')

Provides generic type-hint primitives: `Optional`, `Union` (now `X | Y`), `List`, `Dict`, `Tuple`, `Callable`, `Iterable`, `Any`, `TypeVar`, `Protocol` (structural typing / duck-type interfaces). Used by static checkers (mypy, pyright) — has zero runtime effect on dispatch.

from typing import Callable, Optional
def apply(f: Callable[[int], int], x: int) -> Optional[int]:
    try: return f(x)
    except Exception: return None

Standard library CLI argument parser. Declarative: define args with `add_argument`, get `--help` and type coercion for free.

import argparse
p = argparse.ArgumentParser()
p.add_argument('--name', required=True)
p.add_argument('-n', '--count', type=int, default=1)
args = p.parse_args()

Min-heap (priority queue) operations on a regular list: `heapify`, `heappush`, `heappop` — all O(log n). For a max-heap, push negated values. `heapq.nlargest(k, iter)` / `nsmallest(k, iter)` are O(n log k) — perfect for 'top K' problems.

import heapq
h = []
for x in [3, 1, 4, 1, 5]:
    heapq.heappush(h, x)
heapq.heappop(h)   # 1

Customizes per-attribute behavior in a dataclass: `default_factory` for mutable defaults (lists, dicts), `init=False` to skip from __init__, `repr=False`, `compare=False`, metadata. The mutable-default-arg trap also applies to dataclasses — `field(default_factory=list)` is the fix.

from dataclasses import dataclass, field
@dataclass
class Cart:
    items: list = field(default_factory=list)   # safe

`os` = OS-level operations (env vars, processes, filesystem ops, fork). `sys` = interpreter / runtime (argv, stdin/stdout/stderr, exit, path, modules). `pathlib` = OO path manipulation (mostly replacing `os.path`). For modern code: use `pathlib` for paths, `os.environ` for env, `sys.argv`/`sys.exit` for entrypoints.

Use `''.join(iterable)` — one allocation, O(n) total. Using `+` in a loop creates a new string every iteration (O(n²)). For two or three strings, `+` or an f-string is fine.

''.join(parts)               # best for many
'a' + 'b' + 'c'              # fine for few
f'{user}: {message}'         # best for templates

`split` / `rsplit`, `join`, `strip` / `lstrip` / `rstrip`, `lower` / `upper` / `title` / `casefold`, `startswith` / `endswith`, `find` / `rfind` (returns -1 if missing) vs `index` (raises), `replace`, `count`, `isdigit` / `isalpha` / `isalnum`, `format`, `zfill`, `partition`.

'  Hello World  '.strip().lower().split()   # ['hello', 'world']
','.join(['a', 'b', 'c'])                     # 'a,b,c'