Advanced Python Interview Questions and Answers

The Global Interpreter Lock in CPython (the standard implementation) allows only one thread to execute Python bytecode at a time. Consequences:

• I/O-bound work (network calls, file and database access) still benefits from threads, because threads release the GIL while waiting.
• CPU-bound pure-Python work does not speed up with threads; use multiprocessing (separate processes, each with its own GIL) or libraries that run in C (NumPy).

Python 3.13 introduced an experimental free-threaded build without the GIL, but the default build still has it.

Threads overlapping I/O waits:

import threading, time

def work(n, out):
    time.sleep(0.2)
    out.append(n)

out = []
threads = [threading.Thread(target=work, args=(i, out)) for i in range(5)]
t0 = time.perf_counter()
for t in threads: t.start()
for t in threads: t.join()
print(sorted(out), time.perf_counter() - t0 < 1.0)   # one after another takes at least 1 s

[0, 1, 2, 3, 4] True

Five 0.2-second waits finished in less than the 1 second they need one after another, because they overlapped.

async def defines a coroutine. await pauses it until another awaitable finishes, letting the event loop run other coroutines in the meantime:

import asyncio, time

async def fetch(name, delay):
    await asyncio.sleep(delay)
    return f"{name} done"

async def main():
    return await asyncio.gather(fetch("A", 0.2), fetch("B", 0.2))

t0 = time.perf_counter()
print(asyncio.run(main()), time.perf_counter() - t0 < 0.4)   # one after another takes at least 0.4 s

['A done', 'B done'] True

Both waits ran concurrently. Blocking calls (like time.sleep or requests.get) inside a coroutine freeze the whole loop; use async equivalents.

@decorator above def f is equivalent to f = decorator(f). A decorator returns a wrapper function (a closure over the original) that adds behaviour. functools.wraps copies the original's name and docstring:

from functools import wraps

def debug(func):
    @wraps(func)
    def wrapper(*a, **k):
        r = func(*a, **k)
        print(f"{func.__name__}{a} -> {r}")
        return r
    return wrapper

@debug
def mul(x, y):
    return x * y

mul(3, 4)

mul(3, 4) -> 12

Decorators with arguments add a third layer (a function that returns the decorator). See Decorators.

send(value) resumes a generator and makes the paused yield expression evaluate to value, enabling two-way communication:

def gen():
    received = yield "ready"
    yield f"got {received}"

g = gen()
print(next(g), g.send("hello"))

ready got hello

This is the mechanism coroutines were originally built on.

__slots__ declares a fixed set of attributes. Instances then have no per-object __dict__, which saves memory when you create millions of objects and prevents typos from creating new attributes:

class Point:
    __slots__ = ("x", "y")
    def __init__(self, x, y):
        self.x, self.y = x, y

p = Point(1, 2)
try:
    p.z = 3
except AttributeError as e:
    print("AttributeError:", e)

AttributeError: 'Point' object has no attribute 'z' and no __dict__ for setting new attributes

• Every object has a reference count; when it drops to zero, the object is freed immediately.
• A cyclic garbage collector (gc module) finds and frees groups of objects that reference each other but are otherwise unreachable.
• Small objects use a specialised allocator (pymalloc) for speed.

Practical points: large objects held in global caches or long-lived lists are not freed; weakref lets you refer to objects without keeping them alive; tools like tracemalloc help find leaks.

Classes are objects too, and a metaclass is the class of a class. The default metaclass is type:

print(type(int), type(type))

<class 'type'> <class 'type'>

A custom metaclass (class Meta(type): ...) can change how classes are created, for example to register subclasses or validate class definitions. They are rarely needed; class decorators and __init_subclass__ solve most of the same problems more simply.

@dataclass(frozen=True) makes instances immutable and hashable, so they can be dictionary keys or set members, and cannot be changed by accident:

from dataclasses import dataclass

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

p = Point(1, 2)
print(p, hash(p) == hash(Point(1, 2)))
try:
    p.x = 5
except Exception as e:
    print(type(e).__name__)

Point(x=1, y=2) True
FrozenInstanceError

1. Measure first: cProfile (or python -m cProfile script.py) shows where time is spent; timeit compares small alternatives.
2. Fix the algorithm or data structure before micro-optimising. For example, membership in a set is far faster than in a list:

import timeit
print(timeit.timeit("x in s", setup="s=set(range(10000)); x=9999", number=1000)
      < timeit.timeit("x in s", setup="s=list(range(10000)); x=9999", number=1000))

True

3. Use built-ins and the standard library (written in C), avoid repeated work (caching with lru_cache), and move heavy numeric work to NumPy.
4. For CPU-bound tasks, consider multiprocessing; for I/O-bound ones, threads or asyncio.