装饰器

1、默写下面的函数

import time
def func():
    time.sleep(0.2)
    print("今天放假")
def timme(f):  # 这里的函数名不能直接用time()，不然会报错，很可能是跟系统函数冲突
    def inner():
        Start_time = time.time()
        f()
        End_time = time.time()
        print(End_time - Start_time)

    return inner
func = timme(func)
func()

不想修改函数的调用方式，但是还想在原来的函数前后添加功能
timmer就是一个装饰器函数，只是对一个函数有一些装饰作用
timmer就是装饰器函数，timmer()里面的f()就是被装饰函数

2、装饰器的基本原则

 原则：开放封闭原则

开放：对扩展是开放的

封闭：对修改是封闭的

3、语法糖

 把上面的装饰器用语法糖方式重新定义

def timme(f):
    def inner():
        Start_time = time.time()
        f()
        End_time = time.time()
        print(End_time - Start_time)

    return inner

@timme                #语法糖，@装饰器函数名，这句话等价下面的func = timme(func)
def func():          #紧挨着的是被装饰函数
    time.sleep(0.2)
    print("今天放假")
#func = timme(func)   #用了语法糖以后，这条代码就被省去了，
func()

4、下面被装饰函数func加上返回值以后，当我们调用func()时候有返回值吗

def timme(f):
    def inner():
        Start_time = time.time()
        f()
        End_time = time.time()
        print(End_time - Start_time)

    return inner

@timme                #语法糖，@装饰器函数名
def func():          #紧挨着的是被装饰函数
    time.sleep(0.2)
    print("今天放假")
    return '过节学习'
ret = func()
print(ret)

0.2000114917755127
None

def timme(f):
    def inner():
        Start_time = time.time()
        ret = f()
        End_time = time.time()
        print(End_time - Start_time)
        return ret
    return inner

@timme                #语法糖，@装饰器函数名
def func():          #紧挨着的是被装饰函数
    time.sleep(0.2)
    print("今天放假")
    return '过节学习'
ret = func()
print(ret)

5、装饰带参数函数的装饰器

 带一个参数的装饰器

def timme(f):
    def inner(a):
        Start_time = time.time()
        ret = f(a)
        End_time = time.time()
        print(End_time - Start_time)
        return ret
    return inner

@timme                #语法糖，@装饰器函数名
def func(a):          #紧挨着的是被装饰函数
    time.sleep(0.2)
    print("今天放假",a)
    return '过节学习'
ret = func(2)
print(ret)

今天放假 2
0.2000114917755127
过节学习

带两个参数的装饰器

def timme(f):
    def inner(*args):
        Start_time = time.time()
        ret = f(*args)  # 这里还需要用*把多个参数打散传入
        End_time = time.time()
        print(End_time - Start_time)
        return ret

    return inner

@timme  # 语法糖，@装饰器函数名
def func2(a):  # 紧挨着的是被装饰函数
    time.sleep(0.2)
    print("今天放假", a)
    return '过节学习'


@timme  # 语法糖，@装饰器函数名
def func3(a, b):  # 紧挨着的是被装饰函数
    time.sleep(0.2)
    print("今天放假", a, b)
    return '过节学习'


ret2 = func2(2)
print(ret2)
ret3 = func3(3, 4)
print(ret3)

今天放假 2
0.2000114917755127
过节学习
今天放假 3 4
0.2000114917755127
过节学习

6、包含关键字的装饰器

def timme(f):
    def inner(*args,**kwargs):
        Start_time = time.time()
        ret = f(*args,**kwargs)  # 这里还需要用*把多个参数打散传入
        End_time = time.time()
        print(End_time - Start_time)
        return ret

    return inner


@timme  # 语法糖，@装饰器函数名
def func2(a,b):  # 紧挨着的是被装饰函数
    time.sleep(0.2)
    print("今天放假", a,b)
    return '过节学习'


ret = func2(4,6)
print(ret)
ret2 = func2(2,b = 9)
print(ret2)

今天放假 4 6
0.2000114917755127
过节学习
今天放假 2 9
0.2000112533569336
过节学习

7、装饰器的固定格式

def wrapper(f):                          #装饰函数，f是被装饰函数
    def inner(*args,**kwargs):
        '''在被装饰函数之前要做的事情'''
        ret = f(*args,**kwargs)          #被装饰函数
        '''在被装饰函数之后要做的事情'''
        return ret
    return inner

@wrapper                                 #语法糖，@装饰器函数名，等价于func = wrapper(func）
def func(a,b):                          #被装饰函数
    time.sleep(0.5)
    print("放假最后一天了",a,b )
    return '假期是充实的'

ret = func(b = 9,a = 3)                 #实际执行的是inner函数
print(ret)

放假最后一天了 3 9
假期是充实的

 

 8、装饰器的聚合与打散

传参：聚合,就是说传参的时候是把几个参数一起传给函数
调用：打散，就是说具体调用的时候是一个一个参数来使用，那么好比打散来用

def wrapper(func):
    def inner(*args,**kwargs):
        print("在被装饰之前做的事情")
        ret = func(*args,**kwargs)
        print("被装饰之后做的事情")
        return ret
    return inner

@wrapper
def func(day):
    print("节后第%s天"%day)

    return "继续加油干"

ret = func(1)
print(ret)

上面代码结果是：

在被装饰之前做的事情
节后第1天
被装饰之后做的事情
继续加油干

 9、带参数的装饰器

一个装饰器一般就三层，最外一层是带参数，方便用参数的设置来决定是否进行装饰，这样避免挨个挨个进行去掉装饰

import time
Flag = False
def timmer_out(Flag):
    def timmer(func):
        def inner(*args,**kwargs):
            if Flag:
                start_time = time.time()
                ret = func(*args,**kwargs)
                end_time = time.time()
                print(end_time - start_time)
                return ret
            else:
                ret = func(*args, **kwargs)
                return  ret
        return inner
    return timmer
#timmer = timmer_out(Flag)，timmer_out后面带括号就是函数调用
@timmer_out(Flag)
def get():
    time.sleep(0.2)
    print("快上班了")

get()

快上班了

10、装饰器进阶：多个装饰器同时装饰同一个函数

def wrapper1(func):
    def inner1(*args,**kwargs):
        print("wrapper1开始装饰")
        ret = func(*args,**kwargs)
        print("wrapper1装饰结束")
        return ret
    return inner1

def wrapper2(func):
    def inner2(*args,**kwargs):
        print("wrapper2开始装饰")
        ret = func(*args,**kwargs)
        print("wrapper2装饰结束")
        return ret
    return inner2

def wrapper3(func):
    def inner3(*args,**kwargs):
        print("wrapper3开始装饰")
        ret = func(*args,**kwargs)
        print("wrapper3装饰结束")
        return ret
    return inner3

@wrapper3
@wrapper2
@wrapper1
def f(a):
    print("输入的数是：",a)
    return "返回结束"

print(f(666))

wrapper3开始装饰
wrapper2开始装饰
wrapper1开始装饰
输入的数是： 666
wrapper1装饰结束
wrapper2装饰结束
wrapper3装饰结束
返回结束

多个装饰器同时装饰同一个函数的执行顺序：