Python学习基础笔记十九——装饰器

装饰器的形成过程：

import time
 
 
def func1():
    print('in func1')
 
 
start = time.time()
func1()
end = time.time()
print(end - start)

再进一步：

import time
 
 
def timer(f):          # 计算函数执行时间，将函数名作为参数
    start = time.time()
    f()                # 执行函数
    end = time.time()
    print(end - start)
 
 
def func():
    print("Hello world!")
 
 
timer(func)

第二次进化：

import time
 
 
def func():
    print("Hello world!")
 
 
def timer(f):         # 装饰器
    def inner():       # 闭包
        start = time.time()
        f()           # 被装饰器函数
        end = time.time()
        print(end - start)
    return inner
 
 
func = timer(func)
 
 
func()

说明程序的运行过程：

第一步：def func():  func函数声明

第二步：def timer(func)  timer函数声明

第三步：func = timer(func)  先运行timer函数，传递func函数名（内存地址）

第四步：def inner()：开始运行timer函数内部代码，声明inner函数

第五步：return inner: 返回inner内存地址

第六步：func = timer(func):  将timer的返回值(inner内存地址）传给func变量（实际也是内存地址，跟func函数的内存地址是一样的）

第七步：func() 开始执行func()，实际上执行的就是inner函数，因为将inner内存地址赋值给了func变量的内存地址。

第八步：start = time.time()， 开始到inner函数内部开始执行，从这步开始，获得当前系统时间赋值给start变量。

第九步：f()， 开始执行f函数，该f，就是上一层timer函数传递进来的参数func。

第十步：print("Hello world!"）然后执行func函数内部代码，执行完毕，即退出func函数。

第十一步：end = time.time()， 获得当前系统时间，赋值给end变量。

第十二步：print(end - start)， 然后获得两个时间时间差，并打印，到这一步，inner函数执行完毕，退出inner。

第十三步：到func()调用函数的下一行。

装饰器的作用：

不想修改函数的调用方式，但是还想在原来的函数的前后添加新功能，timer是一个装饰器函数，只是对一个函数有一些装饰作用。

从上面的代码可见，timer是装饰器函数，f() 是被装饰的函数。

进一步变化：

import time
 
 
def timer(f):
    def inner():
        start = time.time()
        f()
        end = time.time()
        print(end - start)
    return inner
 
 
@timer             # 装饰器函数名
def func():        # 被装饰的函数名
    print("Hello world!")
 
# func = timer(func)
 
 
func()

注意其中的@timer的位置。

再进一步，注意其中对返回值的处理：

import time
 
 
def timer(f):
    def inner():
        start = time.time()
        ret = f()
        end = time.time()
        print(end - start)
        return ret
    return inner
 
 
@timer             # 装饰器函数名
def func():        # 被装饰的函数名
    print("Hello world!")
    return '新年好'
 
# func = timer(func)
 
 
ret = func()
print(ret)

如果func有返回值，看看装饰器函数timer中是怎么处理的，然后调用的时候也要注意下这个返回值。

再进一步：

import time
 
 
def timer(f):
    def inner(a):
        start = time.time()
        ret = f(a)
        end = time.time()
        print(end - start)
        return ret
    return inner
 
 
@timer             # 装饰器函数名
def func(a):        # 被装饰的函数名
    print("Hello world!", a)
    return '新年好'
 
# func = timer(func)
 
 
ret = func(1)
print(ret)

装饰带参数函数的装饰器。有了对带参数的处理。

进一步变化， 万能参数：

import time
 
 
def timer(f):
    def inner(*args, **kwargs):
        start = time.time()
        ret = f(*args, **kwargs)
        end = time.time()
        print(end - start)
        return ret
    return inner
 
 
@timer             # 装饰器函数名
def func(a):        # 被装饰的函数名
    print("Hello world!", a)
    return '新年好'
 
 
@timer             # 装饰器函数名
def func(a, b):        # 被装饰的函数名
    print("Hello world!", a, b)
    return '新年好'
 
# func = timer(func)
 
 
ret = func(1)
print(ret)

最后，我们再将装饰器简化：

def wrapper(f):                    # 装饰器wrapper
    def inner(*args, **kwargs):  
        '''在装饰前要做的事情'''  
        ret = f(*args, **kwargs)   # 被装饰的函数
        '''在装饰后要做的事情'''
        return ret
    return inner
 
@wrapper                           # 装饰器函数名
def func(a, b):                    # 被装饰的函数

这个就是一个装饰器固定模式。

原则：开放封闭原则：

开放：对扩展是开放的。

封闭：对修改是封闭的。

目的是维护代码的稳定性，那么这个就是装饰器存在的意义。