引子

你现在有一个任务，需要统计开发人员编写的代码的性能（比如每个函数执行时间），你会怎么做呢？

1. 在每个函数头和函数尾部添加时间，并进行减法运算

    import time
    def func1():
        start = time.time()
        print('in func1')
        print(time.time() - start)

    func1()

2. 在原本的代码上添加计算时间的语句

    import time
    def func1():
        print('in func1')

    start = time.time()
    func1()
    print(time.time() - start)

3. 提供一个带有变量的函数，直接调用该函数来进行统计

    import time
    def timer(func):
        start = time.time()
        func()
        print(time.time() - start)

    def func1():
        print('in func1')

    def func2():
        print('in func2')

    timer(func1)
    timer(func2)

4. 有没有一种方式我直接调用func1 的时候，能够实现调用timer 方法的效果, 你应该会想到闭包函数

    import time
    def timer(func):
        def inner():
            start = time.time()
            func()
            print(time.time() - start)
        return inner

    def func1():
        print('in func1')

    func1 = timer(func1)
    func1()

在这里，装饰器的雏形就出来了，但我们每次调用的时候还要做一次赋值，这个有没有要的方式解决呢，pyhton 为我们提供了一句语法糖来解决这个问题

import time
    def timer(func):
        def inner():
            start = time.time()
            func()
            print(time.time() - start)
        return inner
    @timer  # 相当于func1 = timer(func1)
    def func1():
        print('in func1')
    func1()

到此，完整的装饰器就完成了。
总结：

1. 装饰器的本质，就是一个闭包函数
2. 装饰器是一种设计模式
3. 装饰器的功能：在不修改原函数及其调用方式的情况下，对原函数功能进行扩展
   有了上面这些信息，我们来定义下什么是装饰器

2 装饰器定义

• 定义：在用于不改变原有函数代码的情况下，增加函数的功能。本质上是一个返回另一个函数的函数，他接收被装饰的函数作为参数，并返回一个新的函数，这个新的函数会在原有的函数基础上添加一些额外的功能

3 装饰器的基本语法

• 语法：装饰器使用@ 符号来应用，定位于函数定义之前。

def decorator(func):
    def inner(*args,**kwargs):
        result = func(*args,**kwargs)
        return result
    return inner

@decorator
def func1():
    pass
func1()

4 带参数的装饰器

有时，我们希望装饰器能够接受参数。为了实现这一点，我们可以定义一个外部函数来创建装饰器。这个外部函数接收装饰器的参数，并返回实际的装饰器函数。

def my_decorator_with_args(decorator_arg):
    def decorator(func):
        def wrapper(*args, **kwargs):
            print(f"Decorator argument: {decorator_arg}")
            result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@my_decorator_with_args("Hello from decorator!")
def say_hello():
    print("Hello!")

say_hello()

5 装饰器的陷阱

1. 保持函数签名：装饰器应该尽可能保持原有函数的签名不变，这意味着如果原函数接受n个参数，装饰器返回的函数也应当接受n个参数。
2. 考虑异常处理：装饰器内部的代码可能会抛出异常，这会阻止原有函数的执行。因此，装饰器应当妥善处理可能出现的异常。
3. 避免全局变量：在装饰器中使用全局变量可能会导致不可预见的问题，尤其是在多线程环境中。
4. 使用`functools.wraps`：functools.wraps是一个实用的装饰器，用于解决闭包内函数属性丢失的问题。它将被装饰函数的name__`、`_doc_`、`__module等属性复制到装饰器返回的新函数上。

from functools import wraps

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

6 装饰器的应用场景

1. 日志记录：在函数调用前后添加日志记录。
2. 性能测试：测量函数执行时间。
3. 事务处理：在数据库操作函数前后添加事务开启和提交。
4. 权限检查：在执行某些操作前进行权限验证。
5. 缓存：缓存函数的结果以提高性能。

7 装饰器实例

使用装饰器实现一个简单的缓存机制通常涉及到将函数的结果存储起来，以便在下一次相同的输入参数被传递给函数时，可以直接返回之前计算的结果，而不是重新执行函数。这种技术被称为“记忆化”（memoization）。

下面是一个简单的装饰器实现缓存机制的例子：

import functools

def memoize(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        # 创建一个缓存字典，如果已经计算过结果，就直接返回
        cache_key = (args, tuple(kwargs.items()))
        if cache_key not in wrapper.cache:
            wrapper.cache[cache_key] = func(*args, **kwargs)
        return wrapper.cache[cache_key]
    wrapper.cache = {}
    return wrapper

@memoize
def fibonacci(n):
    if n in (0, 1):
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(10))  # 第一次计算，结果为55
print(fibonacci(10))  # 第二次调用，直接从缓存中获取结果

在这个例子中，memoize装饰器会检查wrapper.cache字典，看看是否已经计算了给定参数的结果。如果已经计算过，它会直接从缓存中返回结果；如果没有计算过，它会调用原始函数，将结果存储到缓存中，并返回结果。

这个简单的缓存机制有几个关键点：

1. 参数的哈希化：为了将参数存储在字典中，我们需要将参数转换为一个可哈希的键。在这个例子中，我们使用了参数的元组表示形式，包括位置参数和关键字参数的键值对。
2. functools.wraps：这个装饰器用于保持原始函数的元数据（如函数名、文档字符串等）不变。这是一个好习惯，因为它使得使用装饰器的函数更容易理解和调试。
3. 缓存字典：wrapper.cache是一个字典，用于存储已经计算过的结果。字典的键是参数的哈希值，值是函数的计算结果。