先看一个示例
定义一个函数，传入数字，经过for循环后写入txt文件。
def writenum(num:int):""":param num: 传入数字:return:"""for i in range(num):with open('1.txt','a') as e:e.write(str(i))当执行函数后会在相同目录下生成一个1.txt的文件，但是我想确定写入文件消耗的时间，并且不打算修改上面的函数，于是编写另一个函数：函数内嵌套了一个函数，并返回该函数
import time
def print_exec_time(func):""":param func: 传入一个函数:return: 返回闭包函数"""def exec(num):""":param num: 装饰器内的函数传入数字num:return:"""starttime = time.time()func(num)endtime = time.time()print(f'花费了：{endtime-starttime}s')return exec
函数 print_exec_time执行过程：
1）函数 print_exec_time的入参是一个函数func，当执行时会返回exec函数
2）exec函数入参是num，执行exec函数时执行到func(num)，其实执行的就是原函数writenum。
而多增加一个嵌套函数的作用是在执行func(num)这一步骤前后增加时间打印并最终计算消耗的时间。
我们将函数writenum作为参数传给函数print_exec_time，执行print_exec_time(writenum)(500)结果如下：
花费了：0.016657114028930664s
并且在本地也同样生成了1.txt文件，那如果换成如下方式呢：
将函数print_exec_time作为writenum的装饰器，增加@print_exec_time
@print_exec_time
def writenum(num:int):for i in range(num):with open('1.txt','a') as e:e.write(str(i))此时我们直接执行函数writenum(500)，结果如下：
花费了：0.01768326759338379s
结论：函数装饰后，执行writenum(500)等同于执行print_exec_time(writenum)(500)，达到被装饰的目的。
什么是函数装饰器？
装饰器（decorator）是函数一种高阶用法，定义时需要满足几个条件：
1 函数内定义嵌套函数并返回该函数（这种叫函数闭包）
2 将函数作为参数传入
这样看来实现也不是很复杂，平常我们也会经常用到装饰器函数，比如类中的@staticmethod，@classmethod，Flask框架中的@app.route()等。
使用functools.wraps保护被装饰的函数本身的属性不被修改
函数被装饰器函数装饰后，会改变原函数的一些属性之比如__name__,__doc__
函数被装饰前我们执行如下语句
print(f'writenum 函数的name： {writenum.__name__}')
print(f'writenum 函数的__doc__属性： {writenum.__doc__}')结果如下：
writenum 函数的name： writenum
writenum 函数的__doc__属性：
:param num: 传入数字
:return:函数装饰后执行相同语句，结果如下：
writenum 函数的name： exec
writenum 函数的__doc__属性：
:param num: 装饰器内的函数传入数字num
:return:结果发现writenum函数的属性已经被改为了装饰器闭包函数的属性
解决方法：使用functools.wraps功能，在闭包函数上使用@wraps(func)
from functools import wraps
import time
def print_exec_time(func):""":param func: 传入一个函数:return: 返回闭包函数"""@wraps(func)def exec(num):""":param num: 装饰器内的函数传入数字num:return:"""starttime = time.time()func(num)endtime = time.time()print(f'花费了：{endtime-starttime}s')return exec此时再次执行如下语句，结果如下：保持了原函数本身的属性
writenum 函数的name： writenum
writenum 函数的__doc__属性：
:param num: 传入数字
:return:装饰器支持闭包函数带参数*args,**kwargs
之前文章介绍函数的参数有位置参数和关键字参数，多个参数我们可以写成func(*args,**kwargs), *args表示代表传入多个位置参数， **kwargs代表传入多个关键字参数。
我们将装饰器中原先参数num，替换为*args,**kwargs，这样就会支持很多不同参数的函数。
def print_exec_time(func):""":param func: 传入一个函数:return: 返回闭包函数"""@wraps(func)def exec(*args,**kwargs):""":param num: 装饰器内的函数传入数字num:return:"""starttime = time.time()func(*args,**kwargs)endtime = time.time()print(f'花费了：{endtime-starttime}s')return exec@print_exec_time
def writenum(*args,**kwargs):""":param args: 位置参数:param kwargs 关键字参数:return:"""print(args)print(kwargs)for i in (args):with open('1.txt','a') as e:e.write(str(i))for i in kwargs.items():with open('1.txt','a') as e:e.write(str(i))同样改造下函数writenum，然后执行writenum(1,2,3,name='lili',age=12)也是没问题的。
装饰器函数带参数
上面示例中的装饰器函数的参数传入的是原函数本身，那如果装饰器函数本身像普通函数需要传参数，那怎么处理呢？ 其实很简单，在装饰器函数中再嵌套一个闭包函数。
示例如下：
from functools import wraps
import time
def print_exec_time(param):""":param func: 传入一个函数:return: 返回闭包函数"""print(f'传入参数{param}')def param_exec(func):@wraps(func)def exec(num):""":param num: 装饰器内的函数传入数字num:return:"""starttime = time.time()func(num)endtime = time.time()print(f'花费了：{endtime -starttime}s')return execreturn param_exec基于上述例子，函数 print_exec_time带参数，在内部再增加一个闭包函数 param_exec，而这个函数的入参变成了函数func，跟上面讲到的示例就是一样了。
那我们装饰函数的时候就可以带上参数了：@print_exec_time('传入数字100')
@print_exec_time('传入数字100')
def add(num):i = 0for j in range(1,num+1):time.sleep(0.01)i+=jprint(f'result:{i}')执行add(100),结果如下：
传入参数传入数字100
result:5050
花费了：1.0658702850341797s
多个装饰器函数如何执行？
定义装饰器函数func1和func2，originfunc函数被这两个装饰器函数装饰。
def func1(func):print(f'执行函数 func1')@wraps(func)def exec():print(f'执行函数 func1的嵌套函数')func()print(f'结束执行函数 func1的嵌套函数')return execdef func2(func):print(f'执行函数 func2')@wraps(func)def exec():print(f'执行函数 func2的嵌套函数')func()print(f'结束执行函数 func2的嵌套函数')return exec@func2
@func1
def originfunc():print(f'执行了原函数 originfunc')执行originfunc()，结果如下：
执执行函数 func1
执行函数 func2
执行函数 func2的嵌套函数
执行函数 func1的嵌套函数
执行了原函数 originfunc
结束执行函数 func1的嵌套函数
结束执行函数 func2的嵌套函数结果分析如下：
1 函数先依次从下到上执行装饰器函数中闭包函数以上的函数内容
2 然后依次从上到下，执行闭包函数中原函数以上的内容
3 执行原函数的内容
4 最后从下到上执行原函数以下的内容
因为经过装饰器装饰后，originfunc这个函数相当于变成了originfunc=func2(func1(originfunc))
执行originfunc()相当于执行func2(func1(originfunc)()。
类装饰器的实现
在类中通过使用 __init__和 __call__方法来实现，__init__接收要被装饰的函数，__call__实现具体的装饰内容。
类装饰器作用是用来装饰函数。
比如以上示例，我们创建一个类class来实现，代码如下
class TESTDEC(object):# 通过初始化方法，传入被装饰的函数def __init__(self, func):self.__func = func# 重写 __call__ 方法来实现具体装饰内容def __call__(self, num):print('执行类的装饰器')starttime = time.time()self.__func(num)endtime = time.time()print(f'花费了：{endtime - starttime}s')使用类装饰器，并执行add(100)，结果是一样的。
@TESTDEC
def add(num):i = 0for j in range(1,num+1):time.sleep(0.01)i+=jprint(f'result:{i}')共勉： 东汉·班固《汉书·枚乘传》：“泰山之管穿石，单极之绠断干。水非石之钻，索非木之锯，渐靡使之然也。”
-----指水滴不断地滴，可以滴穿石头；
-----比喻坚持不懈，集细微的力量也能成就难能的功劳。
----感谢读者的阅读和学习，谢谢大家。
