深入浅出Python 3装饰器：从入门到精通

原创于 2025-11-11 09:38:06 发布 · 740 阅读

10 ·

CC 4.0 BY-SA版权

文章标签：

#python 3 #装饰器 #decorator

编程学习笔记专栏收录该内容

190 篇文章

订阅专栏

诸神缄默不语-个人技术博文与视频目录

文章目录

1. 什么是装饰器
- 1.1 装饰器的基本概念
- 1.2 装饰器的语法糖
2. 装饰器的基本用法
- 2.1 函数装饰器
- 2.2 带参数的函数装饰器
3. 装饰器的高级特性
4. 装饰器的实际应用场景
5. 装饰器的最佳实践
- 5.1 保持装饰器的通用性
- 5.2 调试友好的装饰器
6. 总结

1. 什么是装饰器

1.1 装饰器的基本概念

装饰器（Decorator）是Python中一种强大的语法特性，它允许我们在不修改原函数代码的情况下，为函数添加新的功能。装饰器本质上是一个高阶函数，它接收一个函数作为参数，并返回一个新的函数。

def simple_decorator(func):
    def wrapper():
        print("函数执行前")
        func()
        print("函数执行后")
    return wrapper

@simple_decorator
def say_hello():
    print("Hello!")

say_hello()

输出结果：

函数执行前
Hello!
函数执行后

1.2 装饰器的语法糖

@decorator 语法是Python提供的语法糖，它使得装饰器的使用更加简洁和直观。上面的代码等价于：

def say_hello():
    print("Hello!")

say_hello = simple_decorator(say_hello)
say_hello()

2. 装饰器的基本用法

2.1 函数装饰器

函数装饰器是最常见的装饰器类型，它使用函数来包装另一个函数。

def timer_decorator(func):
    import time
    
    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_decorator
def calculate_sum(n):
    return sum(range(n))

result = calculate_sum(1000000)
print(f"计算结果: {result}")

2.2 带参数的函数装饰器

有时候我们需要让装饰器本身接受参数，这时需要再嵌套一层函数。

def repeat(n):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for i in range(n):
                print(f"第 {i+1} 次执行:")
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

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

greet("Python")

输出结果：

第 1 次执行:
Hello, Python!
第 2 次执行:
Hello, Python!
第 3 次执行:
Hello, Python!

3. 装饰器的高级特性

3.1 保留函数元信息

使用装饰器后，原函数的元信息（如函数名、文档字符串等）会被包装函数覆盖。为了解决这个问题，我们可以使用functools.wraps装饰器。

from functools import wraps

def preserve_info_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        """包装函数的文档字符串"""
        print(f"调用函数: {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

@preserve_info_decorator
def example_function():
    """这是示例函数的文档字符串"""
    print("函数执行中")

print(f"函数名: {example_function.__name__}")
print(f"文档字符串: {example_function.__doc__}")
example_function()

3.2 类装饰器

除了函数装饰器，我们还可以使用类来实现装饰器。类装饰器通过实现__call__方法来实现可调用对象。

class ClassDecorator:
    def __init__(self, func):
        self.func = func
        self.call_count = 0
    
    def __call__(self, *args, **kwargs):
        self.call_count += 1
        print(f"函数第 {self.call_count} 次被调用")
        return self.func(*args, **kwargs)

@ClassDecorator
def say_hello():
    print("Hello!")

say_hello()
say_hello()

3.3 多个装饰器的使用

一个函数可以同时使用多个装饰器，它们的执行顺序是从下往上（或从里到外）。

def decorator1(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print("装饰器1 - 前")
        result = func(*args, **kwargs)
        print("装饰器1 - 后")
        return result
    return wrapper

def decorator2(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print("装饰器2 - 前")
        result = func(*args, **kwargs)
        print("装饰器2 - 后")
        return result
    return wrapper

@decorator1
@decorator2
def test_function():
    print("函数执行")

test_function()

输出结果：

装饰器1 - 前
装饰器2 - 前
函数执行
装饰器2 - 后
装饰器1 - 后

4. 装饰器的实际应用场景

4.1 日志记录

def log_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print(f"[LOG] 开始执行函数: {func.__name__}")
        print(f"[LOG] 参数: args={args}, kwargs={kwargs}")
        try:
            result = func(*args, **kwargs)
            print(f"[LOG] 函数 {func.__name__} 执行成功")
            return result
        except Exception as e:
            print(f"[LOG] 函数 {func.__name__} 执行失败: {e}")
            raise
    return wrapper

@log_decorator
def divide(a, b):
    return a / b

divide(10, 2)
divide(10, 0)

4.2 权限验证

def require_login(func):
    @wraps(func)
    def wrapper(user, *args, **kwargs):
        if not user.get('is_authenticated', False):
            raise PermissionError("用户未登录")
        return func(user, *args, **kwargs)
    return wrapper

@require_login
def view_profile(user):
    print(f"显示用户 {user['username']} 的个人资料")

user1 = {'username': 'Alice', 'is_authenticated': True}
user2 = {'username': 'Bob', 'is_authenticated': False}

view_profile(user1)
view_profile(user2)  # 这里会抛出异常

4.3 缓存装饰器

def cache_decorator(func):
    cache = {}
    
    @wraps(func)
    def wrapper(*args, **kwargs):
        # 创建缓存键
        key = str(args) + str(sorted(kwargs.items()))
        
        if key in cache:
            print(f"从缓存中获取结果")
            return cache[key]
        
        result = func(*args, **kwargs)
        cache[key] = result
        print(f"计算结果并缓存")
        return result
    
    return wrapper

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

print(fibonacci(10))

5. 装饰器的最佳实践

5.1 保持装饰器的通用性

编写装饰器时，应确保它们能够处理各种类型的函数，包括有返回值、无返回值、有参数、无参数等情况。

def universal_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        # 前置处理
        print(f"准备执行函数: {func.__name__}")
        
        # 执行原函数
        result = func(*args, **kwargs)
        
        # 后置处理
        print(f"函数 {func.__name__} 执行完成")
        
        return result
    return wrapper

5.2 调试友好的装饰器

在开发复杂的装饰器时，添加适当的调试信息会很有帮助。

import functools

def debug_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"调试信息: 调用 {func.__name__}")
        print(f"调试信息: 参数 - 位置参数: {args}, 关键字参数: {kwargs}")
        result = func(*args, **kwargs)
        print(f"调试信息: {func.__name__} 返回: {result}")
        return result
    return wrapper