python--对于装饰器的理解

Posted 2020-10-02

1、首先，有个原来写好的函数，完成一定的功能，比如下面的，就打印一句话（某程序被调用）。简单点，容易帮我们想清楚程序是怎么执行的。

1 ‘‘‘
2 原函数
3 ‘‘‘
4 def fun1():
5     print("fun1 is called.")
6 
7 fun1()

结果：

2、然后，有个需求，要在原来的函数上加个功能，我们简单点，就再打印一句话吧（某新功能加入）。

2.1 不懂装饰器，就直白点吧，加一个fun2

 1 ‘‘‘
 2 在原来的函数上加个功能
 3 再打印一句话吧（某新功能加入）。
 4 ‘‘‘
 5 def fun2():
 6     print("new fun is called")
 7 
 8 ‘‘‘
 9 原函数
10 打印一句话（某程序被调用），
11 ‘‘‘
12 def fun1():
13     fun2()
14     print("fun1 is called.")
15 
16 fun1()

结果：

这样子，结果是我们想要的，先执行新功能的程序，再执行原功能的程序，但是有个问题，原来的程序中加入了新的代码，示例中的13行。

写程序有个原则，叫封闭，就是原来跑得好好的代码不要再去改它，免得改来改去得再出问题。所以，我们得改。

2.2 不修改源代码，我们把原函数名字作为参数传给新功能的函数，先跑新功能，完了再掉用作为参数传进去的原功能

 1 ‘‘‘
 2 在原来的函数上加个功能
 3 再打印一句话吧（某新功能加入）。
 4 ‘‘‘
 5 def fun2(funname):
 6     print("new fun is called")
 7     funname()
 8 
 9 ‘‘‘
10 原函数
11 打印一句话（某程序被调用），
12 ‘‘‘
13 def fun1():
14     print("fun1 is called.")
15 
16 fun2(fun1)

结果：

也是我们要的结果。然后新问题来了，这种方式，可不是原来直接调用fun1()，那么程序中所有用到fun1()的地方都得改成fun2(fun1)，如果需要实现对就功能进行加强的地方很多，可以想象，你得找到所有的地方进行修改，程序大了，可不能这么干，万一漏了呢？我们还得改。

2.3 不改源代码，不改调用方式

把原来的程序在新程序中返回，然后再赋值给fun1，这样执行会是什么结果呢？

 1 ‘‘‘
 2 在原来的函数上加个功能
 3 再打印一句话吧（某新功能加入）。
 4 ‘‘‘
 5 def fun2(funname):
 6     print("new fun is called")
 7     return funname
 8 
 9 ‘‘‘
10 原函数
11 打印一句话（某程序被调用），
12 ‘‘‘
13 def fun1():
14     print("fun1 is called.")
15 
16 fun1=fun2(fun1)
17 
18 fun1()

结果：

在这个程序里，调用fun1()可以获得和原来一样的结果，但是，这里有个问题，“new fun is called”是在16行的时候，运行fun2时出来的，“fun1 is called”是在18行运行fun1时出来的，也就是说这个程序实际上并没有将fun1和fun2关联起来，它并没有在fun1()调用的时候同时实现新旧两个功能，它和以下代码是一样的

1 def fun2():
2     print("new fun is called")
3     return
4 def fun1():
5     print("fun1 is called.")
6 fun2()
7 fun1()

这就没有装饰的意思了
2.4 不改源代码，不改调用方式，一次调用执行实现新旧两个功能

 1 ‘‘‘
 2 在原来的函数上加个功能
 3 再打印一句话吧（某新功能加入）。
 4 ‘‘‘
 5 def fun2(funname):
 6     def inner():
 7         print("new fun is called")
 8         funname()
 9     return inner
10 
11 ‘‘‘
12 原函数
13 打印一句话（某程序被调用），
14 ‘‘‘
15 def fun1():
16     print("fun1 is called.")
17 
18 
19 fun1=fun2(fun1)
20 
21 fun1()

在这个代码里，fun1作为参数传给fun2，在fun2中定义了一个函数，在这个嵌套定义的函数中实现了新功能，那么fun2干嘛呢？它只是将这个新功能的地址作为返回值返回。我们拿到这个返回值，重新赋值给fun1，那么再调用fun1的时候，实际上是调用的fun2中定义的新功能函数。
结果：

我们可以通过debug运行，给每行打上断点，就能知道最终的结果是在运行到21行的时候一起出来的。

2.5 在以上基础上，可以看到旧功能是在fun1中实现的，新功能是在fun2中实现的，调用的还是fun1，多了一句话，即19行，传参+复制，会不会搞不清楚，于是，简写一下

 1 ‘‘‘
 2 在原来的函数上加个功能
 3 再打印一句话吧（某新功能加入）。
 4 ‘‘‘
 5 def fun2(funname):
 6     def inner():
 7         print("new fun is called")
 8         funname()
 9     return inner
10 
11 ‘‘‘
12 原函数
13 打印一句话（某程序被调用），
14 ‘‘‘
15 @fun2
16 def fun1():
17     print("fun1 is called.")
18 
19 fun1()

将@fun2写在fun1之前，就表示fun2写了新功能，它是在fun1的基础上来的，把fun1妆点了一下门面，有点加强了--装饰器这个名字很贴切的。

2.6 函数的定义是为了重复调用，可以少写代码，现在我们有fun2（新功能），可以想象，可能有很多其他的fun**（旧功能）需要妆点，如果原来的fun**本身带参数，那么就会报错。

 1 ‘‘‘
 2 在原来的函数上加个功能
 3 再打印一句话吧（某新功能加入）。
 4 ‘‘‘
 5 def fun2(funname):
 6     def inner():
 7         print("new fun is called")
 8         funname()
 9     return inner
10 
11 ‘‘‘
12 原函数
13 打印一句话（某程序被调用），
14 ‘‘‘
15 @fun2
16 def fun1():
17     print("fun1 is called.")
18 
19 @fun2
20 def fun3(arg1):
21     print("fun3 welcome: %s "%arg1)
22 
23 fun1()
24 fun3("susen")

结果：

所以，我们需要用非固定参数来解决这个问题。在装饰器的inner函数用非固定参数*args,**kwargs，这样，不管原来的函数有多少参数，都可以调用了。

 1 ‘‘‘
 2 在原来的函数上加个功能
 3 再打印一句话吧（某新功能加入）。
 4 ‘‘‘
 5 def fun2(funname):
 6     def inner(*args,**kwargs):
 7         print("new fun is called")
 8         funname(*args,**kwargs)
 9     return inner
10 
11 ‘‘‘
12 原函数
13 打印一句话（某程序被调用），
14 ‘‘‘
15 @fun2
16 def fun1():
17     print("fun1 is called.")
18 
19 @fun2
20 def fun3(arg1):
21     print("fun3 welcome: %s "%arg1)
22 
23 fun1()
24 fun3("susen")

结果：

3、总结

按照上面一步步得来，应该能明白装饰器是怎么工作的了，基础知识有：非固定参数传参、函数名实际上也是一个变量（内存地址）、嵌套函数。明白以后，之后写代码就套用格式就完了。