Python 魔法学院 - 第09篇：Python 装饰器 ⭐⭐⭐

原创已于 2025-01-16 17:57:19 修改 · 1k 阅读

12 ·

本内容遵循CC 4.0 BY-SA版权协议

凌云

标签

#python #开发语言

于 2025-01-12 13:11:04 首次发布

《Python 魔法学院》专栏收录该内容

35 篇文章

订阅专栏

1. 引言

在 Python 的世界里，装饰器（Decorator）是一种强大的工具，它允许我们在不修改原有函数代码的情况下，动态地增强函数的功能。装饰器就像是给函数穿上了一件“魔法外衣”，让它拥有了新的能力。本文将带你深入探索 Python 装饰器的奥秘，并通过丰富的案例和详细的解释，帮助你掌握这一强大的工具。

2. 装饰器基础

2.1 什么是装饰器？

装饰器本质上是一个函数，它接受一个函数作为参数，并返回一个新的函数。装饰器的作用是在不修改原函数代码的情况下，为函数添加额外的功能。

详细解释：
装饰器的核心思想是“函数是一等公民”。在 Python 中，函数可以像变量一样被传递、赋值和返回。装饰器利用了这一特性，通过接受一个函数作为参数，并返回一个新的函数，来实现对原函数的增强。

比喻：
装饰器就像是一个“包装盒”，你把一个函数放进去，它会给你一个“包装后”的函数。这个“包装后”的函数不仅保留了原函数的功能，还增加了一些额外的功能。

2.2 装饰器的语法

在 Python 中，装饰器使用 @ 符号来应用。例如：

@decorator
def function():
    pass

这等价于：

def function():
    pass
function = decorator(function)

详细解释：
@decorator 是 Python 提供的一种语法糖，它使得装饰器的应用更加简洁和直观。实际上，@decorator 的作用是将 function 传递给 decorator，并将返回的新函数重新赋值给 function。

2.3 装饰器的简单示例

让我们从一个简单的装饰器开始，这个装饰器会在函数执行前后打印一些信息：

def simple_decorator(func):
    def wrapper():
        print("Before function execution")
        func()
        print("After function execution")
    return wrapper

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

say_hello()

结果为：

Before function execution
Hello!
After function execution

详细解释：
在这个例子中，simple_decorator 是一个装饰器，它接受一个函数 func 作为参数，并返回一个新的函数 wrapper。wrapper 函数在调用 func 前后分别打印了一些信息。当我们调用 say_hello() 时，实际上是调用了 wrapper 函数。

内存结构模拟：

原始函数 say_hello 的内存地址：0x1000
装饰后的函数 wrapper 的内存地址：0x2000
调用 say_hello() 时，实际执行的是 wrapper 函数。

3. 装饰器的进阶用法

3.1 带参数的装饰器

有时候，我们希望装饰器本身也能接受参数。这时，我们可以定义一个带参数的装饰器：

def repeat(num_times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(num_times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

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

greet("Alice")

结果为：

Hello, Alice!
Hello, Alice!
Hello, Alice!

详细解释：
在这个例子中，repeat 是一个带参数的装饰器，它接受一个参数 num_times，并返回一个装饰器 decorator。decorator 接受一个函数 func，并返回一个新的函数 wrapper。wrapper 函数会重复调用 func num_times 次。

内存结构模拟：

repeat(num_times=3) 返回 decorator 函数。
decorator(greet) 返回 wrapper 函数。
调用 greet("Alice") 时，实际执行的是 wrapper 函数。

3.2 类装饰器

除了函数装饰器，Python 还支持类装饰器。类装饰器是一个类，它接受一个函数作为参数，并返回一个新的对象：

class ClassDecorator:
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        print("Before function execution")
        result = self.func(*args, **kwargs)
        print("After function execution")
        return result

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

say_hello()

结果为：

Before function execution
Hello!
After function execution

详细解释：
在这个例子中，ClassDecorator 是一个类装饰器，它接受一个函数 func 作为参数，并在 __call__ 方法中定义了装饰器的行为。当我们调用 say_hello() 时，实际上是调用了 ClassDecorator 实例的 __call__ 方法。

内存结构模拟：

ClassDecorator(say_hello) 创建一个 ClassDecorator 实例。
调用 say_hello() 时，实际执行的是 ClassDecorator 实例的 __call__ 方法。

4. 装饰器的实际应用

4.1 日志记录

装饰器常用于日志记录。例如，我们可以定义一个装饰器来记录函数的执行时间和参数：

import time

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

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

slow_function()

结果为：

slow_function executed in 2.0002 seconds

详细解释：
在这个例子中，log_execution_time 装饰器记录了函数的执行时间，并打印出来。wrapper 函数在调用 func 前后分别记录了时间，并计算了执行时间。

内存结构模拟：

log_execution_time(slow_function) 返回 wrapper 函数。
调用 slow_function() 时，实际执行的是 wrapper 函数。

4.2 权限验证

装饰器还可以用于权限验证。例如，我们可以定义一个装饰器来检查用户是否有权限执行某个函数：

def requires_permission(permission):
    def decorator(func):
        def wrapper(*args, **kwargs):
            if check_permission(permission):
                return func(*args, **kwargs)
            else:
                raise PermissionError(f"Permission {permission} required")
        return wrapper
    return decorator

def check_permission(permission):
    # 模拟权限检查
    return permission == "admin"

@requires_permission("admin")
def delete_file(filename):
    print(f"Deleting {filename}...")

delete_file("example.txt")

结果为：

Deleting example.txt...

详细解释：
在这个例子中，requires_permission 装饰器检查用户是否有权限执行 delete_file 函数。如果没有权限，则会抛出 PermissionError。

内存结构模拟：

requires_permission("admin") 返回 decorator 函数。
decorator(delete_file) 返回 wrapper 函数。
调用 delete_file("example.txt") 时，实际执行的是 wrapper 函数。

5. 装饰器的内部机制

5.1 函数的内存结构

为了更好地理解装饰器的工作原理，我们需要了解函数的内存结构。在 Python 中，函数也是一个对象，它有自己的属性和方法。例如，我们可以通过 func.__name__ 获取函数的名称。

详细解释：
函数对象在内存中存储了函数的代码、名称、参数等信息。当我们应用装饰器时，装饰器会返回一个新的函数对象，这个新的函数对象会替换原来的函数。

5.2 装饰器对函数的影响

当我们应用装饰器时，装饰器会返回一个新的函数对象，这个新的函数对象会替换原来的函数。因此，原函数的属性和方法可能会丢失。为了解决这个问题，我们可以使用 functools.wraps 来保留原函数的属性：

from functools import wraps

def simple_decorator(func):
    @wraps(func)
    def wrapper():
        print("Before function execution")
        func()
        print("After function execution")
    return wrapper

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

print(say_hello.__name__)

结果为：

say_hello

详细解释：
在这个例子中，functools.wraps 保留了原函数 say_hello 的属性，因此 say_hello.__name__ 仍然是 say_hello。

内存结构模拟：

simple_decorator(say_hello) 返回 wrapper 函数。
@wraps(func) 保留了 say_hello 的属性。
调用 say_hello() 时，实际执行的是 wrapper 函数。

6. 装饰器的对比

为了帮助读者更好地理解不同类型的装饰器，我们使用 Markdown 表格来对比它们的特性：

装饰器类型	语法示例	适用场景	优点	缺点
简单装饰器	`@decorator`	简单的功能增强	简单易用	功能有限
带参数的装饰器	`@decorator(param)`	需要动态配置的装饰器	灵活性高	语法稍复杂
类装饰器	`@ClassDecorator`	需要复杂逻辑的装饰器	功能强大	实现复杂
保留属性的装饰器	`@wraps(func)`	需要保留原函数属性的装饰器	保留原函数属性	需要额外导入 `functools.wraps`

7. 高级装饰器用法

7.1 异步装饰器

在现代 Python 开发中，异步编程变得越来越重要。我们可以通过装饰器来增强异步函数的功能。例如，定义一个异步装饰器来记录异步函数的执行时间：

import asyncio
import time

def async_timer(func):
    async def wrapper(*args, **kwargs):
        start_time = time.time()
        result = await func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__} executed in {end_time - start_time:.4f} seconds")
        return result
    return wrapper

@async_timer
async def async_task():
    await asyncio.sleep(2)
    print("Async task completed")

asyncio.run(async_task())

结果为：

Async task completed
async_task executed in 2.0002 seconds

详细解释：
在这个例子中，async_timer 是一个异步装饰器，它记录了异步函数的执行时间。wrapper 函数在调用 func 前后分别记录了时间，并计算了执行时间。

内存结构模拟：

async_timer(async_task) 返回 wrapper 函数。
调用 async_task() 时，实际执行的是 wrapper 函数。

7.2 上下文管理器装饰器

装饰器还可以与上下文管理器结合使用，以实现资源管理等功能。例如，定义一个装饰器来自动管理文件的打开和关闭：

from contextlib import contextmanager

@contextmanager
def open_file(name, mode):
    f = open(name, mode)
    try:
        yield f
    finally:
        f.close()

def file_operation(func):
    def wrapper(*args, **kwargs):
        with open_file("example.txt", "w") as f:
            return func(f, *args, **kwargs)
    return wrapper

@file_operation
def write_to_file(file):
    file.write("Hello, World!")

write_to_file()