python--4、装饰器

装饰器（Decorator）

  使用场景：为被装饰器装饰的函数增加功能，但又不希望修改函数的定义，即在代码运行期间动态增加功能。

  装饰器更多的用于后期功能升级而不是编写新的代码。装饰器不光能装饰函数，也能装饰其他的对象，比如类，但通常，我们以装饰函数为例子介绍其用法。

 

理解装饰器需要具备的知识：

    函数即“变量”、高级函数、嵌套函数

 

例如为已经运行的代码中的多个函数增加同一个功能，方法有：

  1、对基础平台的代码进行重构，即在每段函数中都加入相应代码。

  2、把需要的功能写成一个新函数，在需要加功能的函数中调用它。

  3、使用装饰器，对基础平台的代码进行拓展。

注：开放封闭原则：

   已经实现的功能代码内部不允许被修改，但外部可以被扩展。主要是针对面向对象开发，但是也适用于函数式编程。

   封闭：已实现的功能代码块；

   开放：对扩展开放。

所以使用装饰器这种方式为最佳。

 

原理

例如要在调用函数中添加认证和日志记录功能（

In [23]: def outer(func):

    ...:     def inner():

    ...:         print('认证成功！')

    ...:         result = func()

    ...:         print('日志添加成功')

    ...:         return result

    ...:     return inner

    ...: 

 

In [24]: @outer        # f1 = outer(f1) = inner

    ...: def f1():

    ...:     print('业务部门1数据接口...')

    ...:     

 

In [25]: f1()

认证成功！

业务部门1数据接口...

日志添加成功

）

  1、程序开始运行，从上往下编译，读到def outer(func):的时候，发现这是个“一等公民”->函数，于是把函数体加载到内存里，然后过。

  2、读到@outer的时候，程序被@这个语法糖吸引住了，知道这是个装饰器，按规矩要立即执行的，于是程序开始运行@后面那个名字outer所定义的函数。（装饰器只能放在被装饰的函数的上方最近处，不要空行。）

  3、程序返回到outer函数，开始执行装饰器的语法规则，这部分规则是定死的，是python的“法律”。

规则是：被装饰的函数的名字会被当作参数传递给装饰函数。装饰函数执行它自己内部的代码后，会将它的返回值赋值给被装饰的函数。 

  4、程序开始执行outer函数内部的内容，一开始它又碰到了一个函数。inner函数定义块被程序观察到后不会立刻执行，而是读入内存中（这是潜规则）。

  5、再往下，碰到return inner，返回值是个函数名，并且这个函数名会被赋值给f1这个被装饰的函数，也就是f1 = inner。根据前面的知识，我们知道，此时f1函数被新的函数inner覆盖了（实际上是f1这个函数名更改成指向inner这个函数名指向的函数体内存地址，f1不再指向它原来的函数体的内存地址），再往后调用f1的时候将执行inner函数内的代码，而不是先前的函数体。那么先前的函数体去哪了？还记得我们将f1当做参数传递给func这个形参么？func这个变量保存了老的函数在内存中的地址，通过它就可以执行 老的函数体，你能在inner函数里看到result = func（）这句代码，它就是这么干的！

  6、接下来，还没有结束。当业务部门，依然通过f1()的方式调用f1函数时，执行的就不再是老的f1函数的代码，而是inner函数的代码。在本例中，它首先会打印个“认证成功”的提示，很显然你可以换成任意的代码，这只是个示例；然后，它会执行func函数并将返回值赋值个变量result，这个func函数就是老的f1函数；接着，它又打印了“日志保存”的提示，这也只是个示例，可以换成任何你想要的；最后返回result这个变量。我们在业务部门的代码上可以用 r = f1()的方式接受result的值。

  7、以上流程走完后，你应该看出来了，在没有对业务部门的代码和接口调用方式做任何修改的同时，也没有对原有的代码做内部修改，仅仅是添加了一个装饰函数，就实现了我们的需求，在函数调用前先认证，调用后写入日志。这就是装饰器的最大作用。

 

但为什么我们要搞一个outer函数一个inner函数这么复杂呢？

  注意，@outer这句代码在程序执行到这里的时候就会自动执行outer函数内部的代码，如果不封装一下，在还未进行调用的时候，就执行了些什么，这和初衷有点不符。当然，如果你对这个有需求也不是不行。请看下面的例子，它只有一层函数。  

In [33]: def outer(func):

    ...:     print('认证成功！')

    ...:     result = func()

    ...:     print('日志添加成功')

    ...:     return result

    ...: 

 

In [34]: @outer

    ...: def f1():

    ...:     print('业务部门1数据接口...')

    ...:     

认证成功！

业务部门1数据接口...

日志添加成功

 

上面并没有执行f1函数，只是定义好了，还没有调用f1函数，程序就把工作全做了。这就是封装一层函数的原因。

 

原则

  1、不能修改被装饰的函数的源代码

  2、不能修改被装饰的函数的调用方式

 

 

参数传递

被装饰函数的参数传递

  例如部门调用的接口函数都需要不同的参数，需要使用 *args **kwargs 。

In [17]: def outer(func):

    ...:     def inner(*args, **kwargs):

    ...:         print('认证成功')

    ...:         result = func(*args, **kwargs)

    ...:         print('日志添加成功')

    ...:         return result

    ...:     return inner

    ...: 

 

In [18]: @outer

    ...: def f1(name, age):

    ...:     print("{}正在连接业务部门1数据接口。。。".format(name))

    ...:     

 

In [19]: f1("jack", 18)

认证成功

jack正在连接业务部门1数据接口。。。

日志添加成功

装饰器自己的参数

  装饰器自身的参数不能直接传入所以在装饰器，在装饰器外再封装一层函数的目地就是为了给装饰器传参。

In [31]: # 认证函数

In [32]: def auth(request, kwargs):

    ...:     print("认证成功!")

    ...:     

 

In [33]: # 日志函数

In [34]: def log(request, kwargs):

    ...:     print("日志添加成功！")

    ...:     

 

In [35]: # 装饰器函数，接收2个参数，这两个参数应该是某个函数的名字。

In [41]: def Filter(auth_func, log_func):

    ...:     # 第一层封装，auth和log函数的参数值被传递到了这里

    ...:     def outer(main_func):

    ...:         # 第二层封装,f1函数实际上被传递给了main_func这个参数

    ...:         def wrapper(request, kargs): 

    ...:         # 下面代码的判断逻辑不重要，重要的是参数的引用和返回值

    ...:             before_result = auth(request, kargs) 

    ...:             if(before_result != None):

    ...:                 return before_result

    ...:             main_result = main_func(request, kargs)

    ...:             if(main_result != None):

    ...:                 return main_result

    ...:             after_result = log(request, kargs)

    ...:             if(after_result != None):

    ...:                 return after_result

    ...:         return wrapper

    ...:     return outer

    ...: 

    # 注意了，这里的装饰器函数有参数哦，它的意思是先执行Filter函数

    # 然后将Filter函数的返回值作为装饰器函数的名字返回到这里，所以，

    # 其实这里等价于，Filter(auth,log) = outer , @Filter(auth,log) =  @outer

     #  也等价于f1=Filter(auth, log)(f1)=@outer=wrapper

     

In [44]: @Filter(auth, log)  

    ...: def f1(name, age):

    ...:     print("{} 正在连接业务部门1数据接口。。。".format(name))

    ...:     

 

In [45]: f1("jack", 18)

认证成功!

jack 正在连接业务部门1数据接口。。。

日志添加成功！

可以这么理解，先执行Filter函数，获得它的返回值outer，再执行@outer装饰器语法。

 

一个函数可以被多个函数装饰。