Python for backend, automation, and data roles, including the runtime behaviour that surprises candidates who only know the syntax.
22 published across 7 topics.
Data model, mutability, scoping, comprehensions, and the truthiness and copying gotchas.
Python closures capture variables, not their current values, so functions created in a loop all read the same final loop binding unless you bind a value per iteration. It also connects scoping to the point an interviewer is testing.
Because `is` compares identity while `==` compares value, and CPython reuses objects for small integers and for compile-time string constants. The agreement is an implementation detail of the interpreter you happen to be running, so code that relies on it works until the values change. It also connects interning to the point an interviewer is testing.
Python mutable default arguments are evaluated once when def runs, so omitted calls share the same list or dict stored in the function's __defaults__. It also connects mutability to the point an interviewer is testing.
Dunder methods, MRO and multiple inheritance, descriptors, dataclasses, and properties.
Use a Python ABC when you need nominal inheritance and runtime instantiation checks; use a Protocol when a type checker should accept any object with the required methods, even without inheritance. Use this abstract base classes answer to show the decision, trade-off, and evidence rather than a memorised definition. It also connects protocols to the point an interviewer is testing.
Implement the dunders that opt your type into a protocol, treating repr, eq and hash as one decision, and let a dataclass generate the boilerplate when the fields are the identity. super() follows the C3 linearisation of type(self), so it calls the next class in the MRO rather than your own base.
A Python descriptor implements __get__, and optionally __set__ or __delete__, to control attribute access; @property is a data descriptor that wins over the instance dictionary.
Closures, laziness, context managers, and writing composable higher-order utilities.
A try/finally around the yield. @contextmanager throws the body's exception into the generator at the yield, so a release written after the yield is skipped. Wrap the yield in try/finally, or use with lock inside it, and re-raise anything you catch, or the generator suppresses the caller's error.
Decoration runs once, at definition time, so it happens on import rather than on call. Stacked decorators apply bottom-up and execute outermost-first, and each wrapper replaces the function's identity unless functools.wraps restores it, which is what breaks introspection and framework registration.
A generator produces items on demand and keeps only the current item plus its suspended frame, so memory stays flat as the input grows; it is the wrong tool when you need a length, indexing, or more than one pass, and when per-item resume overhead outweighs the space saved.
Threads versus processes versus asyncio, what the GIL actually blocks, and choosing per workload.
A timeout requests cancellation; it does not stop code. CancelledError is raised at the task next await point, so a task inside blocking code, shielded, in an executor thread, or swallowing the exception keeps running and commits its side effects late. Fix by re-raising CancelledError, keeping blocking calls off the loop, and using asyncio.timeout with a TaskGroup.
The Python GIL serializes CPython bytecode execution, but threads still help I/O-bound work; choose processes for pure Python CPU work and asyncio for many concurrent waits.
Python multiprocessing behaves differently across platforms because fork inherits parent memory while spawn starts a fresh interpreter, re-imports the module and requires picklable callables and arguments. It also connects start methods to the point an interviewer is testing.
With gather they keep running unsupervised and their failures may surface as an unretrieved-exception warning. A TaskGroup, added in Python 3.11, cancels the siblings, waits for them to finish unwinding, and raises an ExceptionGroup you handle with except*.
Reference counting, garbage collection, profiling, and where interpreter overhead dominates.
The cache lives on the class-level function and its keys include self, so every instance the method touches stays strongly referenced and is never collected; with maxsize=None or functools.cache that memory leak is unbounded. Cache per instance with cached_property or an instance dict, or cache plain values.
Into per-object overhead: in CPython on a 64-bit build every object carries a 16-byte header, every field is itself a boxed object reached through an 8-byte pointer, and each instance has a dictionary. Slots remove the dictionary, and a columnar layout removes the objects. Use this memory layout answer to show the decision, trade-off, and evidence rather than a memorised definition.
CPython frees an object the instant its reference count reaches zero, so steady growth is usually something still holding a reference rather than a leak. The cycle collector reclaims only reference cycles. Measure with tracemalloc first, then use __slots__ or generators to cut per-object and peak cost.
ORM behaviour and N+1, middleware, dependency injection, async endpoints, and validation.
Production runs several worker processes, and each has its own interpreter, its own imported modules and therefore its own copy of that dictionary. Requests land on whichever worker is free, so a write in one is invisible to the others and every restart discards the lot. Use this wsgi asgi answer to show the decision, trade-off, and evidence rather than a memorised definition.
An N+1 happens when the ORM follows a relation lazily once per row; select_related fixes forward foreign keys with a SQL join, prefetch_related issues one extra query per relation and joins in Python. An async endpoint gets slower when it contains a blocking call, because that stalls the whole event loop.
The job was enqueued inside an open transaction, so the row was invisible to the worker's connection until commit, and a fast worker won the race. Register the side effect with transaction.on_commit so it fires after the outermost atomic block commits, and never if it rolls back.
pytest fixtures and parametrisation, mocking and patching boundaries, and coverage honestly read.
A mock encodes your belief about the collaborator, so asserting against it proves the code matches your belief rather than reality. Use autospec so signatures are checked, and put a small number of tests against the real engine at the boundary the mock replaced. Use this mocking answer to show the decision, trade-off, and evidence rather than a memorised definition.
A patch must replace the name in the module under test, because a from-import binds its own reference that the original module never consults again. Fixture scope is a shared lifetime, parametrisation belongs on the inputs rather than the assertions, and coverage records execution, not verification.
Make it reproducible before you make it pass. Pin the ordering seed, then work through the sources of non-determinism the test is exposed to - wall-clock time, global random state, hash-dependent iteration, real network calls and shared resources - and inject each one so the test controls it.