Python Developer Interview Questions and Answers

Python interviews test whether you can ship and debug real services, not only recite syntax.

Live coding often includes:

• List/dict/string manipulation
• Parsing JSON or CSV
• Writing a small API handler or data transform
• Debugging mutable-default or async bugs

A strong answer connects language features to production scenarios (retries, large files, query counts), not definitions alone.

A Python developer loop usually emphasizes backend depth: language internals, frameworks, databases, testing, and deployment.

A full stack Python developer loop adds UI integration:

Common full stack stacks in 2026:

• Django + React — batteries-included backend, admin, ORM conventions
• FastAPI + React/Vue — async APIs, OpenAPI contracts, microservices
• Flask + SPA — minimal core; you justify extensions (Flask-Login, SQLAlchemy)

Most companies run 4–6 rounds:

Take-home assignments may ask for a small REST API with tests and a README—quality of error handling and tests often matters more than feature count.

A strong candidate thinks aloud during live coding and states assumptions before coding.

Ship one mini-project (todo API, URL shortener, or ingestion script) with Docker and pytest—not only flashcards.

Immutable objects cannot change after creation: int, float, str, tuple (if all elements immutable), frozenset, bytes.

Mutable objects can change in place: list, dict, set, most user-defined classes.

Why interviewers care:

s = "hello"
# s[0] = "H"  # TypeError — str is immutable

items = [1, 2]
items.append(3)  # mutates list in place

For a deeper comparison of built-in collections, see list vs set vs tuple vs dictionary.

A strong answer ties mutability to bugs you've seen (shared state, unexpected aliasing), not only definitions.

Default arguments are evaluated once at function definition time—not on each call.

def append_item(item, bucket=None):
    if bucket is None:
        bucket = []
    bucket.append(item)
    return bucket

print(append_item(1))  # [1]
print(append_item(2))  # [2] — safe pattern

Broken pattern (common interview trap):

def bad_append(item, bucket=[]):
    bucket.append(item)
    return bucket

print(bad_append(1))  # [1]
print(bad_append(2))  # [1, 2] — same list reused!

Fix: use None as sentinel and create a fresh list inside the function.

Interviewers want you to explain object identity (id(bucket) stays same across calls in the bug version).

*Insertion order preserved since Python 3.7+ (language guarantee 3.8+).

Choose tuple for hashable records; set for O(1) average membership; dict for key→value maps; list when you need order with mutation.

A strong answer mentions time complexity (in on list is O(n), on set/dict is O(1) average).

List comprehension — builds full list in memory:

squares = [n * n for n in range(1_000_000)]

Generator expression — lazy, constant memory:

squares = (n * n for n in range(1_000_000))

Interviewers link this to 50GB log processing—you cannot materialize all lines as a list.

See python yield for generator functions with state.

Python is pass-by-object-reference (sometimes called "pass by assignment"):

• Names bind to objects
• Rebinding a parameter (x = x + 1 on int) does not affect caller
• Mutating a shared object (lst.append(1)) does affect caller

def grow(lst):
    lst.append(99)

data = [1]
grow(data)
print(data)  # [1, 99]

A strong answer avoids saying only "references"—explain rebind vs mutate with a quick example.

• == compares values (calls __eq__)
• is compares object identity (id(a) == id(b))

Use is only for singletons like None, True, False:

x = None
x is None  # idiomatic

"a" * 1000 == "a" * 1000  # True
"a" * 1000 is "a" * 1000  # may be False — separate objects

Interview trap: never use is for small integer caching folklore without context—focus on None checks.

import copy

original = [[1], [2]]
shallow = copy.copy(original)
deep = copy.deepcopy(original)

original[0].append(99)
print(shallow[0])  # [1, 99] — nested list shared
print(deep[0])     # [1] — fully independent

Use deep copy when handing off nested structures you must not alias (config snapshots, test fixtures).

• *args — tuple of extra positional arguments
• **kwargs — dict of extra keyword arguments

def demo(a, *args, b=10, **kwargs):
    return a, args, b, kwargs

demo(1, 2, 3, b=20, c=30)
# (1, (2, 3), 20, {'c': 30})

Common uses:

• Wrapper functions that forward to inner APIs
• Decorators that accept arbitrary signatures
• Framework hooks (Django views, pytest fixtures)

Full examples: python kwargs and args.

A decorator wraps a function to add cross-cutting behavior without duplicating code:

• Logging, timing, auth checks
• Retry with backoff on flaky HTTP calls
• Caching (functools.lru_cache)

Mechanically: @decorator applies func = decorator(func).

A strong answer names one production use (retry on payment API, auth on admin routes) and mentions functools.wraps to preserve __name__ and docstrings for debugging.

Interviewers test closures, exceptions, and real API resilience:

import functools
import time

def retry(times=3, base_delay=0.1):
    def decorator(fn):
        @functools.wraps(fn)
        def wrapper(*args, **kwargs):
            last_exc = None
            for attempt in range(times):
                try:
                    return fn(*args, **kwargs)
                except Exception as exc:
                    last_exc = exc
                    time.sleep(base_delay * (2 ** attempt))
            raise last_exc
        return wrapper
    return decorator

Senior follow-ups:

• Add jitter to avoid thundering herd
• Retry only specific exceptions (requests.Timeout)
• Log attempt count and final failure

I ran this pattern on Python 3.13—the third attempt succeeds after two deliberate failures.

sorted(users, key=lambda u: u["last_login"])

Prefer def for anything non-trivial—lambdas are hard to debug and cannot contain assignments.

See python lambda function for more examples.

A closure is a function that remembers variables from its enclosing scope after the outer function returns.

Decorators rely on closures to hold configuration (times=3 in the retry decorator).

Interviewers may ask you to fix a classic loop bug:

# Bug: all lambdas see final i
funcs = [lambda: i for i in range(3)]

# Fix: default arg binds i at definition time
funcs = [lambda i=i: i for i in range(3)]

A strong answer explains late binding in comprehension lambdas.

class User:
    def __init__(self, name):
        self.name = name

    @classmethod
    def from_dict(cls, data):
        return cls(data["name"])

    @staticmethod
    def validate_name(name):
        return bool(name and name.strip())

Use classmethod when you need polymorphic construction; staticmethod when logic belongs near the class but needs no self or cls.

Python supports multiple inheritance. Method Resolution Order (MRO) is the linearization C3 algorithm uses to pick which parent method runs.

class A:
    def ping(self):
        return "A"

class B(A):
    def ping(self):
        return "B"

class C(A):
    def ping(self):
        return "C"

class D(B, C):
    pass

print(D().ping())   # B
print(D.mro())    # D, B, C, A, object

Interviewers want super() used correctly in cooperative multiple inheritance—not only single-parent examples.

A strong answer mentions mixins (small reusable behaviors) vs deep hierarchies.

@dataclass generates __init__, __repr__, and comparison methods from typed fields—less boilerplate than manual classes.

from dataclasses import dataclass

@dataclass(frozen=True)
class Point:
    x: int
    y: int

Senior note: dataclasses are not a replacement for domain logic—keep behavior methods purposeful.

Duck typing: "If it quacks like a duck, use it"—no inheritance required; rely on protocols (file.read(), iterable behavior).

ABC (abc module): enforce interface contracts for frameworks and plugins.

from abc import ABC, abstractmethod

class Repository(ABC):
    @abstractmethod
    def get(self, id: int): ...

Use ABCs when teams need explicit contracts; use duck typing for flexible utilities and tests (fakes without subclassing).

__slots__ restricts instance attributes to a fixed set—saves memory and can speed attribute access by avoiding per-instance __dict__.

Trade-offs:

Use for high-volume value objects (event streams, parsers)—not default for every model (Django ORM models use their own machinery).

A generator produces items lazily via yield (or a generator expression). A list materializes all items at once.

def read_lines(path):
    with open(path, encoding="utf-8") as f:
        for line in f:
            yield line.strip()

Benefits:

• Constant memory on large files
• Pipeline-friendly (parse → filter → aggregate)
• Can represent infinite sequences

Interview answer for "process 50GB CSV": generator or chunked pandas.read_csv(chunksize=...), never readlines() into RAM.

• Iterable — has __iter__() returning an iterator (list, dict, generator function result)
• Iterator — has __iter__() and __next__(), raises StopIteration when exhausted

it = iter([1, 2, 3])
next(it)  # 1

Generators are iterators. You can only consume a one-shot iterator once unless you recreate it.

yield from delegates to another iterable/generator—flattens nested iteration and forwards send()/throw() in advanced coroutine code.

def chain(*iterables):
    for it in iterables:
        yield from it

list(chain([1, 2], [3]))  # [1, 2, 3]

Practical use: composing pipelines without nested loops; async has async for analog patterns.

The Global Interpreter Lock (GIL) in CPython allows only one thread to execute Python bytecode at a time in a single process.

Implications:

A strong answer does not say "Python can't do concurrency"—it qualifies parallel CPU vs concurrent I/O.

See python multithreading and python multiprocessing.

Example asyncio skeleton:

import asyncio

async def fetch(url):
    await asyncio.sleep(0.01)  # stand-in for I/O
    return url

async def main():
    results = await asyncio.gather(*(fetch(u) for u in ["a", "b", "c"]))
    print(results)

asyncio.run(main())

Senior follow-up: uvicorn + FastAPI runs ASGI event loop; blocking ORM calls need thread pool (run_in_executor) or async drivers.

Choose asyncio when:

• High fan-out I/O (many HTTP/DB/WebSocket clients)
• Latency-sensitive API aggregating multiple backends
• Stack is async-native (FastAPI, httpx, asyncpg)

Avoid assuming asyncio fixes CPU bottlenecks—profile first.

Architecture sketch for notification fan-out:

1. FastAPI accepts request
2. asyncio.gather calls downstream services
3. Push to queue (Redis/RabbitMQ) for slow work
4. Worker process (Celery/sync) for CPU-heavy tasks

Compare with Node.js event loop interviews—similar I/O concurrency story, different runtime.

Interviewers reject candidates who say asyncio gives multi-core parallelism for Python CPU work without mentioning processes.

1. Use async libraries (httpx.AsyncClient, asyncpg)
2. Wrap unavoidable sync calls: await asyncio.to_thread(blocking_fn, arg)
3. Offload heavy CPU to Celery/RQ workers or multiprocessing pool
4. Set timeouts on external calls
5. Monitor event loop lag in production (metrics, slow request logs)

Django note: traditional sync views under WSGI are fine for many apps; ASGI + async views require the same discipline.

try:
    result = risky()
except ValueError as exc:
    handle(exc)
else:
    # runs only if no exception
    log_success(result)
finally:
    # always runs — cleanup
    cleanup()

Best practices interviewers expect:

• Catch specific exceptions, not bare except:
• Re-raise with raise or raise NewError(...) from exc
• Use else to keep success path readable

More patterns: python try except.

Context managers guarantee setup/teardown (files, locks, DB transactions) via __enter__/__exit__ or @contextmanager.

from contextlib import contextmanager

@contextmanager
def tag(name):
    print(f"[{name}] start")
    try:
        yield name
    finally:
        print(f"[{name}] end")

with tag("job") as label:
    process(label)

Prefer with open(...) over manual close() in finally—fewer leaked handles under exceptions.

Example parametrized test:

import pytest

@pytest.mark.parametrize("text,expected", [
    ("", False),
    ("a", True),
])
def test_validate_name(text, expected):
    assert User.validate_name(text) == expected

Senior bar: tests that catch regressions (N+1 query count, auth failures), not only happy path.

• Patch at use site (@patch("myapp.client.requests.get"))
• Return Response fakes with controlled status/body
• Assert call count and payloads for contract tests
• For async, use pytest-asyncio and mock AsyncClient

Avoid hitting real payment or email APIs in unit tests—use interfaces + fakes so CI stays fast and deterministic.

High-level path (WSGI/ASGI):

1. Server receives HTTP request
2. Django middleware chain (security, sessions, auth, CSRF)
3. URL resolver → view
4. View uses ORM/forms/serializers
5. Middleware processes response
6. Connection cleanup / logging

Senior candidates mention CSRF on cookie-session apps, authentication middleware, and database connection handling—not only "URL → view → template."

Follow-up: WSGI sync vs ASGI async entry; choose ASGI when you need async views or WebSockets.

N+1: one query for parent rows + one per row for related data.

# Bad: hits DB per book.author
for book in Book.objects.all():
    print(book.author.name)

# Better: select_related for ForeignKey
for book in Book.objects.select_related("author"):
    print(book.author.name)

Senior nuance: prefetch_related on huge related sets can over-fetch—sometimes a targeted Prefetch queryset or raw SQL wins. Profile with django-debug-toolbar or query logging.

Hybrid pattern: Django for admin/auth + FastAPI for latency-sensitive read APIs—justify operational cost (two deployables, shared auth).

A strong answer picks based on team, traffic shape, and maintenance, not hype.

Pydantic provides:

• Runtime validation of request/response bodies
• Clear 422 errors for clients
• Type hints → OpenAPI / Swagger docs
• Pydantic v2 Rust core → faster validation

Senior angle: schema is the contract between frontend and backend—reduces "works on my machine JSON" bugs until integration tests exist.

from pydantic import BaseModel, Field

class CreateUser(BaseModel):
    email: str = Field(min_length=3)
    age: int = Field(ge=18)

Flask does not ship auth—you choose:

Senior response: ask clarifying questions (SPA vs server-rendered? refresh tokens?) before picking.

For DB patterns with Flask, see Flask SQLAlchemy.

1. Validation at boundary (Pydantic, DRF serializers)
2. AuthN/AuthZ — JWT or session; role checks on sensitive routes
3. Structured logging + request IDs
4. Health/readiness endpoints
5. Migrations (Django/Alembic) with safe rollout plan
6. Tests — unit + API integration
7. Container image (slim base, non-root user)
8. CI — lint, test, type check (ruff, mypy optional)

Interviewers want operational awareness—not only @app.get.

Packaging reference: create a Python package.

Typical flow:

1. React form → fetch('/api/items', { method: 'POST', body: JSON })
2. FastAPI/Django validates body, persists via ORM
3. JSON response → React updates state (React Query/SWR)
4. CORS configured for dev origin; cookies need credentials + CSRF strategy

Cross-read full stack developer interview questions for layer-integration scenarios beyond Python-only depth.

Backend Python roles expect you to read and write SQL, not only ORM magic:

• JOINs, GROUP BY, indexes
• Explain an EXPLAIN plan at high level
• Know when ORM generates inefficient SQL

Practice with SQL technical interview questions.

Strong answer: "I use ORM for productivity but drop to SQL for reporting queries and performance fixes."

Common topics:

• Docker multi-stage builds, uv/pip layer caching
• Gunicorn/uvicorn workers vs async workers
• Environment config — 12-factor, secrets not in git
• Migrations on deploy — expand/contract pattern
• Celery/RQ for background jobs
• Observability — Sentry, Prometheus, structured logs

Senior: blue/green or rolling deploys, feature flags, rollback when migration fails.

Common prompt testing recursion and edge cases:

def flatten(d, parent=""):
    out = {}
    for key, value in d.items():
        full_key = f"{parent}.{key}" if parent else key
        if isinstance(value, dict):
            out.update(flatten(value, full_key))
        else:
            out[full_key] = value
    return out

print(flatten({"a": 1, "b": {"c": 2, "d": {"e": 3}}}))
# {'a': 1, 'b.c': 2, 'b.d.e': 3}

Clarify with interviewer:

• Are values only dicts and scalars?
• What about lists of dicts?
• Mutate or return new dict?

Think aloud: base case (scalar), recursive case (dict), string key building.

Cover:

1. Ingress — HTTP or WebSocket gateway (FastAPI/ASGI)
2. Fan-out — asyncio for I/O; processes if CPU-heavy formatting
3. Queue — Redis/RabbitMQ for durability
4. Workers — Celery consumers for email/push providers
5. Storage — Postgres for preferences, idempotency keys
6. Scale — horizontal API replicas; sticky sessions only if needed for WS

Python-specific: acknowledge GIL—do not promise single-process multi-core CPU; partition work across processes or specialized services.

Compare architecture patterns in full stack developer interview questions.

Technical drills:

• Explain mutable default, GIL, and asyncio vs threading without notes
• Write retry decorator and flatten dict on whiteboard
• Walk through Django N+1 fix with select_related / prefetch_related
• Defend Django vs FastAPI for a JD-specific scenario
• One pytest fixture + parametrized test from memory
• Sketch FastAPI + worker queue deploy diagram

Cross-prep:

• SQL interviews for JOIN/window practice
• Data science interviews if role blends ML
• Git interviews for PR workflow stories

Behavioral (STAR): Prepare one story where you fixed a production Python incident—bad deploy, runaway query, memory leak, or async blocking—with metrics (latency, error rate, query count).

A strong close:

I rehearse framework depth for the JD, core Python traps aloud, and three STAR stories tied to services I actually shipped—not slides of syntax trivia.