Python FAQ

# python
a = [1, 2, 3]
b = a            # b and a name the SAME list
b.append(4)
print(a)         # [1, 2, 3, 4]  <- mutated through the other name

b = [9]          # rebinding b does NOT touch a
print(a)         # [1, 2, 3, 4]

# python
def mutate(xs): xs.append(1)     # caller sees this
def rebind(xs): xs = [1]         # caller does NOT see this

# python
a, b = 256, 256
a is b            # True  — CPython caches small ints (-5..256)
a, b = 257, 257
a is b            # often False — an implementation detail, never rely on it

# python
if items:              # good — works for list, dict, str, ...
if len(items) > 0:     # noisier, same meaning
if items is not None:  # DIFFERENT: an empty list is not None

# python
def bad(item, bucket=[]):     # ❌ the SAME list on every call
    bucket.append(item)
    return bucket

bad(1)   # [1]
bad(2)   # [1, 2]  <- surprise

def good(item, bucket=None):  # ✅ the idiom
    if bucket is None:
        bucket = []
    bucket.append(item)
    return bucket

# python
import copy

original = [[1, 2], [3, 4]]
shallow  = copy.copy(original)      # or original[:] / list(original)
deep     = copy.deepcopy(original)

shallow[0].append(99)
original     # [[1, 2, 99], [3, 4]]  <- inner lists are SHARED
deep[0].append(0)
original     # unchanged

# python
grid = [[0] * 3] * 3      # ❌ three references to ONE row
grid[0][0] = 1            # [[1,0,0], [1,0,0], [1,0,0]]

grid = [[0] * 3 for _ in range(3)]   # ✅ three distinct rows

# python
class Cart:
    items = []            # ❌ shared by every instance

class Cart:
    def __init__(self):
        self.items = []   # ✅ per instance

# python
def f(pos_only, /, standard, *args, kw_only, **kwargs):
    ...

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

fs = [lambda i=i: i for i in range(3)]  # bind now via a default
[f() for f in fs]                       # [0, 1, 2]

# python
count = 0
def bump():
    count += 1        # UnboundLocalError — `count` is local because we assign to it
def bump_ok():
    global count
    count += 1

# python
import functools, time

def timed(fn):
    @functools.wraps(fn)              # keep __name__, __doc__, signature
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        try:
            return fn(*args, **kwargs)
        finally:
            print(f"{fn.__name__} took {time.perf_counter() - start:.3f}s")
    return wrapper

@timed
def work(n): return sum(range(n))

# python
def retry(times):                      # takes the argument
    def decorator(fn):                 # takes the function
        @functools.wraps(fn)
        def wrapper(*a, **kw):
            for attempt in range(times):
                try:
                    return fn(*a, **kw)
                except Exception:
                    if attempt == times - 1:
                        raise
        return wrapper
    return decorator

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

# python
it = iter([1, 2, 3])
next(it)          # 1
list(it)          # [2, 3]
list(it)          # []   <- already exhausted

# python
def powers_of_two(limit):
    value = 1
    while value < limit:
        yield value            # suspend here, resume on next()
        value *= 2

list(powers_of_two(20))        # [1, 2, 4, 8, 16]

# python
import itertools

# A pipeline that never materialises the whole file.
# The `with` owns the file: build AND consume inside it, or the generator holds the
# descriptor open until it is garbage collected.
with open("big.log") as f:
    lines   = (line.rstrip() for line in f)
    errors  = (l for l in lines if "ERROR" in l)
    first10 = list(itertools.islice(errors, 10))

# python
new   = [expr(i) for i in old if keep(i)]        # list
uniq  = {expr(i) for i in old}                   # set
index = {k: v for k, v in pairs}                 # dict
lazy  = (expr(i) for i in old)                   # generator
flat  = [c for row in grid for c in row]         # nested: outer loop first

# python
class Circle:
    tau = 6.283185                       # class attribute (shared)

    def __init__(self, r):
        self.r = r                       # instance attribute

    def area(self):                      # instance method — gets self
        return self.tau / 2 * self.r ** 2

    @classmethod
    def unit(cls):                       # gets the class — alternative constructor
        return cls(1)

    @staticmethod
    def describe():                      # plain function in the class namespace
        return "a round thing"

    @property
    def diameter(self):                  # computed attribute, no parentheses
        return 2 * self.r

    @diameter.setter
    def diameter(self, d):
        self.r = d / 2

# python
class A: ...
class B(A): ...
class C(A): ...
class D(B, C): ...
D.__mro__     # D -> B -> C -> A -> object

# python
from abc import ABC, abstractmethod

class Repository(ABC):                 # nominal: subclasses must inherit
    @abstractmethod
    def get(self, key): ...

from typing import Protocol

class Closeable(Protocol):             # structural: anything with close() matches
    def close(self) -> None: ...

# python
from dataclasses import dataclass, field

@dataclass(frozen=True, slots=True)    # frozen -> no reassignment + generated __hash__
class Point:
    x: int
    y: int
    tags: tuple[str, ...] = ()         # a list field would make __hash__ raise TypeError

@dataclass                             # mutable: a list default MUST use default_factory
class Cart:
    items: list[str] = field(default_factory=list)   # never `= []`

# python
with open("data.txt") as f:      # __exit__ closes f, exception or not
    process(f)

from contextlib import contextmanager

@contextmanager
def timing(label):
    start = time.perf_counter()
    try:
        yield                    # the body of the `with` runs here
    finally:
        print(label, time.perf_counter() - start)

# python
try:                       # ✅ EAFP
    value = cache[key]
except KeyError:
    value = compute(key)

if key in cache:           # LBYL — two lookups, and racy under concurrency
    value = cache[key]

# python
try:
    risky()
except (ValueError, TypeError) as e:   # narrow, grouped
    log.warning("bad input: %s", e)
    raise BusinessError("...") from e  # chain: keeps the original traceback
except Exception:
    raise                              # re-raise unchanged
else:
    commit()                           # runs only if NO exception
finally:
    release()                          # always runs

# python
import sys, gc
sys.getrefcount(obj)     # +1 for the temporary argument reference
gc.collect()             # force a cycle collection
gc.get_referrers(obj)    # who is keeping this alive?

# python
from typing import Iterable, TypeVar

def head(xs: list[int]) -> int | None:        # `Optional[int]` before 3.10
    return xs[0] if xs else None

T = TypeVar("T")
def first(xs: Iterable[T]) -> T | None: ...   # generic, preserves the element type

# python
from collections import defaultdict

richer = [[1, 0], [2, 1], [3, 1], [3, 7], [4, 3], [5, 3], [6, 3]]
richer_than = defaultdict(list)
for person, other in richer:
    richer_than[person].append(other)
# defaultdict(list, {1: [0], 2: [1], 3: [1, 7], 4: [3], 5: [3], 6: [3]})

# python
people.sort(key=lambda p: (-p.score, p.name))   # score desc, then name asc
sorted(words, key=len)                          # returns a new list

# python
def find_all(haystack: str, needle: str) -> list[int]:
    """Every start index where `needle` occurs, overlaps included."""
    out, i = [], haystack.find(needle)
    while i != -1:
        out.append(i)
        i = haystack.find(needle, i + 1)   # +1, not +len(needle) -> allows overlap
    return out

find_all("99023430990999", "99")           # [0, 8, 11, 12]

# python
import pytest

@pytest.fixture
def repo():
    r = Repo(":memory:")
    yield r              # setup / teardown around the yield
    r.close()

@pytest.mark.parametrize("value,expected", [(0, "zero"), (1, "one")])
def test_naming(value, expected):
    assert name(value) == expected

def test_rejects_negative(repo):
    with pytest.raises(ValueError, match="negative"):
        repo.add(-1)

[ ] Names bind objects; pass-by-object-reference; mutate vs rebind
[ ] is vs ==, and why `is None` is the only safe use
[ ] Mutable default arg, [[0]*3]*3, shallow vs deep copy
[ ] Closure late binding and the LEGB rule
[ ] Write a decorator with functools.wraps, and one that takes arguments
[ ] Iterable vs iterator; generator memory/laziness trade-off
[ ] __repr__ vs __str__; __eq__ with __hash__; MRO and cooperative super()
[ ] dataclass / NamedTuple / Enum: which and why
[ ] Context manager both ways (class and @contextmanager)
[ ] EAFP, exception chaining, never bare except
[ ] Refcounting + cycle GC; where leaks actually come from
[ ] collections / heapq / bisect / itertools / functools by heart
[ ] Timsort is stable; sort keys and tuple keys
[ ] Big-O of list vs set vs deque operations