8 个必须要知道的Python装饰器

Python 装饰器是一项强大而灵活的功能，用于修改或增强函数或类的行为。本质上，装饰器是一个接受另一个函数或类作为参数并返回一个新函数或类的函数。

它们通常用于在不改变原始代码的情况下添加额外的功能或特性。使用装饰器的语法涉及“@”符号，应用于目标函数或类。接下来，我们将介绍十个简单但非常有用的自定义装饰器。

为什么我们需要装饰器

在 Python 中，装饰器有几个关键作用，使它们成为开发者的宝贵工具：

• 代码重用性： 装饰器允许你在多个函数或类之间应用相同的功能，而不必重复编写代码。这促进了代码的重用性，使你的代码库保持 DRY（不要重复自己）。
• 关注分离： 通过将功能封装在装饰器中，你可以将函数或类的核心逻辑与日志记录、计时或访问控制等辅助关注点分离开来。这种分离增强了代码的可读性和可维护性。
• 语法便利： 使用@符号来应用装饰器的语法糖使得修改函数或类的行为变得容易，而不必直接修改它们的代码。这导致了更清晰、更直观的代码。
• 可扩展性： 装饰器提供了一种灵活的方式来扩展现有函数或类的功能，而无需修改它们的代码。这在你与外部库或框架一起工作并希望添加自定义行为的情况下特别有用。
• 动态修改： 由于装饰器可以动态地改变函数或类的功能，它们使得代码结构更加动态和灵活，能够适应不同的场景或配置，而无需硬编码更改。

装饰器增强了 Python 代码的功能性、可读性和可维护性，使它们成为 Python 开发者工具箱中高效和有效的基本工具。

@timer：测量执行时间

优化代码性能至关重要。@timer 装饰器有助于跟踪特定函数的执行时间。通过将函数包装在这个装饰器中，我们可以快速识别瓶颈并优化代码的关键部分。下面是它的工作原理：

import time  

def timer(func):  
    """  
    一个打印被装饰函数执行时间的装饰器。  
    """  
    def wrapper(*args, **kwargs):  
        start_time = time.time()  # 记录函数的开始时间  
        result = func(*args, **kwargs)  # 调用被装饰的函数  
        end_time = time.time()  # 记录函数的结束时间  
        print(f"函数 {func.__name__} 执行花费了 {end_time-start_time:.4f} 秒.")  
        return result  
    return wrapper  
  
# 示例用法  
@timer  
def example_function(n):  
    """  
    一个简单的函数，睡眠 n 秒。  
    """  
    time.sleep(n)  
  
example_function(2)

在这个例子中，timer 装饰器被应用到 example_function 上，该函数简单地睡眠了指定的秒数。当你调用 example_function(2) 时，装饰器将测量并打印函数执行的时间，大约应该是 2 秒。这种模式可以应用于任何函数以测量其执行时间，使其成为性能优化的通用工具。

@memoize：缓存结果

在数据科学中，我们经常遇到计算成本较高的函数。@memoize 装饰器有助于缓存这些函数的结果，防止对相同输入进行冗余计算，并显著加快工作流程：

def memoize(func):  
    """  
    一个缓存被装饰函数结果的装饰器。  
    """  
    cache = {}  # 初始化一个空缓存  
  
    def wrapper(*args):  
        # 检查结果是否在缓存中  
        if args in cache:  
            return cache[args]  # 返回缓存的结果  
        else:  
            result = func(*args)  # 计算结果  
            cache[args] = result  # 缓存结果以便未来调用  
            return result  
  
    return wrapper  
  
@memoize  
def fibonacci(n):  
    """  
    使用递归计算第 n 个斐波那契数，使用记忆化进行优化。  
    """  
    if n <= 1:  
        return n  
    else:  
        return fibonacci(n - 1) + fibonacci(n - 2)

该装饰器存储函数调用的结果，并为相同参数的后续调用返回缓存结果，大大减少了像斐波那契数列计算这样的函数的计算时间。

@deprecated：处理废弃函数

随着项目的发展和更新，某些函数可能会变得过时。@deprecated 装饰器用于在不建议使用某个函数时通知用户：

import warnings  
  
def deprecated(func):  
    """  
    一个在调用被装饰函数时发出警告的装饰器，指示该函数已经被弃用，并且可能在未来版本中被移除

。  
    """  
    def wrapper(*args, **kwargs):  
        warnings.warn(f"'{func.__name__}' 已经被弃用，并且可能会在未来版本中被移除。", DeprecationWarning, stacklevel=2)  
        return func(*args, **kwargs)  
    return wrapper  
  
@deprecated  
def old_data_processing(data):  
    """  
    这个函数包含之前使用的数据处理逻辑，现在被视为已弃用。  
    """  
    # 在这里放置你的遗留数据处理代码

warnings.warn 中的 stacklevel=2 参数确保警告指向调用废弃函数的位置，使得开发者更容易识别和替换已废弃的用法。

@debug：简化调试

调试复杂代码可能非常耗时。@debug 装饰器通过打印输入参数及其值来帮助调试，从而简化调试过程：

def debug(func):  
    """  
    一个记录传递给被装饰函数的参数和关键字参数的装饰器，通过提供函数调用的参数和数据流来便于调试。  
    """  
    def wrapper(*args, **kwargs):  
        arg_values = ', '.join([str(a) for a in args])  # 将参数转换为字符串  
        kwarg_values = ', '.join([f"{k}={v}" for k, v in kwargs.items()])  # 将关键字参数转换为字符串  
        print(f"调用 {func.__name__}，参数为: [{arg_values}]，关键字参数为: [{kwarg_values}]")  
        return func(*args, **kwargs)  
    return wrapper  
  
@debug  
def complex_data_processing(data, threshold=0.5):  
    """  
    一个占位符，用于复杂的数据处理逻辑，可以受益于调试，特别是为了理解数据和参数的流动。  
    """  
    # 在这里插入复杂的数据处理逻辑

@retry：执行重试

@retry 装饰器帮助在遇到异常时重试函数执行，确保更高的可靠性：

import time  
  
def retry(max_attempts, delay):  
    """  
    一个装饰器，尝试执行被装饰函数最多指定次数，  
    在出现异常时等待指定延迟后重试。  
    """  
    def decorator(func):  
        def wrapper(*args, **kwargs):  
            for attempt in range(max_attempts):  
                try:  
                    return func(*args, **kwargs)  
                except Exception as e:  
                    print(f"第 {attempt + 1} 次尝试失败。{max_attempts} 次尝试后退出...")  
                    time.sleep(delay)  
            raise Exception(f"经过 {max_attempts} 次尝试后仍然失败。")  
        return wrapper  
    return decorator  
  
@retry(max_attempts=3, delay=2)  
def fetch_data_from_api(api_url):  
    """  
    尝试从指定的 API URL 获取数据，在失败时进行重试。  
    """  
    # 在这里实现你的 API 数据获取逻辑

@validate_output：验证输出

确保数据分析的质量至关重要。@validate_output 装饰器有助于验证函数的输出，确保其满足特定标准后再进行进一步处理：

def validate_output(func):  
    """  
    一个检查函数输出有效性的装饰器。如果输出不符合  
    预定义的标准，则引发错误，确保只处理有效结果。  
    """  
    def wrapper(*args, **kwargs):  
        output = func(*args, **kwargs)  # 执行函数  
        if valid_output(output):  # 检查输出是否有效  
            return output  # 返回有效输出  
        else:  
            raise ValueError("输出验证失败。请检查函数逻辑。")  
  
    return wrapper  
  
@validate_output  
def clean_data(data):  
    """  
    处理并清洗给定的数据。此函数被装饰器包装以  
    确保其输出满足一定的质量标准后再进行处理。  
    """  
    # 在这里实现你的数据清洗逻辑

@suppress_errors：优雅的错误处理

程序执行经常会遇到意外错误，可能会中断整个过程。@suppress_errors 装饰器允许优雅地处理异常，使得执行可以继续进行：

def suppress_errors(func):  
    """  
    一个设计用来捕获并报告被装饰函数执行期间发生的任何异常的装饰器，  
    防止它们中断程序执行。它会记录错误并返回 None。  
    """  
    def wrapper(*args, **kwargs):  
        try:  
            return func(*args, **kwargs)  
        except Exception as error:  
            print(f"{func.__name__} 发生了错误：{error}")  
            return None  # 返回 None 表示已处理错误  
  
    return wrapper  
  
@suppress_errors  
def preprocess_data(data):  
    """  
    对给定的数据应用预处理步骤。使用 suppress_errors 装饰器包装，  
    确保任何遇到的错误都能得到优雅处理，允许工作流程继续。  
    """  
    # 在这里插入你的数据预处理逻辑

@log_results：记录输出

在进行复杂数据分析时，跟踪每个函数的输出变得至关重要。@log_results 装饰器帮助记录函数的结果，便于调试和监控：

def log_results(func):  
    """  
    一个捕获和记录被装饰函数执行结果的装饰器。  
    它将函数名和其结果追加到日志文件中，有助于  
    调试或监控结果跟踪和分析。  
    """  
    def wrapper(*args, **kwargs):  
        result = func(*args, **kwargs)  # 执行函数并捕获结果  
        with open("results.log", "a") as log_file:  # 以追加模式打开日志文件  
            log_file.write(f"函数 {func.__name__} - 结果: {result}\n")  # 记录结果  
        return result  # 返回原始结果  
  
    return wrapper  
  
@log_results  
def calculate_metrics(data):  
    """  
    对提供的数据执行计算以生成指标。此函数  
    使用 log_results 装饰器增强，自动记录其结果。  
    """  
    # 在这里实现指标计算逻辑

结论

Python 装饰器是一项强大而多用途的功能，极大地增强了 Python 代码的功能性，使其成为开发者不可或缺的工具。通过允许程序员修改或扩展函数或类的行为而不改变其实际代码，装饰器促进了更清晰、更可读和更易维护的代码库。它们提供了一种无缝的方式来实现横切关注点，如日志记录、缓存、身份验证和错误处理，在多个函数或类中最小化代码重复。

使用装饰器可以导致更高效的开发实践，使开发者能够专注于应用程序的核心逻辑，同时在整个项目中重用常见功能。装饰器还通过将功能分离到不同的层中促进了关注分离原则，这简化了测试和调试过程。