装饰器

函数一

闭包函数

def outter()
	def inner()
    	print('内部')
        print(inner.__closure__)  #使用函数名.__closure__返回cell就是闭包. 返回None就不是闭包
	return inner  # 此时表示返回内存地址，不能加(),否则表示执行此函数，
f = outter(111)  # f此时是inner的内存地址

无参装饰器

# 为被装饰的函数在之前或之后添加功能，而被装饰的函数调用及其内部不改变
#  模板
def wrapper(func):  # func函数是index函数的地址
    def inner(*args, **kwargs)  # 此两者接受的index()括号内传入的参数
		res = func(*args, **kwargs)
		return func
    return inner
@wrapper
def index()
	print('被装饰函数index')
   




import time


def timmer(func):
    def wrapper(*args,**kwargs):
        start_time = time.time()
        res=func(*args,**kwargs)
        stop_time = time.time()
        print('run time is: %s' %(stop_time - start_time))
        return res
    return wrapper

@timmer  # index=timmer(index)
def index(x,y):
    time.sleep(1)
    print('index===>',x,y)

@timmer  # home=timmer(home)
def home(name):
    "home的文档注释"
    time.sleep(0.5)
    print('welcome %s to home page' %name)
    return 123


res=index(1,2)
print(res)   # index函数无返回值
res1=home('666') 
print(res1)  ## index函数有返回值为123   

叠加多个装饰器

叠加多个装饰器
加载顺序:自下而上
执行顺序:自上而下运行内层的wrapper函数

def deco1(func1):  # func1 = wrapper2的内存地址
    def wrapper1(*args, **kwargs):
        print('wrapper1====>')
        res1 = func1(*args, **kwargs)
        return res1
    return wrapper1

def deco2(func2):  # func2 = wrapper3的内存地址
    def wrapper2(*args,**kwargs):
        print('wrapper2====>')
        res2=func2(*args,**kwargs)
        return res2
    return wrapper2

def deco3(func3):  # func3 = 最原始的那个被装饰函数的内存地址
    def wrapper3(*args,**kwargs):
        print('wrapper3====>')
        res3=func3(*args,**kwargs)
        return res3
    return wrapper3

        # index=wrapper1的内存地址
@deco1  # deco1(wrapper2的内存地址)=>wrapper1的内存地址
@deco2  # deco2(wrapper3的内存地址)=>wrapper2的内存地址
@deco3  # deco3(最原始的那个被装饰函数的内存地址)=>wrapper3的内存地址
def index(x,y):
    print('index=>',x,y)
index(1,2)
###  当deco1,deco2,deco3的顺序不一样时，其产生的结果也会发生变化。

有参装饰器

# 为内部被装饰器函数之前的功能或者之后的功能添加任意多个参数传递，只需要在外面再加一层函数即可
def outter(x,y,z,a=1,b=2)
    def wrapper(func):  # func函数是index函数的地址
        def inner(*args, **kwargs)  # 此两者接受的index()括号内传入的参数
            res = func(*args, **kwargs)
            return func
        return inner
    return wrapper
@wrapper(1,2,3,a=3)
def index()
	print('被装饰函数index')
    
def outter(engine = 'file'):
    def deco2(func2):
        def wrapper2(*args,**kwargs):
            inp_name = input('username>>>: ').strip()
            inp_pwd = input('password>>>: ').strip()
            if engine == "file":
                print('基于file的认证')
                
                if inp_name == "egon" and inp_pwd == "123":
                    print('login successful')
                    res2=func2(*args,**kwargs)
                    return res2
                else:
                    print('username or password error')
            elif engine == 'mysql':
                print('基于mysql的认证')
            elif engine == 'ldap':
                print('基于ldap的认证')
            else:
                print('未知的engine')
        return wrapper2
    return deco2

@outter(engine='mysql')  # @deco2 # index=deco2(index)
def index(x,y):
    print('index=>',x,y)

index(1,2)  # index=>wrapper


# 有参装饰器的模板：
def outter2(x,y,z,a,b):
    def outter1(func):
        def wrapper(*args,**kwargs):
            res=func(*args,**kwargs)
            return res
        return wrapper
    return outter1