Python Interview Questions 2026

How Python Interviews Differ From Whiteboard Coding

When you code in Python during an interview, interviewers expect you to leverage the language. Using a manual linked list when collections.deque exists, or writing a manual sort when sorted(key=...) solves it in one line, signals unfamiliarity. Python proficiency is a signal, not a luxury.

The most common Python interview categories: data structure internals (dict, list, set complexity), functional patterns (map/filter/comprehensions), OOP (classes, inheritance, dunder methods), generators and iterators, decorators, and concurrency primitives (GIL, asyncio, threading).

Data Structure Questions

Python's built-in data structures have specific time complexities that interviewers probe. List append is O(1) amortized; insert(0, x) is O(n). Dict lookup is O(1) average; worst case O(n) due to hash collisions (rare in practice). Set union is O(m+n).

Frequently asked: implement an LRU cache using OrderedDict. Compare defaultdict vs Counter vs plain dict. Explain when to use heapq vs sortedcontainers.SortedList. Know bisect for sorted insertion.

The collections module is heavily tested: deque for O(1) popleft, Counter for frequency maps, namedtuple for lightweight structs, defaultdict for graph adjacency lists.

OOP and Class Design

Python OOP questions at FAANG focus on practical design rather than theory. Common prompts: implement a __repr__ and __str__ that are meaningfully different. Design a class that supports iteration (__iter__, __next__). Make an object comparable using __lt__ and friends for use in a heap.

Property vs attribute: know when to use @property for computed attributes with validation. Slots: know that __slots__ reduces memory for large numbers of small objects by avoiding per-instance __dict__.

Dataclasses (@dataclass) come up in system design coding sessions. Know how to use them, when to add frozen=True for hashability, and what field(default_factory=list) prevents (mutable default argument trap).

Generators and Iterators

Generator questions appear in 20-30% of Python-focused interviews. The core question: explain the difference between a generator function (uses yield) and a generator expression ((x for x in ...)). When would you use a generator over a list? Memory-bounded iteration over large datasets.

Commonly asked: implement an infinite counter generator. Implement flatten() that recursively flattens nested iterables using generators. Chain two generators without materializing either. Use itertools.islice to limit a generator.

The itertools module: know chain, combinations, permutations, product, groupby, takewhile. These are reach tools that demonstrate fluency.

Decorators and Context Managers

Write a decorator from scratch that: (1) logs function calls with arguments, (2) caches results (basic memoization), (3) retries on exception with exponential backoff. These are direct interview prompts, not hypothetical.

Know functools.wraps and why you need it (preserves __name__ and __doc__ on the decorated function). Know functools.lru_cache and when it is not safe (mutable arguments, methods on mutable objects).

Context managers: implement one using __enter__/__exit__ and using contextlib.contextmanager. Know what happens when the managed code raises an exception (exception is passed to __exit__).

Concurrency: GIL, asyncio, and Threading

The Global Interpreter Lock (GIL) prevents true parallel execution of Python threads on CPU-bound work. Threading is appropriate for I/O-bound concurrency (network calls, disk reads). For CPU-bound parallelism, use multiprocessing or a C extension that releases the GIL (NumPy operations do this).

asyncio is appropriate when you have many concurrent I/O operations and thread overhead would be prohibitive. Know the difference between async def/await, asyncio.gather for concurrent coroutines, and asyncio.create_task for fire-and-forget.

Interview question: "Design a rate limiter in Python." The GIL discussion will come up if your solution uses threading. Correct answer: use asyncio with a semaphore (asyncio.Semaphore) for I/O-bound requests, or threading.Semaphore for threaded code.