Python · Intermediate interview

An iterable is anything you can loop over — it implements __iter__ and returns an iterator (lists, dicts, strings). An iterator is the object that actually produces values one at a time via __next__, raising StopIteration when done, and is itself an iterable. So a list is iterable but not its own iterator; calling iter() on it gives you one.

A generator function uses yield to produce values lazily: calling it returns a generator object, and each next() runs the function until the next yield, suspending its state in between. Because it produces one value at a time instead of building a whole list, it uses constant memory and can represent infinite or huge sequences — ideal for streaming large files or pipelines.

def read_lines(path):
    with open(path) as f:
        for line in f:
            yield line.strip()

Use a generator expression (parentheses instead of brackets) when you don't need the whole list at once — for example, feeding sum() or any(), or processing a large stream. It produces items lazily and uses far less memory. Use a list comprehension when you need to index, reuse, or keep the full result.

total = sum(n*n for n in range(1_000_000))  # no million-item list

A decorator is a callable that takes a function and returns a replacement, applied with @decorator syntax above the definition. It's typically used to wrap behaviour — logging, timing, caching, auth — around the original without changing its body. Inside, you define a wrapper that calls the original and add your behaviour around it.

def timed(fn):
    @functools.wraps(fn)
    def wrapper(*a, **k):
        start = time.perf_counter(); r = fn(*a, **k)
        print(time.perf_counter() - start); return r
    return wrapper

A closure is a nested function that captures and remembers variables from its enclosing scope even after that scope has returned. Reading those variables works automatically; to reassign one you declare it nonlocal, otherwise Python treats the assignment as a new local. Closures are the mechanism behind decorators and stateful factory functions.

functools.wraps copies the wrapped function's name, docstring, and metadata onto the wrapper so decorated functions still introspect correctly. functools.lru_cache memoizes a function's results keyed by its arguments, returning cached values for repeat calls — a one-line speedup for pure, expensive functions with hashable arguments. Both are staples of writing good decorators and fast code.

try holds the risky code; except handles specific exceptions; else runs only if no exception was raised (good for code that should only run on success); finally always runs, for cleanup, whether or not there was an error. Catching specific exception types rather than a bare except is important so you don't swallow bugs.

A context manager defines setup and teardown around a block via the with statement, guaranteeing cleanup even on exceptions — the classic example is with open(...) closing the file. You implement __enter__ and __exit__, or more simply write a generator decorated with @contextlib.contextmanager that yields once. It's the idiomatic way to manage resources like files, locks, and connections.

from contextlib import contextmanager
@contextmanager
def timer():
    start = time.perf_counter()
    try: yield
    finally: print(time.perf_counter() - start)

EAFP — 'easier to ask forgiveness than permission' — means try the operation and catch the exception if it fails, which is the Pythonic default. LBYL — 'look before you leap' — checks preconditions first with ifs. EAFP avoids race conditions between the check and the action and is often cleaner, e.g. try/except KeyError instead of checking 'in' first.

Dunder ('double underscore') methods let your objects hook into language syntax. __init__ initializes, __repr__/__str__ control representation, __eq__ defines equality, __len__ enables len(), __iter__ makes it iterable, __getitem__ enables indexing, and __enter__/__exit__ make it a context manager. Implementing the right ones makes your objects feel like built-ins.

If you define __eq__ so two objects can be equal, you must also define __hash__ consistently — equal objects must have equal hashes — or they'll misbehave as dict keys and set members. By default Python makes a class with a custom __eq__ unhashable unless you provide __hash__. Immutable value objects should hash on the same fields they compare.

A shallow copy (copy.copy, list slicing, dict.copy) duplicates the outer container but shares the nested objects, so mutating a nested list affects both copies. A deep copy (copy.deepcopy) recursively copies everything, fully independent but slower. You reach for deepcopy only when shared inner references would cause bugs.