闭包与函数装饰器之Python装饰器

lsekfe

一、闭包
　　在学习装饰器前，需要先了解闭包的概念。形成闭包的要点：
　　·函数嵌套
　　· 将内部函数作为外部函数的返回值
　　· 内部函数必须要使用到外部函数的变量
　　下面以一个计算列表平均值的案例来讲解闭包：

1. def make_average():
   
2. 　　    # 创建一个列表，用来保存数值
   
3. 　　    nums = []
   
4. 　　    # 定义一个内部函数，用来计算列表的平均值
   
5. 　　    def average(n):
   
6. 　　        # 将数值添加到列表中
   
7. 　　        nums.append(n)
   
8. 　　        # 返回平均值
   
9. 　　        return sum(nums) / len(nums)
   
10. 　　    return average

复制代码

首先，定义一个函数make_average；
　　其次，在make_average函数内定义一个空列表，用来存储数值；
　　再次，定义一个内部函数，用来计算列表平均值；
　　最后，将这个内函数作为外函数make_average的返回值，注意不要加( )，加( )就变成调用这个函数了。

1. 　# 调用外部函数，并将其复制给一个变量，注意：此时返回的是内函数的内存地址
   
2. 　　a = make_average()
   
3. 　　# 给这个变量加()，就相当于调用了内函数average
   
4. 　　print(a(20))
   
5. 　　print(a(30))

复制代码

运行结果如下：当传入的数值为20时，列表中只有一个数，所以计算结果是20；当再传入一个数值30时，此时列表中就有两个数20和30，所以平均值的计算结果是25。

　　二、装饰器
　　1.装饰器引入
　　例如，有以下两个函数，分别计算两个数的和以及成绩：

1. def add(a, b):
   
2. 　　    """计算两数之和"""
   
3. 　　    res = a + b
   
4. 　　    return res
   
5. 　　def mul(a, b):
   
6. 　　    """计算两数之积"""
   
7. 　　    res = a * b
   
8. 　　    return res

复制代码

现在有个需求：我想要在每个函数的计算开始前打印“开始计算...”，在计算结束后打印“计算结束...”。我们可以通过直接修改函数代码的方式来满足这个需求，但这样会面临以下问题：
　　如果要修改的函数过多，十个甚至一百个函数，未免不现实；
　　不便于后期维护，例如我不想打印“开始计算...”了，而是要打印“begin...”，岂不是又要重新修改一遍；
　　违反开闭原则（OCP），即程序的设计，要求开放对程序的扩展、关闭对程序的修改；
　　所以，上述直接修改函数代码的方式不可行。我们希望在不修改原函数的情况下，实现对函数的扩展。例如：

1. 　def new_add(a, b):
   
2. 　　    print("开始计算...")
   
3. 　　    r = add(a, b)
   
4. 　　    print("计算结束...")
   
5. 　　    return r
   
6. 　　print(new_add(22, 33))

复制代码

执行结果如下：

　　这种新创建一个函数的方式虽然没有修改原函数，但面临一个很严重的问题：
　　只能扩展指定函数，不能通用于其它函数，例如扩展上述的add函数，而不能扩展mul函数，如果想要扩展mul函数，只能再创建一个扩展函数；
　　因为，我们希望可以定义一个通用的扩展函数，可以作用域所有函数。这类不改变原函数代码的通用函数就是：装饰器。
　　2.函数装饰器
　　装饰器本质上是一个python函数或类，它可以让其他函数或类在不需要做任何代码修改的前提下增加额外功能，也就是为已经存在的对象添加额外功能，装饰器的返回值也是一个函数/类对象。它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景。
　　1）被装饰函数不带参数
　　例如：

1. def wrapper_info(func):
   
2. 　　    def inner():
   
3. 　　        print("开始介绍...")
   
4. 　　        res = func()
   
5. 　　        print("介绍结束...")
   
6. 　　        return res
   
7. 　　    return inner
   
8. 　　def introduce1():
   
9. 　　    print("我是周润发，我来自HONG KONG")
   
10. 　　info = wrapper_info(introduce1)
    
11. 　　info()

复制代码

运行结果如下：

　　可见，在没有改变原函数代码的情况下，即给原函数增加了一些额外的功能，func是要修饰的函数，作为一个变量传入装饰函数，能够通用于其他函数，这个wrapper_info就是装饰器。但目前面临的问题是，被装饰函数如果带参数怎么办？例如：

1. def introduce2(name, age):
   
2. 　　    print(f"我叫{name}, 我今年{age}岁了")

复制代码

2）被装饰函数带参数
　　尽管可以在装饰器wrapper_info中传入name、age，但并不是每个被装饰的函数都只有name、age，亦或是指定类型的参数，还有可能传入的是字典、列表、元组等。也就是传入参数的类型和数量不固定怎么办？
　　此时就需要用到不定长参数：(*args, **kwargs)

1. 　def wrapper_info(func):
   
2. 　　    """
   
3. 　　    用来对其他函数进行扩展，使其他函数可以在执行前做一些额外的动作
   
4. 　　    :param func: 要扩展的函数对象
   
5. 　　    :return:
   
6. 　　    """
   
7. 　　    def inner(*args, **kwargs):
   
8. 　　        print("开始介绍...")
   
9. 　　        res = func(*args, **kwargs)
   
10. 　　        print("介绍结束...")
    
11. 　　        return res
    
12. 　　    return inner

复制代码

例如：

1. def introduce3(name, age, city):
   
2. 　　    print(f"我叫{name}, 我今年{age}岁了, 我来自{city}")

复制代码

运行结果如下：

　　3）装饰器带参数
　　上述提到的是装饰器，一种是应用于被装饰的函数不带参数，一种是被装饰的函数带参数，那装饰器本身能否带参数呢？比如我定义一个变量，想通过传入不同的值来控制这个装饰器实现不同的功能。答案是肯定的，例如：

1. def use_log(level):
   
2. 　　    def decorator(func):
   
3. 　　        def inner(*args, **kwargs):
   
4. 　　            if level == "warn":
   
5. 　　                logging.warning("%s is running by warning" % func.__name__)
   
6. 　　            elif level == "info":
   
7. 　　                logging.warning("%s is running by info" % func.__name__)
   
8. 　　            else:
   
9. 　　                logging.warning("%s is running by other" % func.__name__)
   
10. 　　            return func(*args, **kwargs)
    
11. 　　        return inner
    
12. 　　    return decorator
    
13. 　　def introduce4(name, age, city):
    
14. 　　    print(f"我叫{name}, 我今年{age}岁了, 我来自{city}")
    
15. 　　info1 = use_log(introduce4('周星驰', 28, '香港'))
    
16. 　　info1('info')
    
17. 　　info2 = use_log(introduce4('周润发', 28, '香港'))
    
18. 　　info2('warn')
    
19. 　　info3 = use_log(introduce4('成龙', 28, '香港'))
    
20. 　　info3('xxx')

复制代码

运行结果如下：

　　3.装饰器调用
　　方式一：以函数方式调用

info3 = wrapper_info(introduce3)
　　info3('刘德华', 28, '香港')

如果是装饰器函数带参数，则调用方式为：

1. info4 = use_log(introduce4('周星驰', 28, '香港'))
   
2. 　　info4('info')

复制代码

方式二：以语法糖方式调用
　　即在被装饰函数上方以@符号进行修饰

1. @wrapper_info
   
2. 　　def introduce3(name, age, city):
   
3. 　　    print(f"我叫{name}, 我今年{age}岁了, 我来自{city}")
   
4. 　　introduce3('刘德华', 28, '香港')

复制代码

如果是装饰器函数带参数，例如上述的use_log，则需要在装饰器中传入参数：

1. 　@use_log('info')
   
2. 　　def introduce4(name, age, city):
   
3. 　　    print(f"我叫{name}, 我今年{age}岁了, 我来自{city}")

复制代码

小结
　　什么是装饰器？
　　在不改变原函数代码的情况下，给原函数增加了一些额外的功能，并且能够通用于其他函数，这样的函数就称作为装饰器。
　　装饰器的调用
　　可以通过传统调用函数的方式进行调用，也可以通过@装饰器的方式调用
　　装饰器的特点
　　通过装饰器，可以在不修改原来函数的情况下对函数进行扩展
　　一个函数可以同时指定多个装饰器