前言时刻

今天学习了装饰器的用法，很早之前就学习过……

来来总结一波：

今天主要就学习了装饰器的作用以及用法

装饰器很重要，建议弄懂。

1、装饰器概念

装饰器顾名思义就是对一个函数装饰一下扩展一个功能，而不改变其函数内部的代码，去掉装饰器不影响原函数的功能，加上就可扩展一个功能。例如：可以把装饰器比作化妆品，化妆品可以使人脸的变得更加好看，但是擦掉化妆品，脸还是脸。只是使用化妆品装饰了下你的脸变得好看了，丝毫没有改变脸的属性。

有人说装饰器有啥用呢？装饰器完美的符合了代码开放封闭原则。

什么是代码开放封闭原则？

  1. 封闭性：对修改是封闭的，扩展的代码情况下，不能修改原函数的代码
  2. 开放性：允许对已经设计好的代码进行扩展功能。

试想一个场景，今天过节气，老板让你给网站扩展一个充1送一活动功能，你的做法是硬扩、软扩、还是智扩？听我细细道来

  1. def charge_money(pay_sum):
  3.     print(f"充值到账：{pay_sum} 元")
  5.     return True
  7. # 1、做活动之前
  8. charge_money(666)
  9. # 已经充值了：666 元

1）硬扩：

  2. def charge_money(pay_sum):
  4.     print(f"活动赠送了：{pay_sum} 元")
  5.     pay_sum = pay_sum * 2
  7.     print(f"充值到账：{pay_sum} 元")
  9.     return True
  12. # 2、做活动 硬扩
  13. charge_money(666)
  15. # 活动赠送了：666 元
  16. # 充值到账：1332 元

这里有个问题，那就是更改了原函数的内容，不符合封闭性原则。

2）软扩：

  1. # 3、软扩
  4. def salse_activity(pay_sum):
  5.     print(f"活动赠送了：{pay_sum} 元")
  7.     # 此处省去代码：更新数据库的用户金额
  8.     return True
  11. def charge_money(pay_sum):
  13.     print(f"充值到账：{pay_sum} 元")
  15.     # 此处省去代码：更新数据库的用户金额
  16.     return True
  19. salse_activity(666)
  20. charge_money(666)
  22. # 活动赠送了：666 元
  23. # 充值到账：666 元

软扩是在原基础上新添加了一个函数，相当于是扩展了一个功能。但是又有一个问题了，如果你同时在若干 n 个充值函数都添加充一送一活动，那么就需要写 n 次 salse_activity(666) ，那就很不美观。那么有请今天的主角装饰器，闪亮登场。

3）智扩：

  2. # 智扩 装饰器
  5. def salse_activity(func):
  6.     """其实就是闭包"""
  7.     def inner(pay_sum):
  8.         print(f"活动赠送了：{pay_sum} 元")
  9.         # 此处省去代码：更新数据库的用户金额
  11.         res = func(pay_sum)
  12.         return res
  14.     return inner
  17. def charge_money(pay_sum):
  19.     print(f"充值到账：{pay_sum} 元")
  21.     # 此处省去代码：更新数据库的用户金额
  22.     return True
  24. charge_money = salse_activity(charge_money)
  25. charge_money(666)
  28. # 活动赠送了：666 元
  29. # 充值到账：666 元

使用 Python 的装饰器语法糖变形有：

  2. # 装饰器 语法糖
  5. def salse_activity(func):
  6.     """其实就是闭包"""
  7.     def inner(pay_sum):
  9.         print(f"活动赠送了：{pay_sum} 元")
  10.         # 此处省去代码：更新数据库的用户金额
  12.         res = func(pay_sum)
  13.         return res
  15.     return inner
  18. @salse_activity    # 就等于是 charge_money = salse_activity(charge_money)
  19. def charge_money(pay_sum):
  21.     print(f"充值到账：{pay_sum} 元")
  23.     # 此处省去代码：更新数据库的用户金额
  24.     return True
  27. charge_money(666)
  29. # 活动赠送了：666 元
  30. # 充值到账：666 元

装饰器的引入就介绍完了，下面介绍装饰器的具体用法。

2、装饰器参数

装饰器的参数一般会配合*args和**kwargs，看起来更加简介明了。

  1. # 初始化
  3. def decorate_A(func):
  5.     print("我是装饰器A")
  6.     def inner_A(*args):
  7.         print("装饰器A被调用")
  8.         res = func(*args)
  9.         print(f"resA:{res}")
  10.         return res + " + 装饰器A 返回值"
  12.     return inner_A
  15. def decorate_B(func):
  17.     print("我是装饰器B")
  18.     def inner_B(*args):
  19.         print("装饰器B被调用")
  20.         res = func(*args)
  21.         print(f"resB:{res}")
  22.         return res
  24.     return inner_B

给函数添加装饰器并调用传参：

  1. @decorate_A   # main_func=decorate_A(main_func) = inner_A
  2. def main_func(*args):
  3.     print("我是主函数")
  4.     print(args)
  5.     return True
  7. main_func(*[1, 2, 3], 4, *(5, 6, 7))
  9. """
  10. 我是装饰器A
  11. 装饰器A被调用
  12. 我是主函数
  13. (1, 2, 3, 4, 5, 6, 7)
  14. resA:True
  15. """

以上涉及到*args，如果不懂得话，可以看我的另一篇博客：args和*args，

3、多层装饰器

多层装饰器是从下往上依次执行，需要注意的是，被装饰的函数名所指代的函数是一直被装饰器中的内层函数所取代。

  1. # 3. main_func = decorate_A(inner_B)(*args)
  2. @decorate_A   # 2. main_func=decorate_A(inner_B) = inner_A
  3. @decorate_B   # 1. main_func=decorate_B(main_func) = inner_B
  4. def main_func(*args):
  5.     print("我是主函数")
  6.     print(args)
  7.     return "主函数"
  10. res = main_func(*[1, 2, 3], 4, *(5, 6, 7))
  11. print(res)
  13. """
  14. 我是装饰器B
  15. 我是装饰器A
  16. 装饰器A被调用
  17. 装饰器B被调用
  18. 我是主函数
  19. main_func:(1, 2, 3, 4, 5, 6, 7)
  20. resB:True
  21. resA:True
  22. 主函数 + 装饰器A 返回值
  23. """

解释下上面的两个装饰器怎么调用的。

首先：

  1. 调用函数，main_func(*[1, 2, 3], 4, *(5, 6, 7))
  2. 装饰器从下到上执行，先执行@decorate_B，main_func 就变成main_func = decorate_B(main_func) = inner_B。打印结果分析：这一步由于调用了decorate_B函数，所以就打印了我是装饰器B
  3. 然后执行装饰器@decorate_A，此时有main_func = decorate_A(main_func)，但是在上一步装饰器中main_func已经变成innder_B，所有main_func = decorate_A(inner_B)。
    打印结果分析：这一步由于调用了decorate_A函数，所以就打印了我是装饰器A
  4. 最后有main_func = decorate_A(inner_B)(*args)。打印结果分析：1）当调用函数 main_func 时，先执行函数 inner_A，单后打印装饰器A被调用。2）然后执行传入的参数 inner_B 函数，此时打印装饰器B被调用。3）执行 inner_B 函数中的函数其实就是被装饰的函数main_func，打印我是主函数，然后打印main_func:(1, 2, 3, 4, 5, 6, 7)。
  5. 解释完毕

多层装饰器.png

总结：

装饰器很重要，个人觉得装饰器的设计实在是太巧妙了，但是有点绕不容易理解，建议多看多练多总结。