前面的章节我们简单地了解和使用了装饰器，从本节开始，我们全面讲解它。装饰器是一种Python语法特性，它允许我们在不修改原始函数代码的情况下，通过添加额外的功能来扩展函数的行为。装饰器本质上是一个函数，它接受一个函数作为参数，并返回一个新的函数或可调用对象。

装饰器的语法结构如下所示：

def decorator_func(original_func):
    def wrapper(*args, **kwargs):
        # 在调用原始函数之前执行的代码
        result = original_func(*args, **kwargs)
        # 在调用原始函数之后执行的代码
        return result
    return wrapper

上述代码中，我们定义了一个名为 decorator_func 的装饰器函数，它接受一个 original_func 参数，代表被装饰的原始函数。在装饰器内部，我们定义了一个名为 wrapper 的包装函数，它负责在调用原始函数之前和之后执行额外的代码逻辑。

装饰器函数内部的 wrapper 函数使用 *args 和 **kwargs 来接受任意数量的位置参数和关键字参数，并将它们传递给原始函数。这样，我们可以在不影响原始函数签名的情况下，适应不同参数的函数。

要使用装饰器我们需要将其应用于目标函数，可以使用 @ 符号将装饰器放置在函数定义之前，例如：

@decorator_func
def my_function():
    # 函数的代码逻辑

通过这样的语法，我们将 decorator_func 装饰器应用于 my_function 函数。这也就相当于：

my_function = decorator_func(my_function)

现在，每当我们调用 my_function 时，实际上是调用装饰器返回的 wrapper 函数。在 wrapper 函数中，我们可以添加额外的功能、修改函数的行为，然后调用原始函数，并返回其结果。

装饰器提供了一种灵活的方式来修改函数的行为。我们可以通过装饰器添加额外的功能，例如日志记录、输入验证、性能测试等。本章将介绍如何使用装饰器来修改函数的行为。

例如：

# 一个添加日志记录功能的装饰器
def log_decorator(original_func):
    def wrapper(*args, **kwargs):
        print(f"调用函数 {original_func.__name__}")
        result = original_func(*args, **kwargs)
        print(f"函数 {original_func.__name__} 调用完毕")
        return result
    return wrapper

在上述示例中，我们定义了一个名为 log_decorator 的装饰器函数。它在调用原始函数之前打印一条日志，然后调用原始函数，最后再打印一条日志。现在，让我们使用该装饰器来装饰一个函数：

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

当我们调用 add_numbers 函数时，装饰器会自动添加日志记录的功能：

result = add_numbers(10, 5)

Out[]:

调用函数 add_numbers
函数 add_numbers 调用完毕

print(result)

Out[]: 15

通过装饰器，我们可以在不修改原始函数代码的情况下，增加额外的功能。

又如：

import time

def performance_decorator(original_func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = original_func(*args, **kwargs)
        end_time = time.time()
        execution_time = end_time - start_time
        print(f"函数 {original_func.__name__} 的执行时间为：{execution_time}秒")
        return result
    return wrapper

在上述示例中，我们定义了一个名为 performance_decorator 的装饰器函数。它会在调用原始函数之前记录起始时间，在调用原始函数之后计算执行时间，并打印出来。现在，让我们使用该装饰器来装饰一个函数：

@performance_decorator
def calculate_factorial(n):
    factorial = 1
    for i in range(1, n+1):
        factorial *= i
    return factorial

当我们调用 calculate_factorial 函数时，装饰器会自动计算执行时间并输出：

result = calculate_factorial(10)

Out[]:函数 calculate_factorial 的执行时间为：6.4373016357421875e-06秒

print(result)

Out[]:3628800

通过这个例子我们可以看到，通过使用装饰器我们可以轻松地添加性能测试等额外的功能而无需修改原始函数的代码。

带参数的装饰器是一种更加灵活和可定制的装饰器形式。它允许我们通过在装饰器函数上添加参数，来控制装饰器的行为。在本章中，我们将讨论如何编写带参数的装饰器，并提供一些示例来说明其用法。

例如：

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

本例中我们定义了一个名为 repeat 的装饰器函数，它接受一个参数 num_times。装饰器函数内部定义了另一个函数 decorator_func，它才是真正的装饰器。decorator_func 内部的 wrapper 函数会重复调用原始函数 num_times 次。

我们可以使用带参数的装饰器来装饰一个函数如下：

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

greet("Alice")

Out[]:

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

通过在装饰器上添加参数 num_times=3，我们可以指定 greet 函数被调用的次数。这样，函数体内的打印语句将会重复执行三次。

又如：

import time

def performance_decorator(unit):
    def decorator_func(original_func):
        def wrapper(*args, **kwargs):
            start_time = time.time()
            result = original_func(*args, **kwargs)
            end_time = time.time()
            execution_time = end_time - start_time
            print(f"函数 {original_func.__name__} 的执行时间为：{execution_time}{unit}")
            return result
        return wrapper
    return decorator_func

本例中我们定义了一个名为 performance_decorator 的装饰器函数，它接受一个参数 unit，用于指定执行时间的单位。decorator_func 内部的 wrapper 函数会计算函数执行时间，并在打印时附上指定的单位。

我们可以这样使用：

@performance_decorator(unit="秒")
def calculate_power(base, exponent):
    result = base ** exponent
    time.sleep(1)  # 模拟函数执行的时间
    return result

当我们调用 calculate_power 函数时，装饰器会自动计算执行时间并输出，单位为秒。

result = calculate_power(2, 10)

Out[]:函数 calculate_power 的执行时间为：1.0002830028533936秒

print(result)  # 输出：1024