Python Interview Questions

Python first parses source and compiles it into code objects containing bytecode and metadata. In CPython, an evaluation loop executes that bytecode and may specialize hot operations using runtime feedback. Importable modules can cache compatible bytecode in __pycache__, but that cache is an optimization, not a required execution stage. Python is therefore compiled to an intermediate form and then executed by a runtime; calling it only ‘interpreted’ hides the useful mechanism and confuses the language with CPython.

Every Python value has an identity, a type, and a value. Integers, functions, classes, modules, and user instances can all be bound to names, stored in containers, passed to functions, and inspected through their type-defined behavior. It does not mean every object is mutable or has an instance __dict__. The practical result is a uniform object model: a decorator can receive a function, a metaclass can create a class, and callable objects can participate in function-like APIs.

is asks whether two references identify the same object; == asks whether their values compare equal, normally through __eq__. Use is for singletons such as None or a deliberate sentinel. Do not use it for strings or numbers because caching and interning are implementation details and may make small examples appear to work. A class can define value equality while two equal instances remain distinct objects.

A mutable object can change while retaining its identity; lists, dictionaries, and sets are common examples. An immutable object's value cannot change after creation, so operations on strings, integers, and tuples produce another value. Rebinding a name is different from mutating an object. That distinction matters when aliases share a list, when values cross API boundaries, and when an object participates in hashing. A tuple is immutable, but it can still contain a mutable object whose own state changes.

A function call evaluates each argument and binds the resulting object to a local parameter name. Some people call this call-by-sharing. Reassigning the parameter only changes that local binding; mutating a shared mutable object is visible to the caller. Python is not pass-by-reference in the C++ sense because the function cannot rebind the caller's variable. The clean explanation follows names and objects rather than asking whether an address itself was copied.

For ordinary function code, Python looks for a name in Local, Enclosing function, Global module, then Builtins scope. Assignment makes a name local unless global or nonlocal says otherwise, which is why reading a variable before a local assignment can raise UnboundLocalError. LEGB is a useful mnemonic, not the entire execution model: class bodies, comprehensions, exception targets, closures, and dynamic attribute lookup have additional rules. Attributes such as obj.name do not use LEGB; they use the type's attribute protocol.

Parameters before / are positional-only; parameters after * are keyword-only. Positional-only parameters let an implementation rename internal parameters without breaking callers and can avoid ambiguity when a name belongs in **kwargs. Keyword-only parameters make configuration-heavy calls self-documenting and prevent accidental position swaps. *args collects extra positional arguments and **kwargs collects extra keyword arguments, but broad forwarding can hide misspellings and weaken an API contract, so use it at deliberate adapter boundaries.

Version: Positional-only syntax for Python functions is available in Python 3.8+.

A shallow copy creates a new outer object but reuses references to nested members. A deep copy recursively copies the object graph and uses a memo to handle repeated references and cycles. Deep copy is not automatically safer: it can be expensive, preserve or break sharing unexpectedly, and is inappropriate for files, locks, sockets, database sessions, or identity-bearing domain objects. Prefer explicit construction of the state that should be independent when ownership matters.

Default expressions are evaluated when the def statement executes, not on every call. A default list or dictionary is therefore one persistent object, and mutations leak into later calls. Use None or a dedicated sentinel, then create the mutable object inside the function. A shared default can be intentional for memoization, but implicit hidden state is hard to test, reset, and make thread-safe; name the cache explicitly instead.

Import first checks sys.modules. If the module is absent, the import machinery finds a spec and loader, creates a module object, places it in sys.modules before execution, then runs its top-level code. Early caching helps recursive imports but means a circular import can observe a partially initialized module. Later imports normally reuse the same object. A .pyc may avoid recompiling unchanged source, but importing still executes the module code in a fresh process.

A list is a mutable sequence with append, insert, remove, and in-place update operations. A tuple is an immutable sequence and often communicates a fixed collection or positional record. Tuples can be hashable when every element is hashable, so they may serve as dictionary keys; lists cannot. Tuples can use less memory, but choose primarily from semantics and API intent. For named domain records, a dataclass or NamedTuple is usually clearer than unexplained tuple positions.

A dictionary is a hash table. It hashes a key to probe candidate slots and uses equality to confirm a logical match when hashes collide. Lookup, insertion, and deletion are O(1) expected with well-behaved keys, while resizing and collision-heavy cases cost more. Keys must be hashable and their hash/equality state must remain stable while stored. Insertion order is a language guarantee in modern Python; exact table layout and probing are CPython implementation details.

A set stores distinct hashable elements in a hash-table structure and provides O(1) expected membership. It is ideal for deduplication, visited-state tracking, and union, intersection, and difference operations. A set does not provide a stable positional order contract, so do not use observed iteration order as output semantics. For deterministic presentation, sort at the boundary. Like dictionary keys, members must keep equality and hash behavior stable.

If a == b, hash(a) must equal hash(b); unequal objects may still collide. A custom equality method usually makes instances unhashable unless the class also supplies a compatible __hash__. Hashing mutable equality state is dangerous because the object can move logically while remaining in its old table slot. Value objects should be immutable or use stable identity semantics. dataclass settings make this choice explicit rather than guaranteeing that every dataclass is hashable.

Dictionaries preserve insertion order as a language guarantee in Python 3.7 and later. Updating an existing key does not move it; deleting and reinserting it appends it at the end. This makes deterministic iteration useful, but it does not mean a dictionary is sorted. For wire formats, signatures, snapshots, or database output, define and test the required order explicitly rather than relying on construction history accidentally staying the same.

Version: Insertion ordering became a language guarantee in Python 3.7.

A comprehension is concise when it describes one collection transformation: an expression plus a small number of filters. It creates the target collection eagerly; a generator expression is lazy. Use an ordinary loop when logic needs several branches, exception handling, logging, stateful accumulation, or comments. Comprehensions have their own scope in Python 3, and using them only for side effects is a readability smell because the constructed result is discarded.

defaultdict calls a factory when __getitem__ sees a missing key, which is useful for grouping or accumulating but can also create keys during reads. Counter is a mapping specialized for counts, with frequency operations such as most_common and multiset arithmetic. A plain dict is better when missing data is exceptional, defaults depend on context, or accidental insertion would hide a bug. The choice communicates semantics to the next reader.

Lists provide O(1) amortized append/pop at the right and O(1) indexing, but inserting or popping at the left shifts elements. deque provides O(1) appends and pops at both ends and is a natural FIFO queue, though random indexing is not its strength. heapq maintains a min-heap in a list, giving O(log n) push/pop and O(1) access to the smallest item. It is not a fully sorted container and requires a tie-breaking strategy for complex priorities.

Calling a class normally invokes its metaclass's call machinery, which uses __new__ to create or return an instance and then calls __init__ when the result is an instance of the class. __init__ must return None because construction has already happened. Override __new__ mainly for immutable subclasses, instance interning, or controlled construction; ordinary classes should usually initialize in __init__. Returning a different object from __new__ can skip the expected initializer, so it is an advanced tool with surprising lifecycle effects.

A class attribute is stored on the class and is visible to instances through attribute lookup. Assigning obj.name normally writes an instance attribute that shadows the class value for that object. A mutable class attribute is therefore shared unless each instance replaces it, which is a common bug. Descriptors can intercept this process, so the complete lookup order is richer than ‘instance then class.’ Use class attributes for genuine type-level constants or shared registries with explicit lifecycle and synchronization.

An instance method receives self and operates on instance behavior or state. A classmethod receives cls and is useful for polymorphic alternate constructors or operations that depend on the actual subclass. A staticmethod receives no automatic first argument; it is a regular function placed in the class namespace. If it does not belong to the type's public concept, a module-level function is often clearer. The choice should reveal ownership, not just avoid passing self.

Inheritance is valuable when a subtype genuinely preserves the base contract and framework hooks are designed for extension. Composition is safer when behavior varies independently, dependencies need replacement, or the base implementation would leak into callers. Python makes delegation lightweight and Protocol can describe the required behavior without a hierarchy. Multiple inheritance can be effective for cooperative mixins, but stateful base classes create MRO and initialization coupling that composition usually makes more explicit.

A class's MRO is the deterministic order Python uses to search base classes, computed with C3 linearization. super() does not simply mean ‘my parent’; it returns a proxy that continues lookup after a specified class in that MRO. Cooperative multiple inheritance works when participating methods share compatible signatures and each calls super exactly once. Hard-coding a base method can skip or duplicate another class in a diamond, so mixins should be small, stateless where possible, and explicit about their contract.

A descriptor is an object on a class whose type defines __get__, __set__, or __delete__. The attribute machinery calls those hooks to bind methods, validate fields, compute properties, or connect ORM declarations to storage. property is a data descriptor that delegates access to getter, setter, and deleter functions. Data descriptors take precedence over an instance dictionary; non-data descriptors can be shadowed. Descriptors are excellent framework infrastructure, but ordinary application code should prefer the simplest property or explicit method that communicates the contract.

@dataclass can generate __init__, __repr__, and equality from declared fields, with options for ordering, frozen instances, keyword-only fields, slots, and hashing. default_factory prevents shared mutable defaults. frozen=True blocks normal attribute assignment but does not make nested values immutable, and generated equality is only correct if field-based value semantics match the domain. Use a dataclass for transparent data ownership, not as a substitute for validation, invariants, or a stable service boundary.

Version: Dataclasses are standard in Python 3.7+; slots=True is available in Python 3.10+.

__slots__ declares managed storage for named attributes and, unless a base class already provides one or __dict__ is included, prevents an arbitrary per-instance dictionary. That can reduce memory for very large populations and catch misspelled attributes. It complicates inheritance, weak references, serialization, and tools that expect __dict__, and the exact savings are runtime-dependent. Use it after measuring object population and memory shape, not as a universal micro-optimization.

Dunder methods let a type participate in language protocols such as iteration, comparison, arithmetic, context management, representation, and calling. Implement the smallest coherent protocol and preserve user expectations: __repr__ should aid debugging, equality should be stable, and a binary operator should return NotImplemented for unsupported types so reflected dispatch can run. Special methods are generally looked up on the type, not the instance. Avoid inventing cute operator meanings that hide business actions or failure modes.

A closure is a function that retains access to names from an enclosing function after that outer call returns. The captured name is resolved when the inner function runs, not frozen automatically when it is created. That late binding is why callbacks made in a loop can all observe the loop's final value. Capture a current value with a default parameter, functools.partial, or a small factory. Use nonlocal only when shared closure state is truly part of the design.

@decorate above a function is roughly name = decorate(name) after the function object is created. A decorator can return a wrapper that adds validation, timing, caching, registration, or another policy. A wrapper should normally use functools.wraps so metadata and __wrapped__ remain useful to introspection and tools. Decorators are powerful but can hide control flow, change signatures, and create import-time side effects, so use them for stable cross-cutting contracts rather than arbitrary business logic.

@retry(attempts=3) first calls retry(attempts=3) at definition time. That factory returns the actual decorator, which receives the function and returns a wrapper. The three layers are configuration, decoration, and invocation. Keep each layer explicit, preserve metadata with wraps, and decide whether mutable configuration is shared across all calls. For async targets, the wrapper must also be async and await the function rather than returning an un-awaited coroutine.

A higher-order function accepts or returns callables. lambda creates one expression-sized anonymous function and is useful for a short key or callback. functools.partial returns a callable with selected arguments pre-bound and is often clearer than a closure used only for binding. Once behavior needs a name, branches, documentation, types, or reuse, define a normal function. The goal is to make data flow obvious, not minimize line count.

An object is callable when its type supports the call protocol, commonly by defining __call__. Functions, classes, bound methods, and such instances all satisfy callable(). A callable instance is useful when behavior needs configuration, counters, caches, or dependencies with a lifecycle. It can be easier to test than a closure because state is named. Keep the signature and thread-safety contract clear; making an object callable should clarify its primary role, not create a surprising second interface.

Function annotations describe parameters and return values for static checkers, IDEs, documentation, and frameworks. Python does not automatically reject a value because its runtime type differs. Libraries may inspect annotations and add their own validation, serialization, or dependency behavior. Evaluation semantics have changed across versions, including deferred annotation evaluation in Python 3.14, so production introspection should use supported helpers rather than assuming every annotation is already a concrete object in __annotations__.

Version: Python 3.14 changed annotation evaluation semantics through PEP 649 and PEP 749.

An iterable supports iter(obj) and can usually create an iterator. An iterator supports next(), returns itself from iter(), and raises StopIteration when exhausted. A list is reusable because each iteration creates a fresh iterator; a generator is its own iterator and is normally one-pass. APIs should document when they consume an iterable, because receiving a list and receiving an already-partially-consumed iterator can produce different operational behavior.

A function containing yield is a generator function. Calling it returns a generator without running the body. Each next() resumes execution until a yield produces a value and suspends the frame with its local state and instruction position intact. Returning ends iteration through StopIteration. This enables incremental pipelines and natural state machines, but exceptions and resource cleanup occur during consumption, which may be far from generator creation.

A generator produces values on demand, so it can lower peak Python-object memory and begin downstream work before the full input is available. A list materializes everything, enabling repeated iteration, indexing, length, sorting, and failures at construction time. Generators are not free: they keep suspended frames and referenced objects alive, can be consumed only once, and may hold resources longer. Choose from ownership and access patterns, then measure the actual memory path.

A generator pipeline is pull-based: downstream next() calls drive upstream work. Keep stages small and deterministic, bound any buffering, and decide where malformed records are rejected or recorded. Use context managers around resource ownership rather than assuming a partially consumed generator will close immediately. A synchronous generator provides natural pull backpressure within one call chain, but it does not by itself solve distributed queues, async producers, or retries.

yield from sub delegates iteration to sub and forwards values until it finishes. For generators it also handles send, throw, close, and captures the subgenerator's return value from StopIteration.value. That makes recursive traversal and generator decomposition clearer than a manual forwarding loop. Most code only needs the value-yielding behavior, but the full delegation semantics explain why it was introduced and why it is more than syntactic sugar for for x in sub: yield x.

with evaluates a context manager, calls __enter__, binds its result after as, then executes the block. __exit__ runs with exception information on every normal or exceptional exit; returning a truthy value suppresses the exception. This centralizes acquisition and release for files, locks, transactions, and temporary state. Cleanup is deterministic at the block boundary, unlike relying on object destruction, and nested ownership can be composed with contextlib.ExitStack.

@contextmanager turns a one-yield generator into a context manager: setup occurs before yield and cleanup belongs in finally after it. closing adapts an object with close() but no context protocol. ExitStack is ideal when the number of resources is dynamic; each successful acquisition registers cleanup, and release happens in reverse order. These tools clarify ownership, but do not hide transaction semantics—commit, rollback, and exception suppression should remain explicit.

At runtime, objects have types and names can be rebound to different typed objects, so Python is dynamically and strongly typed. Type hints add an optional gradual static layer used by checkers and tooling. They do not change ordinary runtime dispatch or automatically validate inputs. A production system may add boundary validation, but that is a library or application decision. Strong typing means incompatible operations fail rather than being freely coerced; it does not mean compile-time typing.

A type variable represents a type chosen consistently at a call or specialization site. list[T] says all elements share T; a function (x: T) -> T says the result preserves the input type. A bound restricts T to subtypes of one interface, while constraints choose from an enumerated set of exact alternatives. Use generics to encode relationships, not merely replace Any. Variance matters mainly when designing reusable container or callback APIs.

Version: Built-in collection generics use Python 3.9+ syntax; type-parameter syntax such as class Box[T] is Python 3.12+.

A Protocol lets a static checker accept any type with the required members, even if it never inherits from that Protocol. That formalizes duck typing and is useful for narrow dependency boundaries. An ABC uses explicit inheritance or registration and can provide shared runtime behavior, enforce abstract methods at instantiation, and support isinstance. runtime_checkable Protocol checks are intentionally limited to member presence. Choose from whether the relationship needs static compatibility, runtime identity, implementation sharing, or all three.

TypedDict tells a static checker which keys and value types a plain dictionary should contain; at runtime the value is still a dict and no validation is added. A dataclass creates a distinct runtime class with attributes, generated methods, and a place for invariants or behavior. TypedDict fits JSON-like mappings and incremental adoption; a dataclass fits owned domain data. At untrusted boundaries, parse and validate either representation explicitly.

T | None is a union containing T and the singleton type of None; Optional[T] is its older spelling. ‘Optional’ does not mean the argument can be omitted—a default value controls omission. Code must narrow the union, commonly with if value is None, before using T-specific operations. Overusing None can blur missing, invalid, and not-yet-loaded states, so domain-specific sentinels or result types may produce a clearer contract.

Version: The | union syntax is available in Python 3.10+.

A series of @overload declarations describes different input/output relationships to a type checker and is followed by one non-overloaded implementation. The decorated declarations are not runtime dispatch. Use functools.singledispatch, explicit branching, or another dispatch mechanism for runtime behavior. Overloads are justified when a union return would lose information callers need; too many variants can make an API harder to evolve and its implementation harder to prove consistent.

match/case compares a value against literal, sequence, mapping, class, and capture patterns, with optional guards. It is useful for parsers, command trees, and closed families of message shapes. A bare name captures rather than compares, cases do not fall through, and ordering matters because the first matching case wins. Pattern matching should clarify the data model; polymorphic methods or a dispatch table remain better when behavior belongs to open-ended types.

Version: Structural pattern matching is stable in Python 3.10+.

Name the minimum version, whether the feature is stable or implementation-specific, and what problem it solves. Pattern matching, modern union syntax, TaskGroup, dataclass slots, and newer generic syntax are useful only when the deployment matrix supports them. CPython's free-threaded build is officially supported but optional in 3.14; ordinary builds still use the GIL, and extension compatibility matters. Python 3.15 is pre-release at this hub's review date and should not be treated as a production baseline.

Version: Reviewed against Python 3.14 stable and the Python 3.15 pre-release schedule on 2026-08-09.

A pytest fixture supplies a test dependency by name and can compose other fixtures. yield fixtures put teardown after yield, and scope controls whether setup is repeated per function, class, module, package, or session. Fixtures are valuable when they expose an understandable resource or state boundary. Large autouse or session fixtures can hide coupling and make order-dependent tests, so default to isolated function scope and promote scope only when the cost and reset contract are clear.

Mock boundaries such as a remote client, clock, randomness source, or expensive adapter—not every internal function call. Patch the name where the code under test looks it up, which may differ from where the object was originally defined. Assert observable behavior and meaningful boundary interactions rather than implementation choreography. Use integration or contract tests to verify that mocks still resemble the real dependency, especially for SDKs and APIs that evolve independently.

Put deterministic decisions in functions or objects that receive plain values, and isolate database, network, clock, filesystem, and process effects behind narrow interfaces. Pass dependencies through constructors or functions rather than importing hidden globals. Protocol can describe the minimum static contract without requiring a framework. This reduces patching, makes failure cases controllable, and lets integration tests focus on adapters. Testability is a design signal about ownership, not a reason to add an abstraction for every line.

Configure logging once at the application boundary, use module loggers, structured fields, request or trace identifiers, and logger.exception when stack context matters. Do not build log messages eagerly or record secrets and unbounded payloads. Levels need an operational meaning, and high-volume paths may need sampling. Logs complement metrics and traces: a senior answer explains how an operator moves from an alert to affected requests and then to a causal event without guessing from free-form strings.

An import package is what Python imports; a distribution package is what an installer installs, and their names can differ. A virtual environment isolates an interpreter's installed packages from other projects. pyproject.toml declares build-system and project metadata; a lock or constraints workflow captures tested dependency resolution for applications. Reproducibility also needs a supported Python version, platform-aware artifacts, and CI that builds from a clean environment—venv alone does not guarantee identical installs.

A service should parse configuration once at startup, validate types and cross-field invariants, fail with actionable messages, and pass a typed or explicit settings object to components. Keep secrets out of logs and source control. Environment variables are a delivery mechanism, not a complete configuration architecture. If live reload is required, define atomic snapshot publication and rollback behavior; otherwise immutable startup configuration is simpler to reason about and test.

The Global Interpreter Lock is a CPython runtime lock that normally allows one thread at a time to execute Python bytecode in a process. It simplifies safe access to interpreter state, including reference-count updates, but it is not a general lock for your data. Threads can overlap while the GIL is released around blocking I/O or in native code. CPU-bound pure-Python threads therefore rarely scale across cores on a standard build; processes, native libraries, or an evaluated free-threaded build are alternatives.

No. The GIL does not make a check-then-update sequence, a multi-object invariant, or an external side effect atomic. A thread can be switched between bytecode operations, I/O releases the GIL, and native extensions may release it intentionally. Some built-in operations happen to be atomic in a particular CPython build, but designing around that implementation detail is brittle—especially as free-threaded Python evolves. Protect shared invariants with locks, queues, immutability, partitioned ownership, or a single owner.

Threads are lightweight and share memory, which suits I/O-bound work and libraries with blocking APIs, but shared state requires synchronization and standard CPython limits pure-Python CPU parallelism. Processes have separate interpreters and can use multiple cores, while paying startup, memory, serialization, IPC, and operational costs. The decision follows workload, data size, task duration, failure isolation, and deployment limits—not a rule that every I/O task is a thread and every CPU task is a process.

ThreadPoolExecutor runs callables in threads that share process memory and is useful for bounded blocking I/O. ProcessPoolExecutor runs in separate processes, bypassing the ordinary CPython GIL for CPU work but requiring picklable callables and arguments and paying transfer cost. Cancelling a Future generally cannot stop work that is already running. In services, bound submissions as well as worker count; an unbounded task queue can turn a slow dependency into a memory and latency incident.

A race exists when multiple execution paths access shared state and at least one writes, making the result depend on timing. Lock the whole invariant—not only the final assignment—and keep slow I/O outside the critical section when semantics allow. Use a context manager so release is exception-safe. RLock supports re-entry by the owning thread but can conceal tangled ownership. Before adding a lock, consider immutable messages, queues, per-key partitioning, or single-owner state that removes sharing.

Choose queue.Queue for threads or a multiprocessing queue for processes, set a meaningful max size, and make put behavior part of the overload policy: wait, reject, shed, or spill durably. Consumers should acknowledge completed work, handle poison items, and have an explicit shutdown signal that cannot be starved behind endless production. Queue depth, age of oldest item, processing latency, and failure rate are operational signals. An unbounded queue postpones overload while increasing memory and tail latency.

A process pool can lose when tasks are too small, inputs or outputs are expensive to pickle, workers copy large state, startup dominates, or all processes compete for cache, memory bandwidth, disk, or a downstream service. Libraries may also create their own native thread pools, producing oversubscription. Batch work, initialize stable data once per worker where safe, reduce transfer volume, and benchmark realistic task sizes. More workers than effective cores or capacity can reduce throughput.

Free-threaded CPython can disable the GIL and run Python threads in parallel. In Python 3.14 it is officially supported but remains an optional build; the standard build still uses the GIL. Code that relied on accidental atomicity needs real synchronization, extension modules must be compatible, and some extensions may cause the GIL to be enabled. Evaluate package support, correctness, single-thread overhead, memory, scaling, observability, and deployment tooling before treating it as a drop-in throughput switch.

Version: Free-threaded CPython entered supported phase II in Python 3.14 under PEP 779; it is still optional rather than the default.

An event loop waits for I/O readiness and timers, runs callbacks, and advances ready Tasks. A coroutine keeps control until it reaches an await that actually suspends, so fairness is cooperative rather than preemptive. This supports many concurrent I/O operations without one thread per connection, but blocking Python code or a synchronous library blocks every task on that loop thread. Asyncio improves concurrency, not CPU parallelism, and it still needs explicit resource bounds.

Calling an async function returns a coroutine object immediately and does not run the body. await drives it within another coroutine, while create_task schedules it concurrently on the running loop. If a coroutine object is discarded without being awaited, Python can warn that it was never awaited and the intended work never happened. Libraries should normally expose async functions and let the application own the loop rather than calling asyncio.run deep inside reusable code.

A coroutine object is the suspended computation produced by calling async def. A Task wraps and schedules a coroutine on an event loop and is also a Future. A Future is a lower-level awaitable placeholder completed with a result or exception, often by loop or library code. Application code usually creates Tasks and awaits them rather than manually constructing Futures. Keep strong references to intentionally background Tasks and always observe their failures.

asyncio.gather schedules awaitables and returns results in input order; its failure and cancellation semantics must be read carefully, especially with return_exceptions. TaskGroup provides a lexical lifetime: tasks cannot outlive the block, and a non-cancellation failure cancels remaining siblings before failures are raised as an ExceptionGroup. TaskGroup is usually clearer when work belongs together. gather remains useful for straightforward result aggregation when its exact failure contract matches the operation.

Version: asyncio.TaskGroup is available in Python 3.11+.

Any work that occupies the loop thread without reaching a suspending await blocks progress: synchronous network or file calls, time.sleep, CPU-heavy loops, large JSON encoding, compression, logging handlers, and poorly behaved callbacks. Measure loop lag and capture stacks before guessing. Replace blocking clients with async ones, move bounded blocking calls through asyncio.to_thread, and use processes or native parallel code for substantial CPU work. Offloading preserves loop responsiveness but does not create unlimited downstream capacity.

Task cancellation is cooperative: CancelledError is injected at a suspension point. Use try/finally or context managers for cleanup and normally re-raise cancellation after cleanup rather than swallowing it. Apply timeouts around the operation whose deadline you own, account for cleanup time, and propagate remaining deadline downstream when possible. shield should be rare because it deliberately lets work outlive caller cancellation; use it only for a small operation whose completion is required for consistency.

asyncio.Lock protects a task-level critical section, Semaphore caps simultaneous access to a resource, Event broadcasts a state transition, and Condition combines state waiting with a lock. They suspend the current task instead of blocking the OS thread and are designed for one event-loop context, not cross-thread protection. Keep critical sections free of unrelated network waits. A semaphore controls concurrency count, but a queue often models ownership, buffering, and backpressure more clearly.

An asyncio.Queue with maxsize bounds buffered work. await put() then slows producers when consumers fall behind, creating local backpressure; an admission path may instead reject or shed work under a deadline. Track depth and oldest-item age, not only throughput. Consumers need task_done discipline, error handling, and coordinated shutdown. A queue does not protect a remote dependency by itself—consumer concurrency, connection pools, retries, and per-request deadlines must share one capacity model.

Do not create one unbounded Task per item. Bound admission with a queue or streaming producer, cap in-flight operations with a worker count or semaphore, and align that cap with connection pools and downstream capacity. Add deadlines, cancellation, bounded retries with jitter and a retry budget, and load shedding before memory fills. Separate bulkheads for dependencies with different failure modes. Tune from latency and saturation evidence; a semaphore value copied from a blog is not a capacity plan.

CPython tracks references to most objects and normally deallocates an object when its count reaches zero. A cycle can keep every member's count above zero even when the cycle is unreachable, so the cyclic collector periodically identifies unreachable tracked container graphs. This is CPython behavior, not a universal Python language guarantee. Prompt destruction should never be the resource-management contract; use with or explicit close for files, sockets, locks, and transactions.

del name removes that name binding; del container[key] removes a reference from the container. Neither command promises immediate destruction because aliases may still reach the object, and other Python implementations can collect on a different schedule. __del__ is a finalization hook with complex ordering and resurrection concerns, not a reliable resource-management mechanism. Use context managers and explicit lifecycle methods when cleanup timing affects correctness.

In Python, a leak often means objects remain reachable longer than the application intends: an unbounded cache, queue, global registry, callback, task, traceback, or request context. Process RSS can also stay high after Python objects are freed because allocators retain arenas, or because a native extension owns memory outside the Python heap. Separate object-count growth, traced Python allocations, GC behavior, and native/RSS growth before choosing a fix. gc.collect is not a lifecycle policy.

A weak reference does not increase the target's strong-reference ownership, so it returns None after the target is collected. WeakValueDictionary and WeakKeyDictionary fit caches, metadata, and identity maps where membership must not prolong object lifetime. They are not a general cache policy: entries can disappear between operations and still need concurrency handling. weakref.finalize can arrange cleanup more safely than __del__, but explicit ownership remains clearer for critical resources.

A Python object commonly carries type and lifetime metadata, and containers often store references to separately allocated objects rather than packed values. Millions of tiny instances therefore add allocator work, reference-count traffic, pointer chasing, and poor cache locality. CPython's small-object allocator reduces general allocator overhead but cannot remove object representation costs. Improve the data model or batch/vectorize only after profiles show allocation or traversal is material; readability beats speculative packing for ordinary volumes.

Generators often lower peak memory by yielding one value at a time, but they retain their suspended frame, local variables, closure cells, and any owned resource until exhausted or closed. A local reference to a large batch can erase the expected benefit, and collecting the output into a list simply moves materialization downstream. Verify peak memory across the complete pipeline, including queues, retries, batching, and consumer speed.

A successfully imported module is normally retained in sys.modules and its global objects stay reachable for the process lifetime. Global caches, registries, SDK clients, compiled templates, and dynamically generated classes can therefore accumulate silently. Deleting one local name or reloading a module does not reliably release the old graph if other objects reference it. Give long-lived state an explicit bound and lifecycle; in plugin systems, inspect references across module and class-loader-like registries before assuming unload is possible.

Pre-fork workers may initially share read-only pages through copy-on-write, but mutations make private copies. Spawned workers initialize independently. Sending objects through process boundaries serializes and recreates them, temporarily holding source, byte stream, and destination forms. Native libraries may allocate large per-process pools. Measure proportional set size as well as RSS where available, minimize transferred data, avoid mutating huge preloaded graphs, and treat worker recycling as containment while finding the ownership cause.

Start from the user-visible metric and a representative workload. Use traces and system metrics to identify the resource, then a deterministic profiler such as cProfile for call accounting or a sampling profiler for lower-overhead production-like observation. Use line or allocation profiling only on the narrowed path. Check algorithmic work and I/O before micro-optimizing syntax. Benchmark warm-up and variance, change one hypothesis, and verify latency, throughput, memory, and correctness under the original conditions.

A deterministic profiler records function call and return events, giving call counts and cumulative time but perturbing workloads with many tiny calls. A sampling profiler periodically captures stacks, usually with lower overhead and a useful view of on-CPU time, though short-lived paths can be missed and samples are statistical. Use wall-clock traces for waiting, system tools for native code, and allocation profilers for memory. No single profiler explains every bottleneck.

Replacing an O(n²) membership loop with a set-backed O(n) pass can dominate any bytecode-level tweak as input grows. First define the input distribution, output contract, and memory budget, then count work, I/O, allocations, and serialization. Constants still matter on proven hot paths, and a theoretically better algorithm can lose at tiny sizes or poor locality. Measure at representative scale and preserve clarity unless the gain pays for complexity.

Serialization walks object graphs, converts types, allocates output buffers, validates or escapes data, and often copies across network or process boundaries. Large JSON payloads can consume CPU and block an async loop even when the network is fast. Measure encode/decode time and payload size separately. Reduce fields, batch deliberately, stream when supported, use a schema or native implementation where justified, and never use pickle across untrusted boundaries because deserialization can execute code.

Caching avoids repeated work but adds staleness, invalidation, stampede, and memory risks. Batching amortizes calls and serialization but increases queueing latency and failure blast radius. Vectorization moves loops into compact native kernels and packed data but can allocate large temporaries and is not valuable for irregular control flow. State the bottleneck each technique addresses, bound its resource use, define fallback behavior, and verify end-to-end latency rather than reporting a faster inner loop.

A connection pool amortizes setup and caps simultaneous downstream work. When saturated, requests wait, so measure acquisition time, hold duration, active operations, timeouts, and per-process pool multiplication. Increasing the pool can move the bottleneck into the database or remote service and worsen tail latency. Release connections on every path, keep transactions short, set deadlines, and size total fleet concurrency from downstream capacity rather than independently per worker.

First confirm the regression by version, route, tenant, and instance, then pause or roll back safely if impact is material. Compare traces and service metrics before and after: CPU, event-loop lag, GC, allocation, pool waits, downstream spans, payload size, errors, and queue depth. Diff code, configuration, dependencies, and deployment shape. Reproduce with a representative request, test the leading hypothesis, deploy the smallest reversible fix, and verify the p99 plus resource and error signals—not only the median.

Graph RSS, Python heap estimates, request rate, queue depth, cache size, worker age, and post-GC behavior by instance. Compare tracemalloc snapshots and object counts at similar workload points; inspect growing types, allocation sites, referrers, task stacks, queues, global registries, and cache policy. If Python allocations are flat while RSS rises, investigate native extensions, arenas, threads, buffers, and subprocesses. Recycle a worker only as containment, fix the ownership or bound, then verify the growth slope over the same lifecycle.

Measure event-loop lag, runnable and pending tasks, connection-pool waits, queue age, CPU, and downstream spans. Common causes are a synchronous client, file I/O, time.sleep, DNS or logging behavior, CPU-heavy serialization, long callbacks, unbounded task creation, exhausted pools, and retry amplification. Capture stacks during the stall. Offload or replace the blocking boundary, cap concurrency, add deadlines and shedding, and load-test the fix against the same spike and dependency capacity.

In a standard CPython process, one thread normally executes Python bytecode at a time, so CPU-heavy pure-Python threads contend for the GIL and may add context-switch overhead. Confirm the work is actually on-CPU and not blocked on I/O or a shared lock. Improve the algorithm first; then consider vectorized/native code that releases the GIL, a process pool with coarse tasks, or a tested free-threaded deployment. Any option still needs CPU, memory, and downstream capacity bounds.

Check core saturation, run queue, context switches, per-worker throughput, serialization time and bytes, IPC wait, memory bandwidth, cache misses, page faults, startup, and downstream limits. Tasks may be too fine-grained, payloads too large, or native libraries may already spawn threads. Sweep worker and batch counts rather than assuming cores equal workers. Reduce data movement, initialize stable state once, cap nested parallelism, and select the worker count that maximizes end-to-end throughput within memory and latency limits.

Bound task creation before the dependency call with a queue, worker group, or semaphore aligned to the connection pool. Give requests deadlines, cancel abandoned work, cap retries with jitter and a retry budget, and open a circuit or shed load when success is unlikely. Separate bulkheads so one dependency cannot consume every task and connection. Track in-flight count, queue age, timeout rate, breaker state, and late completions. Recover gradually so a synchronized retry wave does not re-fail the dependency.

Correlate the spike with route, job type, payload, deployment version, thread, and process. Use a low-overhead sampling profiler or repeated stack capture while the worker is hot; inspect Python and native frames. Common causes include pathological input, an accidental busy loop, regex backtracking, huge serialization, compression, retry without blocking, or native library work. Reproduce with the triggering input, add an immediate guard or timeout if needed, fix the algorithm or bound, and verify CPU time and output correctness.

Measure key cardinality, value size, hit rate, age distribution, insertion rate, tenant skew, and retention paths. Decide whether the cache belongs in each worker, a shared service, or nowhere. Add a maximum count or byte budget, TTL where staleness permits, deliberate eviction, and single-flight or jitter to prevent stampedes. Avoid keys with unbounded request dimensions and cache failures carefully. Expose hits, misses, evictions, load latency, and size; verify that memory stabilizes and dependency load remains acceptable.