How do I make function decorators and chain them together?

python

function-decorators

python-decorators

advanced-python

byAnton Shumikhin·Nov 8, 2024

To chain decorators in Python, you use multiple @decorator_name markers preceding a function definition. Each decorator wraps the function and modifies its behavior. When the decorators are applied, the one closest to the function runs first.

Consider this example:

def decorator1(func):
    def wrapper(*args, **kwargs):
        # You've been through the first layer of the decorator onion!
        return func(*args, **kwargs)
    return wrapper

def decorator2(func):
    def wrapper(*args, **kwargs):
        # Second layer of the onion...am I making you cry yet? 😉
        return func(*args, **kwargs)
    return wrapper

@decorator2  # Applied second
@decorator1  # Applied first
def my_function():
    pass

my_function()  # Brace yourself, function! You're going in!

In this setup, my_function is first processed by decorator1, and then it's passed through decorator2.

Crafting Versatile Decorators

Function Decorators as Transformative Agents

Functions in Python are first-class citizens meaning they can be named, passed as arguments, and even modified. Let's demonstrate this:

def greet(name):
    return f"Hello, {name}!"

def uppercase_decorator(func):
    # Beware, uppercase_decorator transformer is in action!
    def wrapper(*args, **kwargs):
        original_result = func(*args, **kwargs)
        modified_result = original_result.upper()
        return modified_result
    return wrapper

shout_greet = uppercase_decorator(greet)
print(shout_greet("Alice"))  # Outputs: HELLO, ALICE!

Use functools.wraps to preserve your function's identity during the journey:

from functools import wraps

def decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        # Pre-decorating activities here
        result = func(*args, **kwargs)
        # Post-decorating activities here
        return result
    return wrapper

Making Decorators with Customizable Parameters

At times, you may need configurable decorators. This is achieved by using a decorator factory:

def repeat(times):
    # Creating a decorator on demand. Like decorator Uber. 😄
    def decorator_repeat(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(times):
                value = func(*args, **kwargs)
            return value
        return wrapper
    return decorator_repeat

@repeat(times=3)
def say_hello():
    print("Hello!")
# Outputs: "Hello!" thrice. Because once is too mainstream, right?

Advanced Decorator Techniques and Best Practices

Performance Considerations with Decorators

While powerful, decorators may slow down your function calls due to additional wrapper invocations. For performance-critical applications, measure decorator impact and be cautious.

Chaining Decorators: Order Matters!

When chaining decorators, especially those with parameters, order is crucial. Refer to this order-correct example:

@log(level='INFO')                     # 3rd Layer 
@validate_user(redirect_url='/login')  # 2nd Layer
@route('/hello')                       # 1st Layer
def hello_page():
    return "Hello, World!"
# In the words of ogres and onions - layers are important!

You may recall the chain operation as:

hello_page = log(level='INFO')(
    validate_user(redirect_url='/login')(
        route('/hello')(hello_page)
    )
)

Decorator Pitfall Avoidance

Keep decorators side-effect-free to ensure they don't impact global state.
Always handle variable and named arguments with *args and **kwargs.
Use closures to prepare custom versions of decorators, avoiding unnecessary global variables.