01 引言

Python装饰器是一种强大而优雅的语法特性，能够在不修改原有函数代码的情况下，为函数添加新的功能。
本文将为你揭示15个实用的Python装饰器技巧，帮助你写出更加简洁、高效的代码。

02 核心概念解析

装饰器本质上是一个接受函数作为参数并返回新函数的可调用对象。它利用了Python的一级函数特性和闭包机制，允许我们在不改变原函数定义的情况下，动态地修改或增强函数的行为。
装饰器的基本语法如下：

@decorator
def function():
    pass

# 等价于：
def function():
    pass
function = decorator(function)

Python中的装饰器不仅可以应用于函数，还可以用于类方法和整个类。它们在日志记录、性能测量、访问控制、缓存等方面有广泛的应用。理解和掌握装饰器，对于编写可维护和可扩展的Python代码至关重要。

03 实际应用场景

1.日志记录：在大型项目中，使用装饰器可以轻松地为多个函数添加日志功能，而无需在每个函数中重复编写日志代码。
2.性能分析：通过装饰器可以方便地测量函数的执行时间，帮助开发者识别性能瓶颈。
3.访问控制：在Web应用中，装饰器可以用于实现用户认证和授权，确保只有具有特定权限的用户才能访问某些功能。
4.缓存机制：对于计算密集型函数，使用缓存装饰器可以显著提高程序的执行效率，避免重复计算。
5.输入验证：在数据处理应用中，装饰器可以用于检查函数输入的有效性，提高代码的健壮性。

04 代码示例与详解

1. 日志装饰器

import logging
from functools import wraps

def log_function_call(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        logging.info(f"Calling {func.__name__} with args: {args}, kwargs: {kwargs}")
        result = func(*args, **kwargs)
        logging.info(f"{func.__name__} returned {result}")
        return result
    return wrapper

@log_function_call
def add(x, y):
    return x + y

# 使用装饰器后的函数调用
add(3, 5)

这个装饰器实现了以下功能：
使用logging模块记录函数调用信息。

@wraps(func)保留了原函数的元数据。

装饰器记录了函数名、参数和返回值。

2. 计时装饰器

使用time.time()测量函数执行时间。

打印函数名和执行时间。

import time
from functools import wraps

def timeit(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__} took {end_time - start_time:.4f} seconds to execute")
        return result
    return wrapper

@timeit
def slow_function():
    time.sleep(2)

# 使用装饰器后的函数调用
slow_function()

3. 缓存装饰器

使用字典cache存储已计算的结果。

对于相同的输入，直接返回缓存的结果，避免重复计算

from functools import wraps

def memoize(func):
    cache = {}
    @wraps(func)
    def wrapper(*args):
        if args not in cache:
            cache[args] = func(*args)
        return cache[args]
    return wrapper

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

# 使用装饰器后的函数调用
print(fibonacci(100))

4. 参数验证装饰器

from functools import wraps

def validate_positive(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        for arg in args:
            if isinstance(arg, (int, float)) and arg <= 0:
                raise ValueError(f"Argument {arg} is not positive")
        return func(*args, **kwargs)
    return wrapper

@validate_positive
def calculate_square_root(x):
    return x ** 0.5

# 使用装饰器后的函数调用
try:
    print(calculate_square_root(4))
    print(calculate_square_root(-1))
except ValueError as e:
    print(e)

检查所有参数是否为正数。

如果发现非正数，抛出ValueError异常。

5. 重试装饰器

import time
from functools import wraps

def retry(max_attempts, delay=1):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            attempts = 0
            while attempts < max_attempts:
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    attempts += 1
                    if attempts == max_attempts:
                        raise
                    time.sleep(delay)
        return wrapper
    return decorator

@retry(max_attempts=3, delay=2)
def unreliable_function():
    import random
    if random.random() < 0.7:
        raise Exception("Random failure")
    return "Success"

# 使用装饰器后的函数调用
print(unreliable_function())

这个重试装饰器的特点：
允许指定最大重试次数和重试间隔。

捕获异常并在达到最大重试次数前继续尝试。

如果所有尝试都失败，则抛出最后一个异常。

05 性能优化与注意事项

1.使用functools.wraps：始终使用@wraps(func)来保留原函数的元数据，这对于调试和文档生成非常重要。
2.避免过度使用：虽然装饰器很强大，但过度使用可能导致代码难以理解和维护。适度使用，并确保每个装饰器都有明确的目的。
3.注意装饰器顺序：当多个装饰器应用于同一个函数时，它们的执行顺序是从下到上的。例如：

@decorator1
@decorator2
def func():
    pass
# decorator2先执行，然后是decorator1。

4.性能考虑：装饰器会引入额外的函数调用，这可能在性能敏感的场景中产生影响。对于频繁调用的小函数，考虑使用内联代码而不是装饰器。
5.参数化装饰器：对于需要自定义行为的装饰器，使用参数化装饰器可以提高灵活性。例如：

def repeat(times):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(times):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(3)
def greet(name):
    print(f"Hello, {name}!")

6.类装饰器：对于更复杂的装饰器逻辑，考虑使用类装饰器。它们可以提供更好的代码组织和状态管理。

随着Python语言的不断发展，我们可以期待看到更多创新的装饰器用法，例如异步装饰器在并发编程中的应用，以及与类型注解结合的更智能的装饰器。