一、初入装饰器

1、首先呢我们有这么一段代码，这段代码假设是N个业务部门的函数

1 def f1(aaa):
2     print('我是F1业务')
3     if aaa == 'f1':
4         return 'ok'
5
6 def f2(aaa):
7     print('我是F2业务')
8     if aaa == 'f2':
9         return 'ok'

业务代码

这里的函数的意思就是当我们调用上面的函数的时候，传入值给aaa，当aaa的值等于f1或者f2就返回ok

2、公司有N个业务部门，1个基础平台部门，基础平台负责提供底层的功能，如：数据库操作、redis调用、监控API等功能。业务部门使用基础功能时，只需调用基础平台提供的功能即可。那么我们业务部门调用功能的时候只需要。

f1（值）

f2（值）

3、公司的运行正在有条不稳的进行，然而有一天呢，你的老大说，我发现了一个问题就是呢业务部调用基础平台的功能的时候没有验证这样不好所以呢老大就把工作交给了LOW们,要求增加验证功能并且业务部门在调用功能的方式不能变

Low A，这个A呢他是这么做的

他呢跟各个做基础功能的人协调，要求在自己的代码上加入验证模块，那么这样呢整个的基础平台就不需要更改，结果，Low A当天就被开除了……

Low B，这个B呢一看A都被开除了不行上面的方法不行哪就换一个

 1 def f1(aaa)：
 2     #验证代码
 3     #验证代码
 4     print('我是F1业务')
 5     if aaa == 'f1':
 6         return 'ok'
 7
 8 def f2(aaa):
 9     #验证代码
10     #验证代码
11     print('我是F2业务')
12     if aaa == 'f2':
13         return 'ok'

LowB

这家伙呢在每个功能前面加入了验证代码，然后过了两天Low B也被开除了

最后老大把工作交给了Low C

Low C呢总结了两个Low的教训他是这么干的

 1 #验证函数
 2 def verify():
 3     # 验证1
 4     # 验证2
 5     # 验证3
 6     pass
 7
 8 def f1(aaa)：
 9     verify():
10     print('我是F1业务')
11     if aaa == 'f1':
12         return 'ok'
13
14 def f2(aaa):
15     verify():
16     print('我是F2业务')
17     if aaa == 'f2':
18         return 'ok'

Lowc

他呢把验证功能的,写成了一个函数然后,每个业务模块来去调用

老大看见了LowC的实现方式,嘴角露出了一丝微笑,并且与LowC聊了个天

老大说:

写代码要遵循开发封闭原则，虽然在这个原则是用的面向对象开发，但是也适用于函数式编程，简单来说，它规定已经实现的功能代码不允许被修改，但可以被扩展，即：

• 封闭：已实现的功能代码块
• 开放：对扩展开发

如果将开放封闭原则应用在上述需求中，那么就不允许在函数 f1 、f2的内部进行修改代码，老板就给了Low C一个实现方案：

装饰器(单层装饰器)

 1 def out(main):
 2     def wra():
 3         # 验证1
 4         # 验证2
 5         # 验证3
 6         return xxx
 7     return wra
 8
 9 @out
10 def f1(aaa):
11     print('我是F1业务')
12     if aaa == 'f1':
13         return 'ok'
14
15 @out
16 def f2(aaa):
17     print('我是F2业务')
18     if aaa == 'f2':
19         return 'ok'

单层装饰器

二、好，故事(这个故事是盗取银角大王的)到此结束我们开始来看上面的代码

（1）首先我们要知道当函数不加括号我们的函数是不被执行的，它会返回这个函数的内存地址

1 def aaa():
2     print("ok")
3
4 print(aaa)
5
6 <function aaa at 0x0000000000B6AC80>

函数内存地址

（2）然后我们来解释一下@out

@out就等于f1 = out(f1)

什么意思呢@out是python语法中的一个简写，他的用处就是针对装饰器来去做的，我们看下面的例子，将@out替换成

f1 = out(f1)

 1 def out(main):
 2     def wra(aaa):
 3         print('我进来了')
 4         ccc = main(aaa)
 5         return ccc
 6     return wra
 7
 8 def f1(aaa):
 9     print('我是F1业务')
10     if aaa == 'f1':
11         return 'ok'
12
13 f1 = out(f1)
14
15 s1 = 'f1'
16
17 ff1 = f1(s1)
18 print(ff1)

转换后

（3）我们来解释下out函数，对于out来说他首先接收一个值，从上面可以看出他接收的值是f1，f2的内存地址，然后return返回函数wra，注意的是f1 = out(f1),没加括号所以都没执行，返回wra的时候也没加括号所以也没执行，那么到了这里这个函数就先暂停我们结合者调用来看下面的图：

第一步：请务必分开wra不等于f1而是main等于f1！！下面的f1就等于wra的意思是执行f1函数就等于执行wra函数

第二步：

最后呢我们通过python语法塘，将f1 = out（f1） 变成@out就变成了之前我们看到的代码

 1 def out(main):
 2     def wra(aaa):
 3         print('我进来了')
 4         ccc = main(aaa)
 5         return ccc
 6     return wra
 7
 8 @out
 9 def f1(aaa):
10     print('我是F1业务')
11     if aaa == 'f1':
12         return 'ok'
13
14
15 s1 = 'f1'
16 ff1 = f1(s1)
17 print(ff1)

完整单层装饰器

友情提示：

在此请将之前的练习一下并且熟知其中的原理再进行下面的学习，大神除外

（4）装饰器装上含有参数的函数,有同学可能测试了一下说，我把函数f1的参数变成了多个，装饰器就报错了，那是怎么回事呢，原因很简单，因为wra首先他只能接收一个参数，并且ccc = main（aaa）也只接收了一个参数

1 def out(main):
2     def wra(aaa):
3         print('我进来了')
4         ccc = main(aaa)
5         return ccc
6     return wra

单参数

既然知道了原因那么我们就给他改改数码宝贝超进化…：

 1 def out(main):   #这里就不多解释了跟上面一样
 2     def wra(*aaa,**aa):  #这里呢变成了啥是不是可以接收各种的参数了
 3         print('我进来了')
 4         ccc = main(*aaa,**aa) #这里呢也可以给f1各种参数
 5         return ccc
 6     return wra
 7
 8 @out
 9 def f1(*af1):
10     print('我是F1业务')
11     print(af1[0]) #给大家测试用的
12     print(af1[1])
13     if af1[0] == 'f1':
14         return 'ok'
15
16 s1 = 'f1'
17 ff1 = f1(s1,'我是参数2') #传入了两个值s1和我是参数2'
18 print(ff1)  #运行一下看看吧呵呵

装饰参数函数的装饰器

三、装饰器的终极进化（多层装饰器）逻辑比较绕

有一天，变态的老大又找到了Low C说你的装饰器练习的咋样了，Low C说：经过老大的调教，我已经练习的差不多了，这个时候老大阴阴的呵呵一笑，好，这样我呢又有个需求要你给我改改，我现在呢想在验证之后呢添加一个欢迎功能，这个功能呢，我们业务线的功能想要添加就添加先要不添加就不添加，要记住封闭原则哦0.0……….

第二天Low C找到了老大说，大哥啊您晚上还是来我家教教我吧，真心的不知道啊0.0，，，于是老大就去了Low C的家里经过一场风云（此次省略一万个字）0.0老大提供了另外的参考代码：

 1 def ds():
 2     print('ok我是欢迎信息1')
 3
 4 def ss():
 5     print('ok我是欢迎信息2')
 6
 7
 8 def fill(*ill):
 9     def out(main):
10         def wra(*waa,**wad):
11             ill[0]()
12             ill[1]()
13             ccc = main(waa[0])
14             return ccc
15         return wra
16     return out
17
18
19 @fill(ds,ss)
20 def f1(aaa):
21     print('我是F1业务')
22     if aaa == 'f1':
23         return 'ok'
24
25
26 c1 = f1('f1')
27 print(c1)

老大的代码

哈哈看不懂了吧（大神除外）来吧我们分开来看就知道了

第一步：还是先解释一下装饰器fill请看图片，有一句话要牢记这个装饰器我就把它理解成调用，也就是把需要用的函数传入到装饰器做值，从而调用值来执行函数

第二步：

好到了这里大家应该明白了吧，不明白的留言，讲错了的请指教谢谢O(∩_∩)O~~，那么有的小伙伴要问了，这尼玛不对啊，为毛我把@fill（ds,ss）变成@fill（ss）就报错了呢？

我们分析一下问题，主要的原因呢就是def wra函数下面执行了 ill[1]报错了，因为这里*ill只有一个参数那么避免呢，看我的终极大招：

 1 def ds():
 2     print('ok我是欢迎信息1')
 3 def ss():
 4     print('ok我是欢迎信息2')
 5
 6 def fill(*ill):
 7     def out(main):
 8         def wra(*waa,**wad):#这里加个判断不就完了么 O(∩_∩)O哈哈~
 9             if len(ill) != '0':
10                 for i in range(0,len(ill)):
11                     ill[i]()
12             ccc = main(waa[0])
13             return ccc
14         return wra
15     return out
16
17 @fill(ss,ds)
18 def f1(aaa):
19     print('我是F1业务')
20     if aaa == 'f1':
21         return 'ok'
22
23 @fill()   #你看这里没参数吧
24 def f2(aaa):
25     print('我是F2业务')
26     if aaa == 'f2':
27         return 'ok'
28
29 c1 = f1('f1')
30 print(c1)
31 c2 = f2('f2')
32 print(c2)

终极大招-多层装饰器

#运行下试试吧

等等！最后老大和Low C成为了…此处省略一百万个字