Python装饰器的高级用法：动态装饰器与参数传递

蒙娜丽宁

已于 2025-01-09 16:45:53 修改

阅读量1.3k

点赞数 28

CC 4.0 BY-SA版权

分类专栏： Python杂谈文章标签： python 开发语言

于 2025-01-03 12:48:31 首次发布

本文链接：https://blog.csdn.net/nokiaguy/article/details/144907813

Python杂谈专栏收录该内容

373 篇文章

订阅专栏

Python装饰器是提升代码可重用性和可读性的强大工具，广泛应用于函数和类的增强。然而，随着项目规模的扩大和需求的复杂化，基础装饰器的功能已难以满足开发者的需求。本文深入探讨了Python装饰器的高级用法，重点介绍了动态装饰器的创建与应用、装饰器参数的传递机制，以及如何在运行时动态修改被装饰函数的行为。通过详细的数学公式解释、丰富的代码示例和全面的中文注释，本文旨在帮助开发者全面掌握装饰器的高级特性，提升代码的灵活性和维护性。文章还涵盖了装饰器在实际项目中的应用场景，展示了其在日志记录、权限控制、性能监测等方面的强大功能。无论是初学者还是有经验的Python开发者，都能从中受益，进一步提升编程技能和代码质量。

引言

在Python编程中，装饰器（Decorator）是一种语法结构，用于在不修改函数或类定义的情况下，动态地为其添加额外的功能。装饰器本质上是一个高阶函数，它接收一个函数作为输入，并返回一个新的函数。装饰器广泛应用于日志记录、权限控制、缓存机制等场景，极大地提高了代码的可重用性和可维护性。

尽管基本装饰器的使用已经非常强大，但在复杂项目中，开发者往往需要更为灵活和动态的装饰器功能。例如，动态创建装饰器、在装饰器中传递参数，以及在运行时根据不同条件修改被装饰函数的行为。这些高级用法不仅可以提升代码的灵活性，还能显著增强代码的功能性和可扩展性。

本文将深入探讨Python装饰器的高级用法，重点介绍动态装饰器的创建与应用、装饰器参数的传递机制，以及如何在运行时动态修改被装饰函数的行为。通过详细的数学公式解释、丰富的代码示例和全面的中文注释，本文旨在帮助开发者全面掌握装饰器的高级特性，提升代码的灵活性和维护性。

装饰器基础回顾

在深入高级用法之前，回顾一下装饰器的基本概念和使用方法是必要的。装饰器本质上是一个函数，它接受另一个函数作为参数，并返回一个新的函数。最常见的装饰器用法是使用@decorator语法，将装饰器应用于函数或类。

简单装饰器示例

# 定义一个简单的装饰器
def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("函数执行前的操作")
        result = func(*args, **kwargs)
        print("函数执行后的操作")
        return result
    return wrapper

# 使用装饰器
@my_decorator
def say_hello(name):
    print(f"Hello, {name}!")

# 调用被装饰的函数
say_hello("Alice")

输出:

函数执行前的操作
Hello, Alice!
函数执行后的操作

在这个例子中，my_decorator是一个装饰器，它在被装饰函数执行前后分别打印一条消息。通过@my_decorator语法，将装饰器应用于say_hello函数，增强了该函数的功能，而无需修改其内部实现。

动态装饰器的概念

动态装饰器指的是在运行时根据特定条件动态创建和应用的装饰器。这种装饰器可以根据不同的需求和环境，灵活地修改被装饰函数的行为。动态装饰器的创建通常涉及闭包（Closure）和高阶函数的使用，使得装饰器能够在运行时接收和处理动态参数。

动态装饰器的应用场景

日志记录：根据不同的日志级别动态调整日志的详细程度。
权限控制：根据用户的权限动态决定是否允许执行某些操作。
性能监测：根据系统负载动态调整监测的频率和详细程度。
缓存机制：根据函数的输入参数动态决定是否使用缓存结果。

通过动态装饰器，开发者可以实现更加灵活和智能的功能增强，提升代码的适应性和可扩展性。

动态装饰器的实现

实现动态装饰器的关键在于设计一个能够接受动态参数的装饰器工厂。装饰器工厂本身是一个函数，返回一个实际的装饰器。通过这种方式，装饰器可以在创建时接收参数，并在运行时根据这些参数调整其行为。

装饰器工厂的基本结构

def decorator_factory(param1, param2):
    def actual_decorator(func):
        def wrapper(*args, **kwargs):
            # 根据param1和param2调整行为
            print(f"参数1: {param1}, 参数2: {param2}")
            return func(*args, **kwargs)
        return wrapper
    return actual_decorator

使用装饰器工厂

@decorator_factory("值1", "值2")
def my_function():
    print("这是被装饰的函数。")

my_function()

输出:

参数1: 值1, 参数2: 值2
这是被装饰的函数。

在这个例子中，decorator_factory是一个装饰器工厂，接受两个参数param1和param2，并返回一个实际的装饰器actual_decorator。当@decorator_factory("值1", "值2")应用于my_function时，装饰器根据传入的参数调整其行为，在函数执行前打印相关信息。

装饰器参数传递机制

在实际应用中，装饰器往往需要接受外部参数，以便根据不同的需求调整其行为。装饰器参数的传递机制涉及多层嵌套的函数定义，以确保装饰器能够正确地接收和处理传入的参数。

装饰器接受参数的实现

要使装饰器接受参数，需要使用三层嵌套函数：

装饰器工厂：接受外部参数，并返回实际的装饰器。
实际装饰器：接受被装饰的函数，并返回包装函数。
包装函数：执行装饰器的具体功能，并调用被装饰的函数。

示例：带参数的装饰器

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

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

greet("Bob")

输出:

执行第 1 次
Hello, Bob!
执行第 2 次
Hello, Bob!
执行第 3 次
Hello, Bob!

在这个例子中，repeat是装饰器工厂，接受参数num_times，用于指定被装饰函数的执行次数。decorator_repeat是实际的装饰器，wrapper是包装函数，负责执行重复逻辑并调用被装饰的函数。

多参数装饰器示例

def logger(level, message):
    def decorator_logger(func):
        def wrapper(*args, **kwargs):
            print(f"[{level}] {message}")
            return func(*args, **kwargs)
        return wrapper
    return decorator_logger

@logger(level="INFO", message="开始执行函数")
def add(a, b):
    return a + b

result = add(5, 7)
print(f"结果: {result}")

输出:

[INFO] 开始执行函数
结果: 12

此示例中，logger装饰器工厂接受两个参数level和message，用于日志记录。装饰器在函数执行前打印日志信息，并调用被装饰的add函数。

修改函数行为的高级装饰器

装饰器不仅可以在函数执行前后添加操作，还可以在运行时动态地修改被装饰函数的行为。这包括但不限于：

条件执行：根据特定条件决定是否执行被装饰函数。
参数验证：在函数执行前验证输入参数的合法性。
返回值处理：在函数执行后对返回值进行处理或转换。
异常处理：在函数执行过程中捕获和处理异常。

条件执行装饰器

def conditional_execute(condition):
    def decorator_conditional(func):
        def wrapper(*args, **kwargs):
            if condition():
                print("条件满足，执行函数。")
                return func(*args, **kwargs)
            else:
                print("条件不满足，跳过函数执行。")
        return wrapper
    return decorator_conditional

# 定义一个条件函数
def is_user_authenticated():
    # 假设用户未认证
    return False

@conditional_execute(is_user_authenticated)
def secure_action():
    print("执行安全操作。")

secure_action()

输出:

条件不满足，跳过函数执行。

在这个例子中，conditional_execute装饰器工厂接受一个条件函数condition，在运行时根据条件函数的返回值决定是否执行被装饰的secure_action函数。

参数验证装饰器

def validate_params(param_types):
    def decorator_validate(func):
        def wrapper(*args, **kwargs):
            for arg, expected_type in zip(args, param_types):
                if not isinstance(arg, expected_type):
                    raise TypeError(f"参数 {arg} 的类型应为 {expected_type.__name__}")
            return func(*args, **kwargs)
        return wrapper
    return decorator_validate

@validate_params([int, int])
def multiply(a, b):
    return a * b

print(multiply(3, 4))  # 输出: 12
print(multiply(3, "4"))  # 引发TypeError

输出:

12
Traceback (most recent call last):
  ...
TypeError: 参数 4 的类型应为 int

此装饰器validate_params用于在函数执行前验证参数的类型，确保传入的参数符合预期的类型要求，提高了函数的健壮性和可靠性。

返回值处理装饰器

def uppercase_return(func):
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        if isinstance(result, str):
            return result.upper()
        return result
    return wrapper

@uppercase_return
def greet(name):
    return f"Hello, {name}!"

print(greet("Charlie"))  # 输出: HELLO, CHARLIE!

该装饰器uppercase_return在函数执行后检查返回值类型，如果是字符串，则将其转换为大写形式。这展示了装饰器在函数返回值处理方面的应用。

异常处理装饰器

def exception_handler(exception_type, handler):
    def decorator_exception(func):
        def wrapper(*args, **kwargs):
            try:
                return func(*args, **kwargs)
            except exception_type as e:
                print(f"捕获到异常: {e}")
                return handler(e)
        return wrapper
    return decorator_exception

def handle_zero_division(e):
    return "除零错误已处理。"

@exception_handler(ZeroDivisionError, handle_zero_division)
def divide(a, b):
    return a / b

print(divide(10, 2))  # 输出: 5.0
print(divide(10, 0))  # 输出: 捕获到异常: division by zero
                       #       除零错误已处理。

exception_handler装饰器用于捕获特定类型的异常，并调用自定义的异常处理函数handler，从而优雅地处理错误，避免程序因未处理的异常而中断。

动态装饰器的高级示例

结合上述高级用法，下面通过一个复杂的示例展示如何创建一个动态装饰器，该装饰器能够根据传入参数动态调整函数的执行次数、日志记录级别，并在函数执行前后进行条件判断。

示例：综合动态装饰器

import functools
import time

def dynamic_decorator(repeat_times=1, log_level="INFO", condition=lambda: True):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            if condition():
                print(f"[{log_level}] 开始执行函数 '{func.__name__}'")
                for i in range(repeat_times):
                    print(f"[{log_level}] 执行第 {i+1} 次")
                    result = func(*args, **kwargs)
                print(f"[{log_level}] 函数 '{func.__name__}' 执行完毕")
                return result
            else:
                print(f"[{log_level}] 条件不满足，跳过函数 '{func.__name__}' 执行")
        return wrapper
    return decorator

# 定义一个条件函数
def check_time():
    current_hour = time.localtime().tm_hour
    # 仅在工作时间执行
    return 9 <= current_hour <= 17

@dynamic_decorator(repeat_times=3, log_level="DEBUG", condition=check_time)
def fetch_data():
    print("Fetching data from the server...")
    return {"data": [1, 2, 3]}

# 调用被装饰的函数
data = fetch_data()
print(data)

输出（假设在工作时间内）:

[DEBUG] 开始执行函数 'fetch_data'
[DEBUG] 执行第 1 次
Fetching data from the server...
[DEBUG] 执行第 2 次
Fetching data from the server...
[DEBUG] 执行第 3 次
Fetching data from the server...
[DEBUG] 函数 'fetch_data' 执行完毕
{'data': [1, 2, 3]}

在此示例中，dynamic_decorator装饰器工厂接受三个参数：

repeat_times：指定函数的执行次数。
log_level：指定日志记录的级别。
condition：一个函数，用于决定是否执行被装饰的函数。

通过这些参数，装饰器在运行时动态调整函数的执行行为，实现了高度的灵活性和可配置性。

装饰器中的数学公式应用

在某些高级应用中，装饰器可能需要执行复杂的数学计算或逻辑操作。例如，性能监测装饰器可能需要计算函数的执行时间，甚至进行统计分析。下面通过一个示例展示如何在装饰器中应用数学公式，并使用LaTeX表示这些公式。

示例：性能监测装饰器

import functools
import time
import math

def performance_monitor(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        elapsed_time = end_time - start_time
        # 计算执行时间的平方
        squared_time = math.pow(elapsed_time, 2)
        print(f"函数 '{func.__name__}' 执行时间: {elapsed_time:.6f} 秒")
        print(f"执行时间的平方: {squared_time:.6f} 秒²")
        return result
    return wrapper

@performance_monitor
def compute_factorial(n):
    return math.factorial(n)

# 调用被装饰的函数
fact = compute_factorial(100000)
print(f"100000的阶乘计算完成。")

输出:

函数 'compute_factorial' 执行时间: 0.012345 秒
执行时间的平方: 0.000152 秒²
100000的阶乘计算完成。

在这个示例中，performance_monitor装饰器用于监测被装饰函数的执行时间，并计算其平方。这里的数学公式可以表示为：

$\text{执行时间平方} = (\text{结束时间} - \text{开始时间})^2$

通过在装饰器中应用数学公式，开发者可以实现更加复杂和精细的功能，例如性能分析、统计计算等。

装饰器的类实现

除了使用函数来实现装饰器，Python还允许使用类来实现装饰器。这种方法可以提供更高的灵活性和状态管理能力，特别适用于需要维护内部状态或配置的装饰器。

使用类实现装饰器

import functools

class TimerDecorator:
    def __init__(self, log_level="INFO"):
        self.log_level = log_level

    def __call__(self, func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            print(f"[{self.log_level}] 开始计时 '{func.__name__}'")
            start_time = time.time()
            result = func(*args, **kwargs)
            end_time = time.time()
            elapsed = end_time - start_time
            print(f"[{self.log_level}] 函数 '{func.__name__}' 执行时间: {elapsed:.6f} 秒")
            return result
        return wrapper

@TimerDecorator(log_level="DEBUG")
def process_data(data):
    time.sleep(1)  # 模拟耗时操作
    return [d * 2 for d in data]

# 调用被装饰的函数
processed = process_data([1, 2, 3, 4])
print(processed)

输出:

[DEBUG] 开始计时 'process_data'
[DEBUG] 函数 'process_data' 执行时间: 1.000123 秒
[2, 4, 6, 8]

在这个例子中，TimerDecorator是一个类，用于实现计时功能。通过定义__init__方法接收参数log_level，以及__call__方法实现装饰器逻辑，类装饰器能够在运行时根据实例的状态调整其行为。

装饰器类中的状态管理

类装饰器的一个显著优势是能够维护内部状态。例如，记录被装饰函数的调用次数：

class CallCounter:
    def __init__(self):
        self.count = 0

    def __call__(self, func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            self.count += 1
            print(f"函数 '{func.__name__}' 已被调用 {self.count} 次")
            return func(*args, **kwargs)
        return wrapper

counter = CallCounter()

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

greet("Alice")
greet("Bob")
greet("Charlie")

输出:

函数 'greet' 已被调用 1 次
Hello, Alice!
函数 'greet' 已被调用 2 次
Hello, Bob!
函数 'greet' 已被调用 3 次
Hello, Charlie!

通过类装饰器，开发者可以轻松地在装饰器中维护和管理状态信息，实现更为复杂和动态的功能。

装饰器的链式应用

在实际开发中，常常需要将多个装饰器应用于同一个函数，以实现多层功能增强。这种装饰器的链式应用要求每个装饰器能够正确地传递和处理函数的调用和返回值。

装饰器链式应用示例

def decorator_a(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print("装饰器A: 函数执行前")
        result = func(*args, **kwargs)
        print("装饰器A: 函数执行后")
        return result
    return wrapper

def decorator_b(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print("装饰器B: 函数执行前")
        result = func(*args, **kwargs)
        print("装饰器B: 函数执行后")
        return result
    return wrapper

@decorator_a
@decorator_b
def say_hi():
    print("Hi!")

say_hi()

输出:

装饰器A: 函数执行前
装饰器B: 函数执行前
Hi!
装饰器B: 函数执行后
装饰器A: 函数执行后

在这个示例中，decorator_a和decorator_b分别被应用于say_hi函数。装饰器的应用顺序是从下到上，即decorator_b首先应用于say_hi，然后decorator_a应用于由decorator_b返回的包装函数。最终调用decorator_a包装后的函数时，会依次执行装饰器A和装饰器B的前后操作。

注意事项

装饰器顺序：装饰器的应用顺序影响最终的执行顺序，开发者需根据功能需求合理安排装饰器的顺序。
保持函数签名：使用functools.wraps装饰器可以保留被装饰函数的元数据（如名称、文档字符串等），提高代码的可读性和可维护性。
避免装饰器冲突：确保多个装饰器之间的功能不会互相冲突，保持装饰器的独立性和模块化。

装饰器的性能优化

虽然装饰器带来了代码的灵活性和可重用性，但不当使用可能引入性能开销，尤其是在嵌套装饰器或频繁调用的场景中。以下是一些装饰器性能优化的建议：

使用`functools.wraps`

functools.wraps不仅有助于保留函数的元数据，还能提升装饰器的性能，通过减少额外的函数调用开销。

import functools

def optimized_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        # 装饰器逻辑
        return func(*args, **kwargs)
    return wrapper

减少装饰器内部的计算

在装饰器内部，尽量减少不必要的计算和操作，将复杂的逻辑尽可能放在外部或条件满足时执行。

def lightweight_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        # 仅在必要时执行装饰器逻辑
        if some_condition:
            perform_heavy_operation()
        return func(*args, **kwargs)
    return wrapper

缓存装饰器结果

对于一些计算密集型的装饰器，可以考虑缓存其结果，避免重复计算。

from functools import lru_cache

def cached_decorator(func):
    cached_func = lru_cache(maxsize=None)(func)
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        return cached_func(*args, **kwargs)
    return wrapper

@cached_decorator
def compute(n):
    # 复杂计算
    return n * n

通过缓存结果，可以显著提升装饰器的执行效率，尤其是在函数调用频繁且参数重复的情况下。

实际应用中的装饰器案例

为了更好地理解装饰器的高级用法，以下将介绍几个实际项目中常见的装饰器应用案例，包括日志记录、权限控制和性能监测。

日志记录装饰器

日志记录是软件开发中不可或缺的一部分，装饰器可以轻松地为函数添加日志记录功能，记录函数的调用、参数和返回值。

import functools
import logging

# 配置日志
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')

def log_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        logging.debug(f"调用函数: {func.__name__}，参数: args={args}, kwargs={kwargs}")
        result = func(*args, **kwargs)
        logging.debug(f"函数 {func.__name__} 返回: {result}")
        return result
    return wrapper

@log_decorator
def add(a, b):
    return a + b

# 调用被装饰的函数
add(10, 20)

日志输出:

2024-04-01 10:00:00,000 - DEBUG - 调用函数: add，参数: args=(10, 20), kwargs={}
2024-04-01 10:00:00,001 - DEBUG - 函数 add 返回: 30

通过log_decorator，每次调用add函数时，都会自动记录调用的参数和返回值，极大地简化了日志记录的工作。

权限控制装饰器

在Web应用或企业级应用中，权限控制是确保系统安全的重要手段。装饰器可以用于检查用户权限，决定是否允许函数执行。

import functools

def require_permission(permission):
    def decorator_permission(func):
        @functools.wraps(func)
        def wrapper(user, *args, **kwargs):
            if user.has_permission(permission):
                print(f"用户 {user.name} 拥有权限 '{permission}'，允许执行函数。")
                return func(user, *args, **kwargs)
            else:
                print(f"用户 {user.name} 缺少权限 '{permission}'，拒绝执行函数。")
                return None
        return wrapper
    return decorator_permission

# 用户类示例
class User:
    def __init__(self, name, permissions):
        self.name = name
        self.permissions = permissions

    def has_permission(self, permission):
        return permission in self.permissions

@require_permission("admin")
def delete_user(user, user_id):
    print(f"用户 {user.name} 删除了用户 {user_id}。")

# 创建用户实例
admin_user = User("Alice", ["admin", "editor"])
regular_user = User("Bob", ["editor"])

# 调用被装饰的函数
delete_user(admin_user, 123)   # 允许执行
delete_user(regular_user, 456) # 拒绝执行

输出:

用户 Alice 拥有权限 'admin'，允许执行函数。
用户 Alice 删除了用户 123。
用户 Bob 缺少权限 'admin'，拒绝执行函数。

require_permission装饰器根据用户是否拥有指定权限，决定是否执行被装饰的delete_user函数，从而实现了灵活的权限控制机制。

性能监测装饰器

性能监测对于优化代码性能和资源利用率至关重要。装饰器可以用于自动记录函数的执行时间和资源消耗情况。

import functools
import time

def performance_monitor(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        print(f"开始执行函数 '{func.__name__}'")
        result = func(*args, **kwargs)
        end_time = time.time()
        elapsed = end_time - start_time
        print(f"函数 '{func.__name__}' 执行时间: {elapsed:.6f} 秒")
        return result
    return wrapper

@performance_monitor
def heavy_computation(n):
    total = 0
    for i in range(n):
        total += i ** 2
    return total

# 调用被装饰的函数
result = heavy_computation(1000000)
print(f"计算结果: {result}")

输出:

开始执行函数 'heavy_computation'
函数 'heavy_computation' 执行时间: 0.123456 秒
计算结果: 333332833333500000

通过performance_monitor装饰器，开发者可以轻松地监测函数的执行时间，帮助识别和优化性能瓶颈。

结合装饰器与其他Python特性

装饰器作为Python语言的高级特性，可以与其他特性如闭包、生成器、上下文管理器等结合使用，进一步增强代码的功能和灵活性。

装饰器与闭包

闭包是指函数内部定义的函数可以访问外部函数的变量。装饰器的实现常依赖闭包来保持装饰器的状态和参数。

def multiplier(factor):
    def decorator_mult(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            result = func(*args, **kwargs)
            return result * factor
        return wrapper
    return decorator_mult

@multiplier(10)
def get_number():
    return 5

print(get_number())  # 输出: 50

在这个例子中，multiplier利用闭包机制，将factor参数保存并在wrapper函数中使用，实现了动态调整函数返回值的功能。

装饰器与生成器

装饰器也可以用于生成器函数，增强其功能，例如添加日志记录或性能监测。

def generator_logger(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"生成器 '{func.__name__}' 开始执行。")
        gen = func(*args, **kwargs)
        for value in gen:
            print(f"生成器 '{func.__name__}' 生成值: {value}")
            yield value
        print(f"生成器 '{func.__name__}' 执行完毕。")
    return wrapper

@generator_logger
def countdown(n):
    while n > 0:
        yield n
        n -= 1

# 使用被装饰的生成器
for number in countdown(3):
    print(f"收到数字: {number}")

输出:

生成器 'countdown' 开始执行。
生成器 'countdown' 生成值: 3
收到数字: 3
生成器 'countdown' 生成值: 2
收到数字: 2
生成器 'countdown' 生成值: 1
收到数字: 1
生成器 'countdown' 执行完毕。

通过generator_logger装饰器，生成器函数countdown的执行过程被详细记录，方便调试和性能分析。

装饰器与上下文管理器

尽管装饰器和上下文管理器在功能上有所不同，但两者可以结合使用，以实现更为复杂的功能增强。例如，在函数执行前后自动管理资源。

from contextlib import contextmanager

@contextmanager
def resource_manager(resource_name):
    print(f"获取资源: {resource_name}")
    yield
    print(f"释放资源: {resource_name}")

def with_resource(resource_name):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            with resource_manager(resource_name):
                return func(*args, **kwargs)
        return wrapper
    return decorator

@with_resource("数据库连接")
def query_database(query):
    print(f"执行查询: {query}")
    return {"result": "数据"}

# 调用被装饰的函数
result = query_database("SELECT * FROM users")
print(result)

输出:

获取资源: 数据库连接
执行查询: SELECT * FROM users
释放资源: 数据库连接
{'result': '数据'}

通过结合上下文管理器，with_resource装饰器能够在函数执行前后自动获取和释放资源，确保资源的正确管理和释放。

结论

Python装饰器作为一种强大的高级特性，极大地提升了代码的灵活性和可维护性。本文深入探讨了装饰器的高级用法，包括动态装饰器的创建与应用、装饰器参数的传递机制，以及在运行时动态修改被装饰函数的行为。通过丰富的代码示例和详细的中文注释，展示了装饰器在日志记录、权限控制、性能监测等实际项目中的应用场景。

此外，本文还探讨了装饰器与其他Python特性的结合使用，如闭包、生成器和上下文管理器，进一步扩展了装饰器的应用范围。通过合理地使用装饰器，开发者可以编写出更加简洁、高效和可维护的代码，提升项目的整体质量和开发效率。

随着项目需求的不断增长和复杂性的提升，掌握装饰器的高级用法将成为每个Python开发者必备的技能。希望本文能够为读者提供全面而深入的装饰器知识，助力开发者在实际项目中灵活应用装饰器，解决复杂问题，优化代码结构。