day11-装饰器

1.举例讲解

　　这里先导入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。

 

2.装饰器的作用

　　（1）不想修改函数的调用方式，但是还想在原来的函数前后添加功能。

　　（2）timmer就是一个装饰器函数，只是对一个函数有一些装饰作用。

3.原则-开放封闭原则

　　对扩展是开放的。

　　对修改是封闭的。

4.装饰器进阶

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。