文章目录
- 一 前置知识-高阶函数，闭包
- 1. 高阶函数
- 2. 闭包
- 二 函数装饰器
- 1. 什么是装饰器（原理）？
- 2. 装饰器的实现
- 3. 何时执行装饰器
- 4. wraps方法
- 三 类装饰器
一 前置知识-高阶函数，闭包
1. 高阶函数
在python中，如果一个函数的参数是另外一个或几个函数，那么这个函数就是高阶函数，如下
#高阶函数
def fun1():
print("Hello world")
def fun2(fun):
print("start".center(20, '='))
fun()
print("end".center(20, '='))
fun2(fun1)
>>>
=======start========
Hello world
========end=========
上面的函数fun2就是一个高阶函数，因为它的参数是一个函数fun1。
2. 闭包
在python中，闭包是一个函数，它延伸了变量的作用域，使得在定义变量的作用域失效后，该变量仍然能够被调用。
了解闭包更有助于学习装饰器，关于闭包，可以参考这篇文章：python之闭包
二 函数装饰器
1. 什么是装饰器（原理）？
装饰器，顾名思义就是装饰XXX的工具。在python中，装饰器的本质就是一个高阶函数，它接受一个函数作为参数，并返回一个被装饰后的函数。
装饰器的作用如下
- 在不修改被装饰函数的源代码和调用方式的情况下，给被装饰函数添加额外的功能。
即就是你传一个函数给装饰器，装饰器不会改变该函数的代码和调用方式就能使该函数获得额外的功能。
2. 装饰器的实现
比如要实现一个计算函数运行时间的功能，该怎么实现呢？
首先你可以使用高阶函数这样写
#装饰器
import time
def fun():
time.sleep(2)
def timer(fun):
start_time = time.time()
fun()
end_time = time.time()
total = end_time - start_time
print("函数运行时间为:{}".format(total))
timer(fun)
>>>
函数运行时间为:2.000129222869873
上面这中写法可以实现计算函数的运行时间，但是有个缺点，就是每计算一个函数运行的时间就得调用一次timer函数，如果函数有几十个几百个，那么就得调用几十次几百次time函数，而且也不太直观。
下面再来用 闭包 优化一下，如下
#装饰器
import time
def fun():
time.sleep(2)
def timer(fun):
def wrapper():
start_time = time.time()
fun()
end_time = time.time()
print("函数运行时间为:{}".format(end_time-start_time))
return wrapper
#timer返回嵌套函数的引用wrapper
#fun=wrapper
fun = timer(fun)
#调用fun()就是调用wrapper()
fun()
>>>
函数运行时间为:2.0008482933044434
上面用闭包函数优化了一下，现在计算函数运行时间的功能由wrapper函数来实现，而wrapper函数是嵌套在timer函数里面，timer函数返回wrapper()函数的引用wrapper。fun=timer(fun)就相当于fun=wrapper，调用fun() 就相当于调用 wrapper()。
可以看到， 经过闭包优化后，我们的调用方式变了，不再是调用 timer() 了，而是直接调用函数本身 fun() 就可以计算函数的运行时间了。
其实上面用闭包优化了后的 timer() 函数就是一个函数装饰器，因为它既没有修改被装饰函数fun() 的代码，也没有修改器调用方式就给函数 fun() 实现了额外计算运行时间的功能。
python又用 @ 来代替fun=timer(fun), @timer和fun=timer(fun)是等效的,于是上面的调用就可以写成下面的形式
import time
def timer(fun):
def wrapper():
start_time = time.time()
fun()
end_time = time.time()
print("函数运行时间为:{}".format(end_time-start_time))
return wrapper
#@timer和fun=timer(fun)等效
@timer
def fun():
time.sleep(2)
fun()
>>>
函数运行时间为:2.0007741451263428
可以看到，用 @timer 替换fun=timer(fun) 后我们就可以直接编写函数，然后调用函数就行了，这就是装饰器的魅力所在！
3. 何时执行装饰器
在python中，装饰器还有下面这两个特性：
- 被装饰函数和装饰器在同一个模块时，只有在明确调用被装饰函数时装饰器才被执行。
- 当被装饰函数和装饰器在不同的模块时，只要被装饰函数一经定义，装饰器就会立即执行，这一般在import导入时发生。
被装饰函数和装饰器在同一个模块时
#装饰器
import time
def timer(fun):
print("我是老六")
def wrapper():
start_time = time.time()
fun()
end_time = time.time()
print("函数运行时间为:{}".format(end_time-start_time))
return wrapper
#@timer和fun=timer(fun)等效
@timer
def fun():
time.sleep(2)
if __name__ == '__main__':
fun()
>>>
我是老六
函数运行时间为:2.000951051712036
被装饰函数和装饰器不在同一个模块
import time
from CSDN import timer
@timer
def fun1():
time.sleep(1)
fun1()
>>>
我是老六
我是老六
函数运行时间为:1.000683069229126
可以看到，结果打印了两次“我是老六”，这是因为在import时装饰器就执行了一次，在调用被装饰函数fun1时，装饰器又执行了一次。
4. wraps方法
在上面我们用闭包来优化写装饰器时，说过timer()函数返回的是wrapper，而我们在调用装饰器时是这样的
#@timer和fun=timer(fun)等效
@timer
def fun():
time.sleep(2)
fun()
说明在调用fun() 时其实是调用的 wrapper(),这时候 fun() 的__ name __ 属性已经被改变了，如下
#@timer和fun=timer(fun)等效
@timer
def fun():
time.sleep(2)
print(fun.__name__)
>>>
wrapper
可以看到fun()的__ name __ 属性已经被改成了wrapper，我们当然不希望装饰器改变被装饰函数的任何属性，这时我们就可以用functools模块中的wraps方法还原被装饰函数的__name__属性，如下
#装饰器
import time
import functools
def timer(fun):
@functools.wraps(fun)
def wrapper():
start_time = time.time()
fun()
end_time = time.time()
print("函数运行时间为:{}".format(end_time-start_time))
return wrapper
#@timer和fun=timer(fun)等效
@timer
def fun():
time.sleep(2)
print(fun.__name__)
>>>
fun
三 类装饰器
上面讲的是函数装饰器，下面简单介绍下类装饰器。把上面实现计算函数运行时间的功能用类装饰实现，如下
#类装饰器
import time
class timer():
def __init__(self, func):
self.func = func
def __call__(self):
star_time = time.time()
self.func()
end_time = time.time()
total = end_time - star_time
print("函数运行时间：", total)
@timer
def fun():
time.sleep(2)
fun()
>>>
函数运行时间： 2.0005552768707275
可以看到类装饰器实现的效果和函数装饰器实现的效果是一样的，只不过类装饰器在内部的装饰函数是用__call__ 方法实现的。其中 __ call __ 的作用如下：
- 能够使类的实例像函数调用那样被调用
@timer等价于 fun=timer(fun)
@timer 的在这里的作用实际就是实例化一个fun对象（fun=timer(fun)），对于类的实例化对象是不支持** 实例化对象() **这样调用的，而__call__ 方法的作用就是支持实例化对象这样被调用。所以才满足装饰器不改变被装饰函数调用方式的特性。
以上就是装饰器相关的一些基础知识。
文章出处登录后可见！
