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()