Hello, today I want to talk about decorators in Python. To be honest, I was also confused when I first encountered decorators. What does that @ symbol mean? Why use decorators? What problems do they actually solve? I believe many Python learners have similar questions. After years of learning and practice, I finally grasped the elegance of decorators, and today I'd like to share my insights with you.

Origins

I remember when I first started writing Python code, I often needed to add some common functionalities to functions, such as timing, logging, permission verification, etc. Initially, I would write these codes directly in each function:

def calculate_sum(a, b):
    start_time = time.time()  # Start timing
    print(f"Function starts executing, parameters: {a}, {b}")  # Log

    result = a + b  # Core business logic

    end_time = time.time()  # End timing
    print(f"Function execution completed, time spent: {end_time - start_time} seconds")  # Log
    return result

While this approach works, I quickly discovered the problem: if 10 or 100 functions need these features, this repetitive code would be everywhere. Moreover, if I needed to modify the logging format, I would have to modify all these functions. This clearly wasn't a good solution.

Evolution

Later, I learned to optimize using function nesting:

def add_logging(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        print(f"Function {func.__name__} starts executing, parameters: {args}, {kwargs}")

        result = func(*args, **kwargs)

        end_time = time.time()
        print(f"Function execution completed, time spent: {end_time - start_time} seconds")
        return result
    return wrapper

def calculate_sum(a, b):
    return a + b

calculate_sum = add_logging(calculate_sum)

This approach was much better, but still looked a bit awkward. Having to add a line of code after each function definition to wrap it. That's when the decorator syntax sugar came to rescue us:

@add_logging
def calculate_sum(a, b):
    return a + b

Much cleaner, isn't it? This is the charm of decorators.

Essence

At this point, you might ask: what's the essence of decorators? Actually, a decorator is just a function that takes a function as a parameter and returns a new function. This new function typically adds some extra functionality before and after executing the original function.

Let me explain with a more relatable example. Imagine you're a baker who can make various flavored cakes (these are the original functions). Now you want to add beautiful packaging to all cakes (this is what the decorator does). You can write it like this:

def beautiful_package(cake_func):
    def wrapper():
        print("Add beautiful gift box")
        cake = cake_func()  # Make cake
        print("Tie with pretty ribbon")
        return cake
    return wrapper

@beautiful_package
def make_chocolate_cake():
    return "Chocolate cake"

@beautiful_package
def make_strawberry_cake():
    return "Strawberry cake"

Advanced

Decorators can also take parameters, making them even more powerful. For example, we can specify the logging level:

def log_with_level(level='INFO'):
    def decorator(func):
        def wrapper(*args, **kwargs):
            if level == 'DEBUG':
                print(f"DEBUG: Executing function {func.__name__}")
                print(f"DEBUG: Parameters are {args}, {kwargs}")
            elif level == 'INFO':
                print(f"INFO: Executing function {func.__name__}")

            result = func(*args, **kwargs)

            if level == 'DEBUG':
                print(f"DEBUG: Function {func.__name__} completed, return value is {result}")
            return result
        return wrapper
    return decorator

@log_with_level(level='DEBUG')
def multiply(x, y):
    return x * y

Decorators can also be stacked, like adding both packaging and ribbon to a cake:

@decorator1
@decorator2
def target_function():
    pass

This is equivalent to: target_function = decorator1(decorator2(target_function))

Applications

After all this theory, let's look at how decorators are used in real projects. Here are some common use cases:

1. Performance monitoring:

def performance_monitor(func):
    def wrapper(*args, **kwargs):
        start_time = time.perf_counter()
        result = func(*args, **kwargs)
        end_time = time.perf_counter()
        print(f"{func.__name__} execution time: {end_time - start_time:.4f} seconds")
        return result
    return wrapper

1. Access control:

def require_login(func):
    def wrapper(*args, **kwargs):
        if not current_user.is_authenticated:
            raise PermissionError("Please login first")
        return func(*args, **kwargs)
    return wrapper

1. Result caching:

def cache_result(func):
    cache = {}
    def wrapper(*args):
        if args in cache:
            return cache[args]
        result = func(*args)
        cache[args] = result
        return result
    return wrapper

@cache_result
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

Reflection

The applications of decorators go far beyond these. In web frameworks like Django and Flask, decorators are widely used for route definitions, permission control, and more. In data science, many libraries also use decorators to simplify code. For example, when using numpy for vectorized operations:

import numpy as np

@np.vectorize
def custom_operation(x):
    if x > 0:
        return x * 2
    return x

This decorator allows our function to automatically support array operations without writing loops.

I believe the greatest value of decorators lies in providing an elegant way to extend and modify function behavior without modifying the function's code itself. This perfectly aligns with the Open-Closed Principle: open for extension, closed for modification.

In actual development, have you encountered situations where you need to add the same functionality to multiple functions? Try refactoring your code using decorators. I believe that once you truly master decorators, you'll find that Python code can be written more elegantly and professionally.

What do you find most attractive about decorators? Feel free to share your thoughts and experiences in the comments.