python开发函数进阶：装饰器

一，装饰器本质

闭包函数

功能：就是在不改变原函数调用方式的情况下，在这个函数前后加上扩展功能

作用：解耦，尽量的让代码分离，小功能之前的分离。

　　　解耦目的，提高代码的重用性

二，设计模式

开放封闭原则

*对扩展是开放的

*对修改是封闭的

三，代码解释

*通用代码

 #!/usr/bin/env python
 #_*_coding:utf-8_*_

 def timmer(func):  #---> jjj
     def inner(*args,**kwargs):
         ret = func(*args,**kwargs)  # --->ret = jjj()
         # print('没有返回值的调用')
         return ret
     return inner

 @timmer #jjj = timmer(jjj)  语法糖
 def jjj():
     return 123
 # jjj()    #调用函数，如果被装饰的函数有返回值，就需要下边的代码
 ret = jjj()  #==>inner    有返回值
 print(ret)  #返回123

执行顺序

*用装饰器简单实现用户登录，登陆一个函数成功，无需再次登陆

 #!/usr/bin/env python
 #_*_coding:utf-8_*_

 tag = False

 def login(func):
     def inner(*args,**kwargs):
         global tag
         if tag == False:
             user = input('please your username>>>:')
             pwd = input('please your password>>>:')
             f = open('aaa','r',encoding='utf-8')
             for i in f:
                 user_pwd = eval(i)
                 if user == user_pwd['name'] and pwd == user_pwd['password']:
                     tag = True
             f.close()
         if tag:
             ret = func(*args,**kwargs)
             return ret
     return inner

 @login
 def haha(*args,**kwargs):
     print('中国动漫')
     pass

 @login
 def hengheng(*args,**kwargs):
     print('美国动漫')
     pass
 ##########用户调用方式
 haha()
 hengheng()

*统计函数中有多少个函数被装饰了

 #!/usr/bin/env python
 #_*_coding:utf-8_*_

 l = []
 def wrapper(func):
     #l.append(func)  #统计当前程序中有多少个函数被装饰了
     def inner(*args,**kwargs):
         l.append(func)  #统计本次程序执行有多少个带这个装饰器的函数被调用了
         ret = func(*args,**kwargs)
         return ret
     return inner

 @wrapper  #f1 = wrapper(f1)
 def f1():
     print('in f1')

 @wrapper #f2 = wrapper(f2)
 def f2():
     print('in f2')

 @wrapper #f2 = wrapper(f2)
 def f3():
     print('in f3')
 f1()
 f2()
 f3()

 print(len(l))

四，双层带参数的装饰器

顾名思义，就是给装饰器添加参数

可以控制被装饰的函数是否需要这个装饰器，或者其他用法

 #!/usr/bin/env python
 #_*_coding:utf-8_*_

 #带参数的装饰器 开关 ，控制是否需要装饰器

 F = False    #通过这里控制是否需要装饰器
 def outer(flag):
     #以下是装饰器
     def wrapper(func):
         def inner(*args,**kwargs):
             if flag:
                 print('before') #被装饰代码运行之前
                 ret = func(*args,**kwargs)  #被装饰的代码
                 print('after')   #被装饰代码运行之后
             else:
                 ret = func(*args, **kwargs)
             return ret
         return inner
     ###########################
     return wrapper

 @outer(F)   # F默认是FALSE，那么装饰器没有用上，因为 if false: ret = func()，因为加了括号直接执行，返回了wrapper，后面就是装饰器过程了
 def hahaha():
     print('hahaha')

 @outer(F)   # F如果是TRUE，就用上了装饰器
 def shuangww():
     print('shuangwaiwai')

 shuangww()
 hahaha()

执行过程

五，多个装饰器装饰一个函数（非重点）

 #!/usr/bin/env python
 #_*_coding:utf-8_*_

 #多个装饰器装饰一个函数
 def qqxing(func):  #func = pipixia_inner
     def qqxing_inner(*args,**kwargs):
         print('in qqxing:before')
         ret = func(*args,**kwargs)  #pipixia_inner
         print('in qqxing:after')
         return ret
     return qqxing_inner

 def pipixia(func):  #dapangxie
     def pipixia_inner(*args,**kwargs):
         print('in pipixia:before')
         ret = func(*args,**kwargs)      #dapangxie
         print('in pipixia:after')
         return ret
     return pipixia_inner

 #qqxing(pipixia_inner)  -->dapangxie = qqxing_inner()
 @qqxing    #dapangxie = qqxing(dapangxie)  -->dapangxie = qqxing(pipixia(dapangxie)) -->
 @pipixia   #dapangxie = pipixia(dapangxie)
 def dapangxie():
     print("饿了么")
 dapangxie()

 #dapangxie = pipixia(dapangxie)
 #dapangxie = qqxing(dapangxie)  -->dapangxie = qqxing(pipixia(dapangxie))
                                             #pipixia(dapangxie) == >pipixia_inner
                                             #qqxing(pipixia_inner) = qqxing_inner
 #dapangxie()  ==> qqxing_inner()