自动化工具 Python 装饰器的进化史

1、史前故事

先看一个简单例子，实际可能会复杂不少：

def today():
 print('2018-05-25')

如今有一个新的需求，但愿能够记录下函数的执行日志，因而在代码中添加日志代码：

def today():
 print('2018-05-25')
 logging.info('today is running...')

若是函数 yesterday()、tomorrow() 也有相似的需求，怎么作？再写一个 logging 在yesterday函数里？这样就形成大量雷同的代码，为了减小重复写代码，咱们能够这样作，从新定义一个新的函数：专门处理日志 ，日志处理完以后再执行真正的业务代码

def logging_tool(func):
 logging.info('%s is running...' % func.__name__)
 func()

def today():
 print('2018-05-25')

logging_tool(today)

这样作逻辑上是没问题的，功能是实现了，可是咱们调用的时候再也不是调用真正的业务逻辑today函数，而是换成了logging_tool函数，这就破坏了原有的代码结构，为了支持日志功能，原有代码须要大幅修改，那么有没有更好的方式的呢？固然有，答案就是装饰器。

2、开天辟地

一个简单的装饰器

def logging_tool(func):
 def wrapper(*arg, **kwargs):
 logging.info('%s is running...' % func.__name__)
 func() # 把today看成参数传递进来，执行func()就至关于执行today()
 return wrapper

def today():
 print('2018-05-25')

today = logging_tool(today) # 由于装饰器logging_tool(today)返回函数对象wrapper，故这条语句至关于today=wrapper
today() # 执行today()就至关于执行wrapper()

以上也是装饰器的原理！！！

3、Pythonic世界的初探

@语法糖
接触 Python 有一段时间的话，对 @ 符号必定不陌生了，没错 @ 符号就是装饰器的语法糖，它放在函数开始定义的地方，这样就能够省略最后一步再次赋值的操做

def logging_tool(func):
 def wrapper(*arg, **kwargs):
 logging.info('%s is running...' % func.__name__)
 func() # 把today看成参数传递进来，执行func()就至关于执行today()
 return wrapper

@logging_tool
def today():
 print('2018-05-25')

today()

有了 @ ，咱们就能够省去today = logging_tool(today)这一句了，直接调用 today() 便可获得想要的结果。
不须要对today() 函数作任何修改，只需在定义的地方加上装饰器，调用的时候仍是和之前同样。
若是咱们有其余的相似函数，能够继续调用装饰器来修饰函数，而不用重复修改函数或者增长新的封装。这样，提升程序可重复利用性，并增长程序的可读性。

装饰器在 Python 使用之因此如此方便，归因于Python函数能像普通的对象同样能做为参数传递给其余函数，能够被赋值给其余变量，能够做为返回值，能够被定义在另一个函数内。

装饰器本质上是一个Python函数或类，它可让其余函数或类在不须要作任何代码修改的前提下增长额外的功能，装饰器的返回值也是一个函数/类对象。
它常常用于有切面需求的场景，好比：插入日志、性能测试、事务处理、缓存、权限校验等场景，装饰器是解决这类问题的绝佳设计。
有了装饰器，咱们就能够抽离出大量与函数功能自己无关的代码到装饰器中并继续重用。
简单来讲：装饰器的做用就是让已经存在的对象添加额外的功能。

4、多元化百家争鸣

一、带参数的装饰器

装饰器的语法容许咱们在调用时，提供其它参数，好比@decorator(condition)。为装饰器的编写和使用提供了更大的灵活性。好比，咱们能够在装饰器中指定日志的等级，由于不一样业务函数可能须要不一样的日志级别。

def logging_tool(level):
 def decorator(func):
 def wrapper(*arg, **kwargs):
 if level == 'error':
 logging.error('%s is running...' % func.__name__)
 elif level == 'warn':
 logging.warn('%s is running...' % func.__name__)
 else:
 logging.info('%s is running...' % func.__name__)
 func()
 return wrapper
 return decorator

@logging_tool(level='warn')
def today(name='devin'):
 print('Hello, %s! Today is 208-05-25' % name)

today()

二、让装饰器同时支持带参数或不带参数

def new_logging_tool(obj):
 if isinstanc(obj, str): # 带参数的状况，参数类型为str
 def decorator(func):
 @functools.wraps(func)
 def wrapper(*arg, **kwargs):
 if obj == 'error':
 logging.error('%s is running...' % func.__name__)
 elif obj == 'warn':
 logging.warn('%s is running...' % func.__name__)
 else:
 logging.info('%s is running...' % func.__name__)
 func()
 return wrapper
 return decorator
 else: # 不带参数的状况，参数类型为函数类型，即被装饰的函数
 @functools.wraps(obj)
 def wrapper(*args, **kwargs):
 logging.info('%s is running...' % obj.__name__)
 obj()
 return wrapper

@new_logging_tool
def yesterday():
 print('2018-05-24')

yesterday()

@new_logging_tool('warn')
def today(name='devin'):
 print('Hello, %s! Today is 208-05-25' % name)

today()

如上所示，参数有两种类型，一种是字符串，另外一种是可调用的函数类型。所以，经过对参数类型的判断便可实现支持带参数和不带参数的两种状况。

三、类装饰器

装饰器不只能够是函数，还能够是类，相比函数装饰器，类装饰器具备灵活度大、高内聚、封装性等优势。使用类装饰器主要依靠类的call方法，当使用 @ 形式将装饰器附加到函数上时，就会调用此方法。

（1）示例1、被装饰函数不带参数

class Foo(object):
 def __init__(self, func):
 self._func = func # 初始化装饰的函数

 def __call__(self):
 print ('class decorator runing')
 self._func() # 调用装饰的函数
 print ('class decorator ending')

@Foo
def bar(): # 被装饰函数不带参数的状况
 print ('bar')

bar()

（2）示例2、被装饰函数带参数

class Counter:
 def __init__(self, func):
 self.func = func
 self.count = 0 # 记录函数被调用的次数

 def __call__(self, *args, **kwargs): 
 self.count += 1
 return self.func(*args, **kwargs)

@Counter
def today(name='devin'):
 print('Hello, %s! Today is 208-05-25' % name) # 被装饰的函数带参数的状况

for i in range(10):
 today()
print(today.count) # 10

（3）示例3、不依赖初始化函数，单独使用call函数实现（体现类装饰器灵活性大、高内聚、封装性高的特色）
实现当一些重要函数执行时，打印日志到一个文件中，同时发送一个通知给用户

class LogTool(object):
 def __init__(self, logfile='out.log'):
 self.logfile = logfile # 指定日志记录文件

 def __call__(self, func): # __call__做为装饰器函数
 @functools.wraps(func)
 def wrapper(*args, **kwargs):
 log_string = func.__name__ + " was called"
 print(log_string) # 输出日志
 with open(self.logfile, 'a') as fw:
 fw.write(log_string + '\n') # 保存日志
 self.notify() # 发送通知
 return func(*args, **kwargs)
 return wrapper

 # 在类中实现通知功能的封装
 def notify(self):
 pass

@LogTool() # 单独使用__call__函数实现时，别忘了添加括号，进行类的初始化
def bill_func():
 pass

进一步扩展，给LogTool建立子类，来添加email的功能：

class EmailTool(LogTool):
 """
 LogTool的子类，实现email通知功能，在函数调用时发送email给用户
 """
 def __init__(self, email='admin@myproject.com', *args, **kwargs):
 self.email = email
 super(EmailTool, self).__init__(*args, **kwargs)

 # 覆盖父类的通知功能，实现发送一封email到self.email
 def notify(self):
 pass

@EmailTool()
def bill_func():
 pass

四、装饰函数 -> 装饰类

（1）函数层面的装饰器很常见，以一个函数做为输入，返回一个新的函数；
（2）类层面的装饰其实也相似，已一个类做为输入，返回一个新的类；

例如：给一个已有的类添加长度属性和getter、setter方法

def Length(cls):
 class NewClass(cls):
 @property
 def length(self):
 if hasattr(self, '__len__'):
 self._length = len(self)
 return self._length

 @length.setter
 def length(self, value):
 self._length = value
 return NewClass

@Length
class Tool(object):
 pass

t = Tool()
t.length = 10
print(t.length) # 10

5、上古神器

一、@property -> getter/setter方法

示例：给一个Student添加score属性的getter、setter方法

class Student(object):
 @property
 def score(self):
 return self._score

 @score.setter
 def score(self, value):
 if not isinstance(value, int):
 raise ValueError('score must be an integer')
 if value < 0 or value > 100:
 raise ValueError('score must between 0~100!')
 self._score = value

s = Student()
s.core = 60
print('s.score = ', s.score)
s.score = 999 # ValueError: score must between 0~100!

二、@classmethod、@staticmethod

（1）@classmethod 类方法：定义备选构造器，第一个参数是类自己（参数名不限制，通常用cls）
（2）@staticmethod 静态方法：跟类关系紧密的函数

简单原理示例：

class A(object):
 @classmethod
 def method(cls):
 pass

等价于

class A(object):
 def method(cls):
 pass
 method = classmethod(method)

三、@functools.wraps

装饰器极大地复用了代码，但它有一个缺点：由于返回的是嵌套的函数对象wrapper，不是原函数，致使原函数的元信息丢失，好比函数的docstring、name、参数列表等信息。不过呢，办法总比困难多，咱们能够经过@functools.wraps将原函数的元信息拷贝到装饰器里面的func函数中，使得装饰器里面的func和原函数有同样的元信息。

def timethis(func):
 """
 Decorator that reports the execution time.
 """
 @wraps(func)
 def wrapper(*args, **kwargs):
 start = time.time()
 result = func(*args, **kwargs)
 print(func.__name__, time.time() - start)
 return result
 return wrapper


@timethis
def countdown(n: int):
 """Counts down"""
 while n > 0:
 n -= 1


countdown(10000000) # 1.3556335
print(countdown.__name__, ' doc: ', countdown.__doc__, ' annotations: ', countdown.__annotations__)

@functools.wraps让咱们能够经过属性wrapped直接访问被装饰的函数，同时让被装饰函数正确暴露底层的参数签名信息

countdown.__wrapped__(1000) # 访问被装饰的函数
print(inspect.signature(countdown)) # 输出被装饰函数的签名信息

四、Easter egg

（1） 定义一个接受参数的包装器

@decorator(x, y, z)
def func(a, b):
 pass

等价于

func = decorator(x, y, z)(func)

即：decorator(x, y, z)的返回结果必须是一个可调用的对象，它接受一个函数做为参数并包装它。

（2）一个函数能够同时定义多个装饰器，好比：

@a
@b
@c
def f():
 pass

等价于

f = a(b(c(f)))

即：它的执行顺序是从里到外，最早调用最里层，最后调用最外层的装饰器。