Interview Questions

The Global Interpreter Lock lets only one thread execute Python bytecode at a time in CPython. Threads still help for I/O-bound work (network, disk) because the lock is released while waiting; for CPU-bound work, threads do not run in parallel — use multiprocessing (separate processes, separate GILs) or a library that releases the GIL in C, like NumPy. Python 3.13 has an experimental free-threaded build.

What they are really testing: Whether you can choose between threads, processes and asyncio for a given workload.

A function with yield returns an iterator that produces values lazily, pausing between them and keeping its local state. It uses constant memory regardless of how many items it produces, so it is how you process a file larger than RAM, stream from a database, or build pipelines of transformations. A list materialises everything up front.

A callable that takes a function and returns a replacement, usually a wrapper that adds behaviour. @timed above def f is f = timed(f). Use functools.wraps so the wrapper keeps the original's name and docstring. A minimal one: def log(fn): @wraps(fn) def w(*a, **k): print(fn.__name__); return fn(*a, **k); return w.

Parameters after a bare * are keyword-only — callers must name them, which keeps calls readable and lets you add parameters later without breaking positional callers. Parameters before / are positional-only — callers cannot name them, which lets you rename them freely. def f(a, /, b, *, c) has one of each plus a normal one.

__repr__ is the unambiguous developer representation — ideally code that recreates the object — used by the REPL, by containers, and as the fallback when __str__ is missing. __str__ is the readable user representation used by print and f-strings. Always define __repr__; define __str__ when users see the object.

It does not mean "the parent class" — it means "the next class in this object's MRO after the current one". With class C(A, B), super() inside A resolves to B, not to A's own parent. That is what makes cooperative multiple inheritance (mixins) work: each class calls super().__init__() and the chain visits every class exactly once.

Objects that define __enter__ and __exit__ for use with with: setup on entry, guaranteed cleanup on exit even if an exception is raised. Files, locks and DB transactions are context managers. The easiest way to write one is @contextlib.contextmanager on a generator: code before yield is setup, after it is cleanup.

A classmethod receives the class as its first argument (cls), so it can build instances — the alternative-constructor pattern, Date.from_iso("2026-01-01"). A staticmethod receives nothing implicit; it is a plain function namespaced in the class because it belongs there conceptually. If it needs neither self nor cls, it is a staticmethod.

A single-threaded event loop that runs coroutines (async def) and switches between them at await points — while one waits on the network, another runs. It gives high concurrency for I/O-bound work without threads. It does nothing for CPU-bound work, and a blocking call inside a coroutine (like time.sleep or requests.get) stalls the whole loop.

A class attribute listing the instance attributes allowed. It replaces the per-instance __dict__ with fixed slots, cutting memory per object substantially and speeding attribute access. Worth it when you create millions of small objects; not worth it otherwise, because it also prevents adding attributes dynamically.

Define __eq__ and __hash__ together — defining __eq__ alone sets __hash__ to None. Hash the same fields you compare. For ordering, define __lt__ and use functools.total_ordering to derive the rest. Or use @dataclass(frozen=True, order=True), which generates all of it.

is None checks identity with the one None object — always correct and fast. == None calls __eq__, which a class can override to return anything (NumPy arrays return an array of booleans, and pandas raises). PEP 8 says use is.

Measure before guessing. cProfile (python -m cProfile -s cumulative app.py) shows where the time goes by function; time.perf_counter for a specific block; line_profiler for line-level detail; tracemalloc for memory. Nine times out of ten the fix is algorithmic — an O(n²) loop, or a list where a set was needed — not micro-optimisation.

Duck typing: you use an object for what it can do, not for what class it is — anything with .read() is file-like. Type hints support it with typing.Protocol: a class that declares the methods required, which any object satisfies structurally without inheriting from it. So you get static checking without giving up the flexibility.

Timsort — a hybrid merge/insertion sort that is O(n log n) worst case and exploits existing runs in real data. Stable means equal elements keep their original relative order, which lets you sort by several keys in successive passes (least important first) or in one pass with a tuple key like (-count, name).

Name lookup order: Local, Enclosing, Global, Built-in. The classic bug: a function reads a global count and later assigns to it — the assignment makes count local for the whole function, so the earlier read raises UnboundLocalError. Fix by passing values in and returning them, or with global/nonlocal if you must.

A function that captures variables from its enclosing scope and keeps them after that scope has returned. Decorators are closures over the wrapped function; factories like make_multiplier(3) are closures over the argument. The late-binding trap: closures capture the variable, not its value at creation, so lambdas in a loop all see the final value unless bound with a default argument.

The second import is a dictionary lookup in sys.modules and returns the already-loaded module object — the file is executed only once per process. That is why module-level code is effectively a singleton, and why a circular import fails: the second module finds a partially-initialised entry in sys.modules.

Stream it: iterate the file line by line (or with csv.reader) and aggregate as you go, keeping only the running results in memory. With pandas, read_csv(chunksize=…) and combine per-chunk results. If it must be sorted or joined, use a database (sqlite3 or DuckDB) or move to Spark. The wrong answer is f.read().

threading: threads sharing memory, good for I/O-bound concurrency, limited by the GIL for CPU. multiprocessing: separate processes, true parallelism for CPU-bound work, data must be pickled between them. concurrent.futures: one high-level API (ThreadPoolExecutor/ProcessPoolExecutor) over both, with submit and map — use this one.

With pytest: a file named test_*.py, functions named test_*, plain assert statements. Fixtures provide setup; @pytest.mark.parametrize runs one test over many inputs; pytest.raises checks exceptions. Tests should be fast, independent, and test behaviour through the public interface, not implementation details.

They are the same thing — d.copy(), dict(d) and {**d} all produce a new dict with the same value objects. The nuance interviewers want: nested dicts or lists inside are shared, so mutating copy["nested"]["k"] changes the original. copy.deepcopy when the values are mutable.

Every operator and built-in function is dispatched to a dunder method on the object, so a class can participate in the language by implementing them. Example: len(x) calls x.__len__(); x + y calls x.__add__(y); for i in x calls x.__iter__(); with x calls __enter__/__exit__.

@dataclass generates __init__, __repr__, __eq__ (and optionally ordering and hashing) from annotated fields. Prefer it over a dict when the fields are known — you get attribute access, defaults, type hints and editor support. Prefer it over a namedtuple when you need mutability or methods; use frozen=True for an immutable record.

Set a timeout (there is none by default), check the status (raise_for_status), retry idempotent requests on connection errors, timeouts, 429 and 5xx with exponential backoff and a cap, reuse a Session, and log the request id from the response. Never retry a non-idempotent POST blindly.