Python interview questions and worked answers

When does changing one list change another?

Assignment creates another name for the same object. A shallow copy creates a new outer list or dictionary, but its elements still refer to the same nested objects. If the new result must be independently editable, copy the data at the boundary where ownership changes, or build new records explicitly.

A function receives a list of records, makes a “copy” for a filtered result, and then annotates one nested record. Explain when the original changes and show a safe approach.

Python variables bind names to objects; they do not contain the objects. copy.copy() copies one compound container, while copy.deepcopy() recursively copies its reachable contents, using a memo to handle cycles. Deep copying can duplicate too much or interact badly with custom objects, so it is not a universal fix. A mutable default argument has the same shared-object issue: Python evaluates the default once when the function is defined, not once per call.

rows = [[]] * 3
rows[0].append("x")
# rows is [['x'], ['x'], ['x']]

Read the source: Python copy operations · default argument values · programming FAQ on shared defaults

↑ Back to questions

What can you safely assume about an iterator?

An iterator is a forward-only stream unless its type documents extra behavior. Consuming it advances its state; it is not automatically rewindable or reusable. If the function needs two passes, it must either accept a repeatable container, materialize the items within a justified memory bound, or perform both calculations in one pass.

A function accepts an iterable of events. It counts matching events and then returns the matching events. A caller passes a generator. Why can the second operation return nothing, and what would you change?

An iterator supplies __next__() and signals exhaustion by raising StopIteration. A generator suspends at each yield and resumes from that point. Generator expressions and functions can keep memory use low by producing values on demand, but laziness also means errors and side effects occur during iteration, not at construction. An iterator may represent an unbounded stream, so blindly calling list() may never finish or may exhaust memory.

def matching_events(events):
    count = sum(event.kind == "error" for event in events)
    matches = [event for event in events if event.kind == "error"]
    return count, matches

Read the source: Iterator protocol and functional iteration · iterator and generator data model · itertools.tee

↑ Back to questions

Who closes a resource when iteration stops early?

Put resource lifetime under an explicit context manager. A with block calls the manager’s exit method when control leaves the block, including when an exception occurs. Merely yielding a resource-backed generator does not make early consumer termination a clear ownership boundary; the consumer should close it or the API should keep iteration inside the resource’s context.

A generator reads a large file and yields parsed records. A caller stops after the first matching record. What guarantees cleanup, and what does not?

A context manager’s __exit__() runs after a successful __enter__(), whether the suite finishes normally or raises. Its return value controls whether an exception is suppressed. A generator can use try/finally, but the finally runs when the generator is closed or otherwise finalized, so relying on garbage collection timing is a weaker contract than explicit closure. For multiple dynamically acquired resources, contextlib.ExitStack registers cleanup as resources are acquired.

with open(path, encoding="utf-8") as source:
    for line in source:
        record = parse(line)
        if is_match(record):
            break

Read the source: The with statement semantics · contextlib.ExitStack · generator closing methods

↑ Back to questions

What should an asyncio coroutine do when cancellation arrives?

Put cleanup in finally. If code catches asyncio.CancelledError to add cleanup or logging, it should generally re-raise the exception. Cancellation is cooperative: Task.cancel() requests cancellation, and the exception is raised at a later opportunity, usually an await. Swallowing it can interfere with TaskGroup and asyncio.timeout(). A finally block ensures cleanup is attempted, not that an awaited cleanup always completes: another cancellation can interrupt it, and an exception from cleanup can replace the exception already in flight (with the earlier exception retained as context). Give cleanup a bounded, idempotent policy and decide explicitly how to report cleanup failure.

A request handler awaits a remote operation while holding a temporary resource. The caller times out and cancels the task. How should the coroutine clean up without defeating cancellation?

Cancellation is not an asynchronous kill signal that can safely interrupt any instruction. The task gets a chance to run cleanup. CancelledError directly subclasses BaseException, so except Exception generally does not swallow it. Structured-concurrency helpers use cancellation internally to shut down related work and report errors; suppressing cancellation without understanding task state breaks that coordination.

asyncio.TaskGroup and asyncio.timeout() require Python 3.11 or later. On an older supported runtime, choose APIs available there and keep cancellation propagation explicit.

async def fetch_with_cleanup(resource):
    try:
        return await resource.fetch()
    finally:
        await resource.close()

Read the source: Asyncio task cancellation and CancelledError · TaskGroup · async context managers

↑ Back to questions

Does adding threads make Python CPU work run on more cores?

On standard GIL-enabled CPython, threads are useful for overlapping I/O, but usually do not run pure-Python bytecode in parallel across cores. For CPU-bound work, measure a process pool or move the computation to an implementation that releases the GIL. asyncio is useful for many I/O operations in one event loop when the libraries are awaitable; it does not make CPU work parallel by itself.

A service has many independent network waits and one CPU-heavy pure-Python transformation. Which concurrency model would you try first, and what version details matter?

This statement is about CPython’s usual GIL-enabled build, not every Python implementation or every extension. Starting with Python 3.13, CPython offers an optional free-threaded build. It is not the default, and importing a C extension that is not marked as free-threading-safe may enable the GIL. The free-threaded mode has compatibility and performance tradeoffs; check the actual interpreter and dependency set. Even with a GIL, do not treat compound shared-state operations as a synchronization guarantee. Use locks, queues, or message passing when correctness depends on ordering.

import asyncio

async def fetch_all(urls, fetch):
    return await asyncio.gather(*(fetch(url) for url in urls))

Read the source: Threading and the GIL · free-threaded Python support and extension behavior · asyncio overview

↑ Back to questions

When is a protocol better than checking a concrete class?

State the operations the function needs, not the concrete class that happens to provide them. If it only iterates, accept an iterable of records. If it needs a custom capability, define a small protocol or abstract base class. A protocol lets static type checkers recognize structural compatibility without requiring inheritance.

A function streams records from a source. The current implementation accepts only list[Record], but callers may use a tuple, file reader, or generator. How would you express the contract?

Python’s runtime data model defines behavior through methods such as __iter__ and __next__; the for statement uses that protocol. typing.Protocol describes a structural interface to static type checkers. Type annotations do not validate input at runtime, so external or untrusted data still needs explicit parsing and validation. @runtime_checkable protocols check for attribute presence, not full signatures or semantic correctness.

from collections.abc import Iterable

def count_valid(records: Iterable[Record]) -> int:
    return sum(record.is_valid() for record in records)

Read the source: Python data model and iterator protocol · typing protocols · annotations in the language reference

↑ Back to questions

What do type annotations guarantee at runtime?

The annotation will not validate decoded JSON. Parse untrusted data into a known shape at the input boundary, reject values that do not meet the endpoint’s contract, and then pass a validated value into typed internal functions. A static checker can check code paths, but it does not inspect a request at runtime.

A Python endpoint accepts JSON with a values field, then totals it. The team annotates the parsed value as list[int]. What happens if the payload contains strings or booleans, and where should the contract be enforced?

json.loads() returns ordinary Python values such as dictionaries, lists, strings, numbers, booleans, and None. An annotation documents what a function expects; Python does not automatically compare each runtime value with that annotation. TypedDict can describe dictionary keys to a static checker, but a decoded dictionary still needs validation. In Python, bool is a subclass of int, so a boundary that accepts JSON integers but rejects JSON booleans should check the exact type or use a schema validator with that policy.

def total_values(payload):
    if type(payload) is not dict or "values" not in payload:
        raise ValueError("values is required")
    values = payload["values"]
    if type(values) is not list or any(type(value) is not int for value in values):
        raise ValueError("values must be a list of integers, excluding booleans")
    return sum(values)

assert total_values({"values": [3, 4]}) == 7
for invalid in (["3", "4"], [True], None):
    try:
        total_values({"values": invalid})
    except ValueError:
        pass
    else:
        raise AssertionError("invalid values accepted")

Read the source: Typing support and runtime behavior · TypedDict behavior · JSON decoding · Python numeric types and bool

↑ Back to questions

How do you test a function that calls an external dependency?

Separate the transformation from the I/O boundary where practical. Test the transformation with ordinary inputs and edge cases. For the orchestration layer, replace the dependency at the name the code looks up, then assert the meaningful call and result. Keep at least one integration test for the real adapter if the project can run it safely.

A function reads a record from a client, transforms it, and saves the result. How would you test behavior without making a real network call?

Unit tests should make behavior and failures observable, not mirror every implementation line. A fake can be simpler than a mock when it models a small contract. When using unittest.mock.patch, patch the symbol in the module under test’s namespace: from client import fetch binds a name there, so patching the original client.fetch later may not replace that bound reference. Isolate fixtures so one test cannot contaminate another.

from unittest.mock import patch

with patch("service.fetch", return_value={"id": 7}):
    result = service.load(7)

Read the source: unittest test cases and fixtures · unittest.mock and where to patch

↑ Back to questions

How do you decide what to optimize?

Define the slow user-visible operation, measure a representative workload, and profile it to locate the expensive work. Then make one change and repeat the same measurement. A shorter expression is not evidence of faster behavior.

A data-processing endpoint is slow. A teammate wants to replace a loop with a compact comprehension and claims it will be faster. What evidence do you gather first?

Profilers help attribute time and call counts, but profiling overhead changes execution. cProfile is useful for locating time in Python call paths. timeit is designed for measuring small snippets more fairly, with repeated runs. A microbenchmark can miss I/O, allocation, cache, input-size, and concurrency effects from the real endpoint. Track both latency and resource use when relevant.

python -m cProfile -s cumulative app.py

Read the source: Python profiler guidance · timeit · performance measurement notes in timeit

↑ Back to questions

How do you make a Python project reproducible on another machine?

Make the supported Python version and dependency set explicit, isolate project packages in a virtual environment, and document a repeatable install and test command. Keep the environment directory out of source control; commit the project’s dependency metadata or lock file according to its packaging tool.

A script works on one laptop but fails on a teammate’s machine because package versions differ. What would you check and change?

venv creates an environment with its own site-packages, isolated from the base installation by default. It is disposable and should be recreated, not copied or committed. A virtual environment does not by itself pin dependency versions or guarantee cross-platform equivalence; the project still needs a declared dependency policy and tested setup instructions.

python -m venv .venv
. .venv/bin/activate
python -m pip install -r requirements.txt
python -m pytest

Read the source: venv creation and isolation · Python tutorial on virtual environments and packages · module installation overview

↑ Back to questions

Keep exploring