Python Interview Questions

Python Decorators: Principle, functools.wraps, Parameterized

Explain how decorators work. Write a @retry(times=3) decorator.

Why Interviewers Ask This

Decorator fluency is table stakes for mid-level Python; parameterized decorators filter out people who only use @ without understanding it.

How to Answer

  1. 1

    @decorator above def f: ... is sugar for f = decorator(f). decorator is any callable returning a callable.

  2. 2

    Typical shape: `def deco(fn): def wrapper(*a, **kw): ...; return fn(*a, **kw); return wrapper`.

  3. 3

    Use functools.wraps(fn) inside wrapper to preserve original __name__, __doc__, __wrapped__ — otherwise help() and logging break.

  4. 4

    Parameterized decorator: three-layer — outer takes params and returns the real decorator.

  5. 5

    Class decorators: use __init__ to capture fn, __call__ to make instance callable.

Sample Answer

A decorator is any callable that accepts a function and returns something callable. `@foo` above `def f()` is syntactic sugar for `f = foo(f)`. Typical pattern: outer function defines a wrapper that calls the original around any extra logic, returns wrapper. Always slap `@functools.wraps(fn)` on the wrapper so __name__, __doc__, and tracebacks stay sane — without it every decorated function looks like 'wrapper' to downstream tooling. For `@retry(times=3)` I need three layers: retry(times) returns decorator(fn), which returns wrapper(*a, **kw) that loops up to times, catching exceptions. Parameterized decorators trip people up because the outermost layer is called with the params, and its return value is the actual decorator.

Pro Tips

  • @functools.lru_cache is a built-in decorator that's great to know — TTL-less in-memory memo.

  • For async functions, write async-aware decorators: wrapper must be `async def` and `await fn(...)`.

  • HireMe AI (即答侠) has the three-layer parameterized template memorized with functools.wraps in the right place.

Frequently Asked Questions

What if I forget functools.wraps?

The decorated function loses its name and docstring, and introspection (inspect, sphinx, debuggers) reports the wrapper instead. Annoying but not fatal.

Class decorators vs function decorators?

Class decorators can hold state cleanly in self. Function decorators are lighter. Functionally equivalent otherwise.

More Python Interview Questions

Python GIL (Global Interpreter Lock) ExplainedPython Decorators: Principles and PatternsPython asyncio: How the Event Loop and Coroutines Actually WorkPython Garbage Collection: Reference Counting + Cycle CollectorPython GIL: Why It Exists and How to Work Around ItPython multiprocessing vs threading vs asyncio
See all Python Interview Questions

Worried About Going Blank in Your Interview?

HireMe AI listens to your interview in real-time, detects questions, and generates instant answer suggestions — so you never freeze up again.

Try HireMe AI Free