装饰器：（语法糖）
本质是函数，它是赋予函数新功能，但是不改变函数的源代码及调用方式
原则：
1.不能修改被装饰函数的源代码
2.不能修改被装饰函数的调用方式
3.函数的返回值也不变
这两点简而言之，就是装饰器对被装饰函数来说是透明的
知识储备
1.函数即变量
比如定义了一个变量 x = ‘gkx’ python是一门解释性语言，解释了‘gkx’，并给它分配了内存地址，而 x 就是这个内存地址的一个索引，类似门牌号。
同理可得 def test():print('gkx') 定义了一个函数 test是它的门牌号，print('gkx')分配了一个内存地址。故可以理解为函数即变量。
2.高阶函数
a.把一个函数名当作实参传递给另外一个函数（在不改变函数源代码的情况
为其添加新功能）
b.返回值中包含函数名（不改变函数调用方式
3.嵌套函数
嵌套函数 在一个函数的函数体内，用def声明一个新函数
def foo():
print('in the foo.')
def bar():
print('in the bar.')
bar() #要调用bar需要在在函数体内调用，类似局部变量
foo()
装饰器例子：仅针对注释的几段，对其进行排序，如下红字
import time #python的debug都是先读取最外层框架（最外层没有缩进），最外层中如果涉及到调用，再接着运行调用内容。 第一步 def timer(func): #当读取到 @timer的时候，相当于运行 test1 = timer(test1)，所以会返回来读取 warpper 第三步
def warpper(*args,**kwargs):
start_time = time.time()
func(*args,**kwargs) #此时才是真正意义上运行 test1函数 第六步
return func(*args,**kwargs) #保证fun()返回值也不变
stop_time = time.time()
print('in the test1() %s'%(stop_time-start_time))
return warpper #把test1当作实参传递给 timer，timer(test1)，此时返回的是 函数warpper的内存地址 第四步 #然后此时运行到 python里的语法【@timer】
@timer #相当于 test1 = timer(test1)，返回warpper的内存地址，此时如果运行 test1()，相当于 warpper()，warpper就开始执行其函数体内的语句 第二步
def test1():
time.sleep(1)
print('in the test1')
return ‘from test1’
test1() #此时运行的 test1()已经不是直接运行 test1函数了，是经过@timer，转换成运行 warpper()了 第五步
装饰器进阶版，装饰器本身带参数
user = 'gkx'
pass_1 = ''
def decorator(auth_type):
print("auth type",auth_type)
def outer_warpper(func):
def warpper(*args,**kwargs):
if auth_type == 'local':
username = input("id")
password = input("password")
if username == user and password == pass_1:
print('\033[32;1mwelcome\033[0m')
res = func(*args,**kwargs)
print("after decorator")
return res
else:
print('\033[31;1mwrong info\033[0m')
elif auth_type == 'ldap':
print('我不会')
return warpper
return outer_warpper #当访问到这里的返回值时候，会继续执行 warpper，然后执行逻辑就和上面提到的timer一样了 @decorator(auth_type='local') #这里分成两部分看，第一部分是 调用decorator(auth_type = 'local')，此时返回outer_wrapper的内存地址
#在第一部分的基础上，此时加上@，变成了 @outer_wrapper，相当于 homepage = outer_wrapper(wrapper)，再返回了wrapper的内存地址 def homepage():
26 print('home page')
return 'from home' @decorator(auth_type='ldap')
def bbs():
print('in bbs') print(homepage())
bbs()
装饰器三个重要补充：
#一共有三个 # 第一个
from functools import wraps def outer(func):
@wraps(func) #wraps模块
def inner(*args,**kwargs):
print('装饰前')
ret = func(*args,**kwargs)
print('装饰后')
return ret
return inner @outer
def holiday(day):
''' :param day: days of vacation
:return:
'''
print("放假%s"%day)
return '好开心' print(holiday.__name__) #import wraps后此时打印holiday函数名，否则是 inner函数名
print(holiday.__doc__)
ret = holiday(3)
print(ret) # 第二个，当装饰器带参数
import time
FLAG = False
def out_timmer(flag):
def timmer(func):
def inner(*args,**kwargs):
if flag:
start = time.time()
ret = func()
end = time.time()
print(start-end)
return ret
else:
ret = func()
return ret
return inner
return timmer
@out_timmer(FLAG) #可以看成两部 1, timmer = out_timmer(FLAG) 2, @timmer
def shop1():
time.sleep(0.01)
print('buy first thing') @out_timmer(FLAG)
def shop2():
time.sleep(0.01)
print('buy second thing') shop1()
shop2() #第三个 函数被多个装饰器调用
def wrapper1(func): #func-----> f
def inner1():
print('wrapper1,befor func')
ret = func()
print('wrapper1,after func') #这一句运行完，但是inner2还没结束，要返回inner2继续运行【print('wrapper2,after func')】
return ret
return inner1 def wrapper2(func): #func-----> inner1 inner1传给了wrapper2
def inner2():
print('wrapper2,befor func') #运行完这一句，下一句运行inner1，故返回到wrapper1继续运行
ret = func() #inner1
print('wrapper2,after func')
return ret
return inner2 @wrapper2 #wrapper1 执行完后，执行wrapper2 但是此时传入的不是f，是 inner1，相当于 wrapper(inner1) == inner2 然后继续运行warpper2
@wrapper1 #先执行到这里，因为语法糖要找离它最近的函数。wrapper2没找到，故往下运行。此时函数 f传给wrapper1 相当于 f = wrapper1(f) 即为 inner1
def f():
print('in the f')
f() #--------->>调用inner2