定义一个函数，该函数可为其他函数添加额外的功能。
需要在不修改被装饰对象源代码及其调用方式时，为被装饰对象添加额外的功能。
现在我们有如下一个函数help（），time.sleep（）来模拟函数执行时间，print打印传入参数值，方便我们来进行分析。如果现在我们需要为help函数添加一个统计其运行时间的功能，我们可以怎么做？
import time
def help(x, y):
time.sleep(1)
print(f'x={x} y={y}')
help(1, 2)方案一：
在help函数开头结束分别调用time.time（），两者相减得运行时间。
import time
def help(x, y):
start = time.time()
time.sleep(1)
print(f'x={x} y={y}')
stop = time.time()
print(stop - start)
help(1, 2)运行结果：
方案一中我们在help中加了相关代码，虽然没有改变它的调用方式，但改变了它的源代码。我们继续想想如何两者都不改变的情况下，完成我们的目标。
对，函数内不能动，我们可以动函数外呀，在help前后加上相关代码，似乎就可以达到我们的目标了，这就是方案二，我们来试试。
方案二：
import time
def help(x, y):
time.sleep(1)
print(f'x={x} y={y}')
start = time.time()
help(1, 2)
stop = time.time()
print(stop - start)运行结果：
显而易见，似乎没有问题，但是如果我们需要多次调用help函数的话，在它前后都得加上相同的代码，这样代码就会显得十分冗余了。既然help函数前后代码不会变的话，我们可以将它们封装成另一个函数呀，说干就干。
方案三：
import time
def help(x, y):
time.sleep(1)
print(f'x={x} y={y}')
def wrapper():
start = time.time()
help(1, 2)
stop = time.time()
print(stop - start)
wrapper()
运行一下：
这样我们就解决了多次调用的问题，但美中不足的是，help函数的调用方式改变了，而且help的参数固定，也只能修饰help函数，我们来一步步试着优化。
优化一（参数优化，实现任意参数）：
对参数优化，我们可以将help的实参通过wrapper的传入，而为了实现任意参数，我们首先想的便是*args,**kwargs来作为函数的参数，于是将方案三进行改进如下（为方便分析，为help多增加了一个参数）：
import time
def help(x, y, z):
time.sleep(1)
print(f'x={x} y={y} z={z}')
def wrapper(*args, **kwargs):
start = time.time()
help(*args, **kwargs)
stop = time.time()
print(stop - start)
wrapper(1, 2, 3)
运行一下：
这样我们便将help的参数变得更加灵活了，接着我们来优化。
优化二（实现装饰其他对象）：
需要装饰其他对象，意味着我们在help位置的应该是一个可变参数，也就是用户输入的参数，即wapper函数内应变为：
def wrapper(*args, **kwargs):
start = time.time()
func(*args, **kwargs)
stop = time.time()
print(stop - start)但是我们期望wrapper能和内部调用的func函数的参数一致，即wrapper的参数我们应该不去改变，那我们func的值从何处传来呢？
没错，我们可以运用闭包函数来传参，修改一下下：
def outter(func):
def wrapper(*args, **kwargs):
start = time.time()
func(*args, **kwargs)
stop = time.time()
print(stop - start)
return wrapper这样我们为其他函数修饰时，只需要将其函数名作为outter函数的参数传入即可：
import time
def help(x, y, z):
time.sleep(1)
print(f'这是help的{x}{y}{z}')
def others(x, y, z):
time.sleep(1)
print(f'这是others的{x}{y}{z}')
def outter(func):
def wrapper(*args, **kwargs):
start = time.time()
func(*args, **kwargs)
stop = time.time()
print(stop - start)
return wrapper
help = outter(help)
others = outter(others)
help(1, 2, 3)
others(4, 5, 6)运行一下：
结果符合预期，而且在使用时由于outter内的func是在局部名称空间，outter外的func是在全局名称空间，调用时二者并不冲突，并且使用时可读性较高，我们好像达成开始的目标，似乎能以假乱真了。但我们继续思考一下，我们演示用到的函数十分简单，甚至没有返回值，如果加上返回值后，我们再对其修饰后，能得到原函数的返回值吗？
优化三（得到相同返回值）：
回到我们的wrapper中去，既然需要我们func函数的返回值，我们直接将其赋值给res，再return出res的值：
import time
def help(x, y, z):
time.sleep(1)
print(f'这是help的{x}{y}{z}')
return 'help'
def others(x, y, z):
time.sleep(1)
print(f'这是others的{x}{y}{z}')
return 'others'
def outter(func):
def wrapper(*args, **kwargs):
start = time.time()
res=func(*args, **kwargs)
stop = time.time()
print(stop - start)
return res
return wrapper
help = outter(help)
others = outter(others)
res1=help(1, 2, 3)
res2=others(4, 5, 6)
print(res1,res2)没毛病，跑一下：
总结：
到这我们完成了一个简单的无参装饰器，装饰后的func既没有改变源代码，也没有改变调用方式。
但是代码稍显冗余，python语法便规定：在被装饰对象正上方单独一行写@装饰器名字，等价于func=outter(func)，简化代码。从中我们总结出无参装饰器的一个模板：
def outter(func):
def wrapper(*args,**kwargs):
# 1、调用原函数
# 2、增加的新功能
res=func(*args,**kwargs)
return res
return wrapper
#使用时
@outter
def func:
pass