Origin

Have you ever been frustrated by writing similar code repeatedly? Have you wondered how to elegantly add new functionality to functions without changing their original code? As a Python developer, I deeply appreciate the convenience brought by decorators. Today, let's explore Python decorators, this powerful and elegant programming tool.

Essence

A decorator is essentially a Python function that allows us to modify the functionality of other functions. Sounds magical, right? But its working principle isn't complicated. Let me illustrate with a simple example:

Suppose you're a coffee shop owner with a basic coffee-making process:

def make_coffee():
    return "a black coffee"


def add_milk(func):
    def wrapper():
        coffee = func()
        return coffee + "with milk"
    return wrapper

@add_milk
def make_coffee():
    return "a black coffee"

print(make_coffee())  # Output: a black coffee with milk

See, through decorators, we elegantly added new features to the coffee without modifying the original coffee-making function. This is the charm of decorators.

Deep Dive

Let's go a step further. Decorators can handle not only simple functions but also functions with parameters. This is more common in actual development:

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

@log_execution_time
def calculate_sum(n):
    return sum(range(n))

calculate_sum(1000000)  # Will output function execution time

This example shows how to use decorators to measure function execution time. I often use this trick to optimize performance bottlenecks in actual work.

Practice

Speaking of practice, let me share some decorator patterns I commonly use in actual projects:

1. Cache decorator:

def cache_result(func):
    cache = {}
    def wrapper(*args, **kwargs):
        key = str(args) + str(kwargs)
        if key not in cache:
            cache[key] = func(*args, **kwargs)
        return cache[key]
    return wrapper

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

1. Permission verification decorator:

def require_permission(permission):
    def decorator(func):
        def wrapper(*args, **kwargs):
            if check_permission(permission):  # Assume this function checks permissions
                return func(*args, **kwargs)
            else:
                raise PermissionError("Insufficient permissions")
        return wrapper
    return decorator

@require_permission("admin")
def sensitive_operation():
    print("Executing sensitive operation")

Advanced

After mastering the basic usage, let's look at some more advanced applications. Decorators can also be used with classes, which gives us more possibilities:

def singleton(cls):
    instances = {}
    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return get_instance

@singleton
class Database:
    def __init__(self):
        print("Initializing database connection")

This singleton pattern decorator ensures that the database connection is created only once, which is very practical in actual projects.

Pitfalls

I've also encountered some pitfalls when using decorators. For example, the most common one is the function signature loss issue:

def my_decorator(func):
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

@my_decorator
def greet(name):
    """Say hello to someone"""
    return f"Hello, {name}"

print(greet.__name__)  # Output: wrapper
print(greet.__doc__)   # Output: None

The solution is to use functools.wraps:

from functools import wraps

def my_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

Reflection

Decorators are not just a syntax feature, but a reflection of programming thinking. They make our code more modular and easier to maintain. In my view, the key to mastering decorators lies not in remembering syntax, but in understanding their design philosophy.

For instance, when you find yourself writing similar code in multiple functions, you can consider using decorators to extract these common logics. This not only reduces code duplication but also makes the code structure clearer.

Looking Forward

As Python evolves, the application scenarios for decorators will become increasingly widespread. Decorators play an even more prominent role, especially in web development and data processing.

Now that you have a deeper understanding of decorators, think about this: where in your projects could you use decorators to optimize code? Have you encountered any special decorator use cases?

Finally, remember one thing: decorators are a powerful tool, but don't overuse them. Keeping code simple and readable is most important.