Master Python Decorators: Concepts, Usage, and Design Patterns

Reference

Books: Fluent Python , Effective Python

Basic Concepts

Question 1: What is a decorator?

Answer: A decorator is syntactic sugar; it is a callable object that takes a function as an argument and returns a callable, often replacing the original function.

Question 2: What are the features of decorators?

Answer: Decorators can replace the decorated function with another function and can execute code at module load time.

def decorate(func):
    print('running decorate', func)
    return func()

def decorate_inner():
    print('running decorate_inner function')
    return func()

return func
return decorate_inner

Question 3: How to use arguments of the decorated function?

Answer: Pass arguments via *args and **kwargs in the wrapper.

def decorate(func):
    def decorate_inner(*args, **kwargs):
        print(type(args), type(kwargs))
        print('args', args, 'kwargs', kwargs)
        return func(*args, **kwargs)
    return decorate_inner

Stacked Decorators

Question: What is the execution order of stacked decorators?

Answer: The innermost decorator is applied first; the function is wrapped by the inner decorator, producing a new function that is then wrapped by the outer decorator.

def outer(func):
    print('enter outer', func)
    def wrapper():
        print('running outer')
        func()
        return wrapper

def inner(func):
    print('enter inner', func)
    def wrapper():
        print('running inner')
        func()
        return wrapper

@outer
@inner
def main():
    print('running main')

if __name__ == '__main__':
    main()

Standard Library Decorators

Common built‑in decorators include @property, @classmethod, @staticmethod, and those from functools such as lru_cache, singledispatch, and wraps.

from functools import lru_cache, singledispatch, wraps

Why use @wraps ? It copies important metadata (e.g., __name__, docstring) from the original function to the wrapper, preventing side effects that break introspection tools.

from functools import wraps

def decorate(func):
    @wraps(func)
    def decorate_inner():
        print('running decorate_inner function')
        return func()
    return decorate_inner

Decorator Design Pattern

The design pattern adds responsibilities to objects dynamically, keeping the component and decorator interfaces identical so that clients can use them transparently; multiple decorators can be nested to compose behavior.

Python decorators implement the same idea but are more powerful and not a one‑to‑one mapping to the classic pattern.