这里先导入time模块的概念。
import time
print(time.time()) # 打印距离1970年到现在的秒数
time.sleep(1) # 停留一秒再执行下一句'''
测试一段代码执行会经过多长时间
'''
import time
def func(): # 被装饰的函数
time.sleep(0.01) # 由于一个print语句太少，所以这里故意设置一个时间间隔，以达到预期效果。
print('今天好热')
def timmer(f): # 装饰器函数
def inner():
start = time.time()
f() # 调用被装饰的函数
end = time.time()
print('时间间隔为：',end - start)
return inner
result = timmer(func)
result()上面一段代码就是一个简单的装饰器。
通常为了是代码更加优美，于是引入语法糖的概念。这里将对上述第二段代码进行改进，他们的作用和结果完全相同。
'''
测试一段代码执行会经过多长时间
'''
import time
def timmer(f): # 装饰器函数
def inner():
start = time.time()
f() # 调用被装饰的函数
end = time.time()
print('时间间隔为：',end - start)
return inner
@timmer #语法糖-@装饰器函数
def func(): # 被装饰的函数
time.sleep(0.01) # 由于一个print语句太少，所以这里故意设置一个时间间隔，以达到预期效果。
print('今天好热')
# result = timmer(func) @timeer与此句一个作用相同
func() # 分析一下，此func等价于timmer(func)，也就相当于inner。
'''
测试一段代码执行会经过多长时间
'''
# 新增功能-装入带参数函数的装饰器
import time
def timmer(f): # 装饰器函数
def inner(a):
start = time.time()
f(a) # 调用被装饰的函数
end = time.time()
print('时间间隔为：',end - start)
return inner
@timmer #语法糖-@装饰器函数
def func(a): # 被装饰的函数
time.sleep(0.01) # 由于一个print语句太少，所以这里故意设置一个时间间隔，以达到预期效果。
print('今天好热',a)
# result = timmer(func) @timeer与此句一个作用相同
func(1) # 分析一下，此func等价于timmer(func)，也就相当于inner。上面一段代码是装入一个参数，如果我想在被装饰函数中加入两个参数呢？也许你会说，再加入一个变量，那么三个参数呢？这个时候我们就要用到前面学过的内容：*args。继续，如果我们再加入一个关键字参数呢？同样，我们要用到**kwargs。下面是代码：
'''
测试一段代码执行会经过多长时间
'''
# 新增功能-装入带参数函数的装饰器
import time
def timmer(f): # 装饰器函数
def inner(*args,**kwargs):
start = time.time()
f(*args,**kwargs) # 调用被装饰的函数
end = time.time()
print('时间间隔为：',end - start)
return inner
@timmer #语法糖-@装饰器函数
def func(a,b): # 被装饰的函数
time.sleep(0.01) # 由于一个print语句太少，所以这里故意设置一个时间间隔，以达到预期效果。
print('今天好热',a,b)
# result = timmer(func) @timeer与此句一个作用相同
func(1,b = 3) # 分析一下，此func等价于timmer(func)，也就相当于inner。
（1）不想修改函数的调用方式，但是还想在原来的函数前后添加功能。
（2）timmer就是一个装饰器函数，只是对一个函数有一些装饰作用。
对扩展是开放的。
对修改是封闭的。
4.1._name_、_doc_
# 学习._name_和._doc_，在这里如果不做任何修改，._name_会输出inner，因为study和inner等价，但是我们做出以下修改，就会成功输出study
from functools import wraps #导入
def wrapper(func):
@wraps(func)# 加上这句
def inner(*args,**kwargs):
print('在被装饰的函数执行前要做的事')
ret = func(*args,**kwargs)
print('在被装饰的函数执行后要做的事')
return ret
return inner
@wrapper
def study(days):
'''
这是一个注释
:param days:
:return:
'''
print('坚持学习%s天'%days)
return '加油'
# ret = study(10)
# print(ret)
print(study.__name__)# 输出
print(study.__doc__)4.2.多个函数下的装饰器
# 若多个函数同时用一个装饰器，一般来说就是在函数上面加一个@装饰器名，但是我们有不想用它的时候，如果我们一个一个去删除它则会非常的麻烦，下面这种方法将会解决这种问题。
import time
Flag = False
def timmer_out(Flag):
def timmer(func):
def inner(*args,**kwargs):
if Flag:
start = time.time()
ret = func(*args,**kwargs)
end = time.time()
print(end - start)
return ret
else:
ret = func(*args, **kwargs)
return ret
return inner
return timmer
@timmer_out(Flag)
def para_fir():
time.sleep(0.1)
print('the first')
@timmer_out(Flag)
def para_sec():
time.sleep(0.1)
print('the second')
para_fir()
para_sec()
# 思想就是在装饰器外再加上一层，成为三层装饰器，通过判断Flag为True还是False，来执行相应的代码块4.3.多个装饰器
def wrapper1(func): # func-->f
def inner1():
print('wrapper1 ,before func')
ret = func()
print('wrapper1 ,after func')
return ret
return inner1
def wrapper2(func): # func = inenr1
def inner2():
print('wrapper2 ,before func')
ret = func()
print('wrapper2 ,after func')
return ret
return inner2
@wrapper2 # f = wrapper2(f) -> wrapper2(inner1) = inner2
@wrapper1 # f = wrapper1(f) = inner1
def f():
print('in f')
return '哈哈哈'
print(f()) # f = inner2
# result:
# wrapper2 ,before func
# wrapper1 ,before func
# in f
# wrapper1 ,after func
# wrapper2 ,after func
# 哈哈哈
# 仔细观察这个结果，首先执行wrapper1，将f传入wrapper1中，于是wrapper1中的func就是f，最后返回一个inner1。接着再执行wrapper2,但是此时传入wrapper2中的参数是上一次执行返回过来的inner1，所以wrapper2中的func是inner1,最后返回一个inner2。
# 为什么结果是先有wrapper2，但是实际上是先执行wrapper1呢，这是因为装饰器中的语法糖会找最近的一个被修饰的函数，显然wrapper1更接近f()，而wrapper2比较远，所以是先执行wrapper1,再是wrapper2。
0