装饰器放在一个函数开始定义的地方，它就像一顶帽子一样戴在这个函数的头上。和这个函数绑定在一起。在我们调用这个函数的时候，第一件事并不是执行这个函数，而是将这个函数做为参数传入它头顶上这顶帽子，这顶帽子我们称之为 装饰器 。
- 引入日志
- 函数执行时间统计
- 执行函数前预备处理
- 执行函数后清理功能
- 权限校验等场景
- 缓存
装饰器的使用方法很固定
- 先定义一个装饰器（帽子）
- 再定义你的业务函数或者类
- 最后把装饰器（帽子）扣在这个函数头上
def decorator(func):
def wrapper(*args, **kw):
return func()
return wrapper
@decorator # 也可以不用装饰器，在最底部加上function = decorator(function),效果是一样的
def function():
print("hello, decorator")实际上，装饰器并不是编码必须性，意思就是说，你不使用装饰器完全可以
装饰器的优点
- 更加优雅，代码结构更加清晰
- 将实现特定的功能代码封装成装饰器，提高代码复用率，增强代码可读性
接下来，我将以实例讲解，如何编写出各种简单及复杂的装饰器。
首先是日志打印器。 实现的功能：
- 在函数执行前，先打印一行日志告知一下主人，我要执行函数了。
- 在函数执行完，也不能拍拍屁股就走人了，咱可是有礼貌的代码，再打印一行日志告知下主人，我执行完啦。
# 这是装饰器函数，参数 func 是被装饰的函数
def logger(func):
def wrapper(*args, **kwargs):
print('主人，我准备开始执行：{} 函数了:'.format(func.__name__))
# 真正执行的是这行。
func(*args, **kwargs)
print('主人，我执行完啦。')
return wrapper
@logger # 相当于add = logger(add)
def add(x, y):
print("{} + {} = {}".format(x, y, x + y))
add(200, 50)
>>> 主人，我准备开始执行：add 函数了:
>>> 200 + 50 = 250
>>> 主人，我执行完啦。代码解析
python解释器从上往下执行，先定义了有一个logger函数，返回的是wrapper函数的引用，当执行到@logger时候，此时内部已经生成了一个闭包，实际上这句哈就相当于add = logger(add)，add变量指向了logger函数，logger函数又返回了wrapper，所以add变量其实是指向了def wrapper函数，当执行add(200, 50)，如果没有@logger装饰器，正常来说是执行add函数下面的print语句，但是现在add变量已经指向了wrapper函数，所以此时，执行的是wrapper函数里面的内容。
所以输出的第一句内容是print('主人，我准备开始执行')，接着是执行func函数，此时func指向的是add函数，为什么？因为add = logger(add)是传入了变量add，所以def logger(func)就变成了def logger(add)，自然而然func(*args, **kwargs)就变成了add(*args, **kwargs)，调用的是add函数
所以输出的第二句是x和y的和，输出的第三句就是主人，我执行完了
结论:@logger完全可以用add = logger(add)来代替，使用@logger这种语法糖是更加方便，清晰
实现功能：顾名思义，就是计算一个函数的执行时长。
# 定义一个计算函数时长的装饰器
def timer(func):
def wrapper(*args, **kwargs):
start_time = time.time()
func(*args, **kwargs)
end_time = time.time()
cost = end_time - start_time
print("花费了{}s".format(cost))
return wrapper
# 定义一个下载图片并保存到本地
def downloadPicture(url):
r = requests.get(url)
data = r.content
with open((str(random.random()) + '.jpg'), 'wb') as f:
f.write(data)
# 使用多线程下载4张图片
@timer
def time1():
t1 = threading.Thread(target=downloadPicture, args=('https://ss0.bdstatic.com/70cFuHSh_Q1YnxGkpoWK1HF6hhy/it/u=2106474246,1283617636&fm=26&gp=0.jpg', ))
t1.start()
t2 = threading.Thread(target=downloadPicture, args=('https://ss1.bdstatic.com/70cFvXSh_Q1YnxGkpoWK1HF6hhy/it/u=3083490177,4087830236&fm=26&gp=0.jpg', ))
t2.start()
t3 = threading.Thread(target=downloadPicture, args=('https://ss0.bdstatic.com/70cFuHSh_Q1YnxGkpoWK1HF6hhy/it/u=1828982182,1114677948&fm=26&gp=0.jpg', ))
t3.start()
t4 = threading.Thread(target=downloadPicture, args=('https://ss3.bdstatic.com/70cFv8Sh_Q1YnxGkpoWK1HF6hhy/it/u=45058783,2028528740&fm=11&gp=0.jpg', ))
t4.start()
# 调用time1函数
time1()
>>> 花费了0.0011370182037353516s带参数的装饰器
通过上面两个简单的入门示例，你应该能体会到装饰器的工作原理了。
不过，装饰器的用法还远不止如此，深究下去，还大有文章。今天就一起来把这个知识点学透。
回过头去看看上面的例子，装饰器是不能接收参数的。其用法，只能适用于一些简单的场景。不传参的装饰器，只能对被装饰函数，执行固定逻辑。
装饰器本身是一个函数，做为一个函数，如果不能传参，那这个函数的功能就会很受限，只能执行固定的逻辑。这意味着，如果装饰器的逻辑代码的执行需要根据不同场景进行调整，若不能传参的话，我们就要写两个装饰器，这显然是不合理的。
比如我们要实现一个可以定时发送邮件的任务（一分钟发送一封），定时进行时间同步的任务（一天同步一次），就可以自己实现一个 periodic_task （定时任务）的装饰器，这个装饰器可以接收一个时间间隔的参数，间隔多长时间执行一次任务。
那我们来自己创造一个伪场景，可以在装饰器里传入一个参数，指明国籍，并在函数执行前，用自己国家的母语打一个招呼。
def say_hello(country):
def wrapper(func):
def deco(*args, **kwargs):
if country == "china":
print("你好!")
elif country == "america":
print('hello.')
else:
return
# 真正执行函数的地方
func(*args, **kwargs)
return deco
return wrapper
@say_hello("china")
def a():
pass
@say_hello("america")
def b():
pass
a()
b()
>>> 你好!
>>> hello.不带参数的类装饰器
以上都是基于函数实现的装饰器，在阅读别人代码时，还可以时常发现还有基于类实现的装饰器。
基于类装饰器的实现，必须实现 __call__ 和 __init__两个内置函数。
- init ：接收被装饰函数
- call ：实现装饰逻辑。
还是以日志打印这个简单的例子为例
class Logger(object):
def __init__(self, func):
self.func = func
def __call__(self, *args, **kwargs):
print("[INFO]: the function {}() is running...".format(self.func.__name__))
return self.func(*args, **kwargs)
@Logger
def say(something):
print("say {}!".format(something))
say("hello")
>>> [INFO]: the function say() is running...
>>> say hello!带参数的类装饰器
上面不带参数的例子，你发现没有，只能打印INFO级别的日志，正常情况下，我们还需要打印DEBUG WARNING等级别的日志。这就需要给类装饰器传入参数，给这个函数指定级别了。
带参数和不带参数的类装饰器有很大的不同。
- init ：不再接收被装饰函数，而是接收传入参数
- call ：接收被装饰函数，实现装饰逻辑
class Logger(object):
def __init__(self, level='INFO'):
self.level = level
def __call__(self, func): # 接受函数
def wrapper(*args, **kwargs):
print("[{level}]: the function {func}() is running...".format(level=self.level, func=func.__name__))
func(*args, **kwargs)
return wrapper # 返回函数
@Logger(level='WARNING')
def say(something):
print("say {}!".format(something))
say("hello")
>>> [WARNING]: the function say() is running...
>>> say hello!
