Python 装饰器学习的日志记录应用

xiaoshi 05-30 12 抢沙发

默认

摘要： ...

Python装饰器实战：打造高效日志记录系统

装饰器基础：从理解到应用

Python装饰器是提升代码复用性和可维护性的强大工具。本质上，装饰器是一个接受函数作为参数并返回新函数的可调用对象。这种特性使得我们能够在不修改原函数代码的情况下，为函数添加额外功能。

让我们从一个简单的装饰器示例开始：

def basic_logger(func):
    def wrapper(*args, **kwargs):
        print(f"开始执行函数: {func.__name__}")
        result = func(*args, **kwargs)
        print(f"函数 {func.__name__} 执行完毕")
        return result
    return wrapper

这个basic_logger装饰器会在函数执行前后打印日志信息。使用时只需在目标函数前添加@basic_logger即可：

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

日志记录装饰器的进阶实现

基础版本虽然实用，但在生产环境中往往需要更完善的日志记录功能。我们可以改进装饰器，使其记录更详细的信息：

import time
from functools import wraps

def enhanced_logger(func):
    @wraps(func)  # 保留原函数的元信息
    def wrapper(*args, **kwargs):
        start_time = time.time()
        print(f"[INFO] 调用函数: {func.__name__}")
        print(f"[DEBUG] 参数: args={args}, kwargs={kwargs}")

        try:
            result = func(*args, **kwargs)
            end_time = time.time()
            print(f"[INFO] 函数 {func.__name__} 执行成功")
            print(f"[PERF] 执行耗时: {end_time - start_time:.4f}秒")
            return result
        except Exception as e:
            print(f"[ERROR] 函数 {func.__name__} 执行失败: {str(e)}")
            raise

    return wrapper

这个改进版装饰器不仅记录了函数调用信息，还添加了执行时间统计和异常处理功能。@wraps装饰器的使用确保了被装饰函数保留其原始名称和文档字符串，这在调试时非常有用。

参数化装饰器：灵活配置日志行为

有时我们希望根据不同场景调整日志记录的详细程度。通过创建可接受参数的装饰器，可以实现这一需求：

def configurable_logger(level='INFO', record_time=True):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            start_time = time.time() if record_time else None

            if level in ['DEBUG', 'INFO']:
                print(f"[{level}] 进入函数: {func.__name__}")
                if level == 'DEBUG':
                    print(f"[DEBUG] 参数详情: args={args}, kwargs={kwargs}")

            result = func(*args, **kwargs)

            if record_time:
                elapsed = time.time() - start_time
                print(f"[PERF] 函数 {func.__name__} 耗时: {elapsed:.4f}秒")

            if level in ['DEBUG', 'INFO']:
                print(f"[{level}] 离开函数: {func.__name__}")

            return result
        return wrapper
    return decorator

使用这个装饰器时，可以指定日志级别和是否记录执行时间：

@configurable_logger(level='DEBUG', record_time=True)
def process_data(data):
    # 数据处理逻辑
    pass

日志装饰器在实际项目中的应用

在真实项目中，我们通常需要将日志写入文件而非仅打印到控制台。以下是一个生产环境可用的日志装饰器实现：

import logging
from datetime import datetime

def file_logger(log_file='app.log', level=logging.INFO):
    logging.basicConfig(
        filename=log_file,
        level=level,
        format='%(asctime)s - %(levelname)s - %(message)s'
    )

    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            logging.info(f"开始执行函数: {func.__name__}")
            try:
                result = func(*args, **kwargs)
                logging.info(f"函数 {func.__name__} 执行成功")
                return result
            except Exception as e:
                logging.error(f"函数 {func.__name__} 执行失败: {str(e)}")
                raise
        return wrapper
    return decorator

这个装饰器将日志信息写入指定文件，并按日期时间、日志级别和消息内容进行格式化。在大型项目中，这种持久化日志对于问题排查和系统监控至关重要。

装饰器组合与最佳实践

在实际开发中，我们经常需要组合多个装饰器来满足不同需求。例如，你可能想同时记录日志和验证参数：

def validate_input(*validators):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for i, val in enumerate(validators):
                if not val(args[i]):
                    raise ValueError(f"参数 {i} 验证失败")
            return func(*args, **kwargs)
        return wrapper
    return decorator

@file_logger(level=logging.DEBUG)
@validate_input(lambda x: x > 0, lambda y: isinstance(y, str))
def process_values(num, text):
    return text * num

使用装饰器时应注意以下几点：

保持装饰器代码简洁，专注于单一功能
使用@wraps保留原函数元信息
注意装饰器应用顺序（从上到下应用）
为复杂装饰器编写清晰的文档
避免过度使用装饰器导致代码可读性下降

性能考量与替代方案

虽然装饰器非常有用，但在性能敏感的场景中需要注意其开销。每个装饰器都会增加一层函数调用，对于高频调用的简单函数，这可能会成为瓶颈。

对于这种情况，可以考虑以下替代方案：

在类方法中使用__getattribute__实现类似功能
对于简单日志需求，直接在函数内部添加日志语句
使用sys.settrace实现全局跟踪（虽然更复杂但开销可能更小）

# 直接日志记录示例（无装饰器开销）
def critical_function(x):
    start = time.time()
    # 函数逻辑
    end = time.time()
    if end - start > 1.0:  # 仅当执行时间长时记录
        logging.warning(f"critical_function执行缓慢: {end-start:.2f}s")
    return result