一、前言
python装饰器本质上就是一个函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外的功能，装饰器的返回值也是一个函数对象。
Python中一切皆可对象
二、函数带和不带()的区别
def test():
print('test ist running')
test()
print(test)
test_two = test
test_two()
#输出
test ist running
test ist running
如代码所示，test()和test输出是不同的，这是因为当你把一对小括号放在后面，这个函数就会执行；然而如果你不放括号在它后面，它是一个对象，那它可以被到处传递，并且可以赋值给别的变量而不去执行它
三、简单的装饰器
def use_logging(func):
def wrapper():
"""wrapper()"""
print('%s start running' % func.__name__)
f = func()
print('%s stop running' % func.__name__)
return f
return wrapper
@use_logging
def foo():
"""foo()"""
print("i am foo")
foo()
#output
foo start running
i am foo
foo stop running
or（代码稍微不同，可以控制执行顺序吧）
def use_logging(func):
def wrapper():
"""wrapper()"""
print('%s start running' % func.__name__)
#f = func()
print('%s stop running' % func.__name__)
return func()
return wrapper
@use_logging
def foo():
"""foo()"""
print("i am foo")
foo()
#output
foo start running
foo stop running
i am foo
use_logging 就是一个装饰器，它是一个普通的函数，它把执行真正业务逻辑的函数 func 包裹在其中，看起来像 foo 被 use_logging 装饰了一样，use_logging 返回的也是一个函数，这个函数的名字叫 wrapper。
如果业务函数带有参数，且不确定有几个参数，这是就需要用*args，**kwargs两兄弟了。
def use_logging(func):
def wrapper(*args, **kwargs):
"""wrapper()"""
print('%s start running' % func.__name__)
#f = func(*args, **kwargs)
print('%s stop running' % func.__name__)
return func(*args, **kwargs)
return wrapper
六、warps
__name__用于获取函数的名称，__doc__用于获取函数的docstring内容（函数的注释）
在上面章节的示例代码加入如下代码
print(foo.__name__)
print(foo.__doc__)
#output
wrapper
wrapper()
可以发现foo函数的名称和注释都被装饰器的wrapper函数覆盖了。
Python提供了一个简单函数解决了这个问题。
from functools import wraps
def use_logging(func):
@wraps(func)
def wrapper(*args, **kwargs):
"""wrapper()"""
print('%s start running' % func.__name__)
#f = func(*args, **kwargs)
print('%s stop running' % func.__name__)
return func(*args, **kwargs)
return wrapper
@use_logging
def foo():
"""foo()"""
print("i am foo")
print(foo.__name__)
print(foo.__doc__)
#output
foo
foo()
@wraps接受一个函数来进行装饰，并加入了复制函数名称、注释文档、参数列表等等的功能。这可以让我们在装饰器里面访问在装饰之前的函数的属性。
五、装饰器带参数
import logging
from functools import wraps
def use_logging(level=‘warn’):
@wraps(func)
def decorator(func):
def wrapper(*args, **kwargs):
if level == "warn":
logging.warning("%s is running" % func.__name__)
elif level == "info":
logging.info("%s is running" % func.__name__)
return func(*args)
return wrapper
return decorator
@use_logging(level="warn")
def foo(name='foo'):
print("i am %s" % name)
foo()
上面的 use_logging是允许带参数的装饰器。它实际上是对原有装饰器的一个函数封装，并返回一个装饰器。我们可以将它理解为一个含有参数的闭包。当我 们使用@use_logging(level="warn")调用的时候，Python 能够发现这一层的封装，并把参数传递到装饰器的环境中。
@use_logging(level="warn") 等价于 @decorator
六、类装饰器
关于call方法，不得不先提到一个概念，就是可调用对象（callable），我们平时自定义的函数、内置函数和类都属于可调用对象，
但凡是可以把一对括号()应用到某个对象身上都可称之为可调用对象，判断对象是否为可调用对象可以用函数 callable。
如果在类中实现了call方法，那么实例对象也将成为一个可调用对象
import time
class runtime(object):
def __init__(self, func):
self.func = func
def __call__(self, *args, **kwargs):
start = time.time()
f = self.func(*args, **kwargs) # 原函数
end = time.time()
print("运行时长：%.4f 秒" % (end-start))
return f
@runtime
def func_a(a):
print("hello"+a)
time.sleep(0.5)
@runtime
def func_b(b, c="xx"):
print("world"+b+c)
time.sleep(0.8)
if __name__ == '__main__':
func_a("a")
func_b("b", c="xxx")
类装饰器带参数
import time
class runtime(object):
def __init__(self, slowly=1):
self.slowly = slowly
def __call__(self, func):
def wrapper(*args, **kwargs):
start = time.time()
f = func(*args, **kwargs) # 原函数
end = time.time()
t = end-start
time.sleep((self.slowly-1)*t) # 延迟效果
new_end = time.time()
print("运行时长：%.4f 秒" % (new_end-start))
return f
return wrapper
@runtime(1.5)
def func_a(a):
print("hello"+a)
time.sleep(0.5)
@runtime(1.5)
def func_b(b, c="xx"):
print("world"+b+c)
time.sleep(0.8)
if __name__ == '__main__':
func_a("a")
func_b("b", c="xxx")
参考：
菜鸟教程
上海-悠悠