浅谈Python中的装饰器
Python的装饰器，是Python函数(或者类)功能增强的一种方式。在了解装饰器之前，有必要先了解两个概念：闭包和柯里化。
闭包
Python的装饰器，实际上的闭包的应用。了解闭包是什么及其特性，请浏览这篇文章《理解Python闭包概念》。
柯里化
所谓的柯里化，先来看看它在维基百科上的解释：
柯里化，英语：Currying，是把接受多个参数的函数变换成接受一个单一参数（最初函数的第一个参数）的函数，并且返回接受余下的参数而且返回结果的新函数的技术。
例子如下：
# add 函数，接收两个参数并返回和
def add(x,y):
return x + y
# 将add函数柯里化
def add(x):
def _add(y):
return x + y
return _add
# 调用：
t = add(4)
t(5) # 输出 9
通过嵌套函数，把函数柯里化了。柯里化函数，其实就是闭包的应用。或者反过来说也成立，利用柯里化机制的函数，就是闭包函数。二者相辅相成。
了解了柯里化和闭包的概念，我们就可以来看看装饰器的概念了。
装饰器
Python的装饰器是为函数进行功能增强的一种方式。试想下有这么一个需求：
实际业务中，某些关键性函数必须增加打印日志的功能。
为了降低代码的耦合性，打印功能不应该糅合到其他业务功能的代码中，而是作为一个增强性的功能而存在。此时，就不应该侵入到指定的函数增加输出日志的代码，而应该把它抽象出来，作为一个功能增强的装饰而存在。
我们知道，为了实现代码重用，可以把代码抽象为函数的形式。那装饰器是不是也是函数？是的。
本质上，装饰器就是一个函数(或者类)，它接收函数作为参数，并返回另一个函数对象。因此，装饰器是一种高阶函数，它实现了对传入函数的功能的增强(装饰)。
无参装饰器
下面来看看例子，是如何使用装饰器：
需求：一个加法函数，想增强它的功能，能够输出被调用过以及调用的参数信息。
# 原函数
def add(x,y):
return x + y
# 增加信息输出功能 v1
def add(x,y):
print("call add, x + y") # 日志输出到控制台
return x + y
上述的v1版加法函数满足了需求，但存在以下缺点：
- 打印语句的耦合度太高
- 加法函数属于业务功能，而输出信息的功能则属于非业务功能代码，不应该放到业务函数中。否则改变了业务功能函数的属性。
我们只需要，在调用add函数前，把打印语句先打印出来就可以了。比如：
def add(x,y):
return x + y
def logger(fn,x,y):
print('args: {}.{}'.format(x,y))
ret = fn(x,y)
print('call finished!')
return ret
print(logger(add,4,5))
更加通用的实现：
def add(x,y):
return x + y
def logger(fn,*args,**kwargs): # 这里存在多个参数，可以做柯里化
print('args: {},{}'.format(*args,*kwargs))
ret = fn(*args,**kwargs)
print('call finished!')
return ret
print(logger(add,4,5))
对logger柯里化：
def add(x,y):
return x + y
def logger(fn):
def _logger(*args,**kwargs):
print('args: {},{}'.format(*args, *kwargs))
ret = fn(*args,**kwargs)
return ret
print('call finished!')
return _logger
print(logger(add)(4,5))
注意：logger(add)返回的是_logger，而_logger函数返回的是fn，也就是add的调用结果。因此，实际上_logger函数指向了新的add函数。也就是说logger(add) -> _logger -> add。
因此，可以如此表示add = logger(add)，使用语法糖@，变成了以下形式：
def logger(fn):
def _logger(*args,**kwargs):
print('args: {},{}'.format(*args, *kwargs))
ret = fn(*args,**kwargs)
return ret
print('call finished!')
return _logger
@logger # 语法糖，用于装饰器函数。它相当于执行了add = logger(add)
def add(x,y):
return x + y
print(add(4,5))
业务函数好比一幅画，而装饰器则比作画外部的画框，以实现不同的装饰。比如，前置功能增强或者后置功能增强。
装饰器的本质是使用非侵入式代码进行功能增强。当然，此功能即使不使用，也不应该影响原来的业务功能。
副作用
经过logger装饰的add函数，实际上已经不是原来的add函数了，它已经变成了装饰器函数。因此带来一些副作用。
看下面的例子：
def logger(fn):
def wrapper(*args,**kwargs):
'I am wrapper'
print('args: {},{}'.format(*args, *kwargs))
ret = fn(*args,**kwargs)
return ret
print('call finished!')
return wrapper
@logger
def add(x,y):
'This is a function for add'
return x + y
print("name={},doc={}".format(add.__name__,add.__doc__))
输出：
call finished!
name=wrapper,doc=I am wrapper
add函数的文档字符串改变了。原对象的属性都被替换了。实际上，我们关心的是被包装函数的属性(原add函数)，而无关装饰器。
因此，需要考虑将需要的属性，从被包装函数，覆盖到包装函数中。
def copy_properties(src,dest):
dest.__name__ = src.__name__
dest.__doc__ = src.__doc__
# ... 还有许多属性
def logger(fn):
def wrapper(*args,**kwargs):
'I am wrapper'
print('args: {},{}'.format(*args, *kwargs))
ret = fn(*args,**kwargs)
return ret
copy_properties(fn,wrapper)
print('call finished!')
return wrapper
@logger
def add(x,y):
'This is a function for add'
return x + y
print("name={},doc={}".format(add.__name__,add.__doc__))
输出：
call finished!
name=add,doc=This is a function for add
我们应该知道，上述的copy_properties函数，实际上就是wrapper函数功能的增强，那是否可以把它改造成装饰器？
带参装饰器
def copy_properties(src):
def _inner(dest):
dest.__name__ = src.__name__
dest.__doc__ = src.__doc__
return dest
return _inner
def logger(fn):
@copy_properties(fn) # wrapper = copy_properties(fn)(wrapper)
def wrapper(*args,**kwargs):
'I am wrapper'
print('args: {},{}'.format(*args, *kwargs))
ret = fn(*args,**kwargs)
return ret
print('call finished!')
return wrapper
@logger
def add(x,y):
'This is a function for add'
return x + y
print("name={},doc={}".format(add.__name__,add.__doc__))
因为装饰器携带参数，因此成为带参装饰器。上述的例子，是一个应用在装饰器里的装饰器。
functools模块
functools.update_wrapper
上述带参装饰器的例子中，写一个copy_properties函数来指定原函数需要传递的属性值，这种方式不够优雅。functools.update_wrapper正好解决了这个问题。
先看看它的构造函数：
WRAPPER_ASSIGNMENTS = ('__module__', '__name__', '__qualname__', '__doc__',
'__annotations__')
WRAPPER_UPDATES = ('__dict__',)
def update_wrapper(wrapper,
wrapped,
assigned = WRAPPER_ASSIGNMENTS,
updated = WRAPPER_UPDATES):
for attr in assigned: # 以元组的形式
try:
value = getattr(wrapped, attr) # 相当于value = wrapped[attr]
except AttributeError:
pass
else:
setattr(wrapper, attr, value) # 把原属性值，追加到wrapper. wrapper[attr] = value
for attr in updated: # 以字典的形式，attr为key
getattr(wrapper, attr).update(getattr(wrapped, attr, {}))
wrapper.__wrapped__ = wrapped
return wrapper
- wrapper是包装函数，wrapped是被包装函数
- 元组WRAPPER_ASSIGNMENTS中是要被覆盖的属性
- 元组WRAPPER_UPDATES是要被更新的属性，__dict__属性字典
- 增加一个__wrapped__属性，保留着wrapped被包装函数
因此，可以如此使用它：
import functools
def logger(fn):
def wrapper(*args,**kwargs):
'I am wrapper'
print('args: {},{}'.format(*args, *kwargs))
ret = fn(*args,**kwargs)
return ret
functools.update_wrapper(wrapper,fn) # 更新属性
print('call finished!')
return wrapper
@logger
def add(x,y):
'This is a function for add'
return x + y
print("name={},doc={}".format(add.__name__,add.__doc__))
是否可以把functools.update_wrapper改造成装饰器？
functools的另一个工具可以解决这个问题。
functools.wraps
源码：
def wraps(wrapped,
assigned = WRAPPER_ASSIGNMENTS,
updated = WRAPPER_UPDATES):
return partial(update_wrapper, wrapped=wrapped,
assigned=assigned, updated=updated)
这里简单说明下偏函数的作用
functools.partial把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。上述例子中，wraps 相当于update_wrapper(wrapped,assigned,updated)。当然它需要传递wrapped函数作为参数，因此它是一个带参装饰器。
偏函数把wrapped=wrapped,assigned=assigned, updated=updated这些参数固定住了，并传递给update_wrapper.
因此，可以如此使用它：
def logger(fn):
@functools.wraps(fn)
def wrapper(*args,**kwargs):
'I am wrapper'
print('args: {},{}'.format(*args, *kwargs))
ret = fn(*args,**kwargs)
return ret
print('call finished!')
return wrapper
此时，add.__wrapped__实际上就是原add，也就是fn了。这保留了wrapped函数。