python：装饰器与偏函数

装饰器

对于某个函数或类，需要增添大量类似的需求。对于类来说，可以用继承解决，但是继承会增加大量的静态属性，子类会变得越来越臃肿；对于函数来说，每个需求增加一个函数封装过于繁琐。
装饰器的出现解决了这一问题。装饰器本身是一个python函数，它可以让其它函数不发生变动的情况下增加额外的功能，装饰器的返回值是函数对象。
直观来说，装饰器就是为已有代码增添新的功能。
原代码：

def foo():
    print('i am foo')

此时，希望增加打印日志功能
使用函数封装：

def use_logging(func):
	logging.warn("%s is running" % func.__name__)
    func()
    
use_logging(foo)

使用装饰器：

def use_logging(func):
	def warpper(*args,**kwargs):
		loggin.warn("%s is running"% func.__name__)
		return func(*args,**kwargs)
	return warpper

foo = use_logging(foo)
foo()

语法糖＠可以帮助我们减少一次函数定义：

def use_logging(func):
	def warpper(*args,**kwargs):
		loggin.warn("%s is running"% func.__name__)
		return func(*args,**kwargs)
	return warpper

@use_logging   # 对要扩展功能的函数使用语法糖＠
def foo():
    print('i am foo')

foo()

语法糖＠帮我们省去了foo = use_logging(foo)这一句。

带参装饰器
使用装饰器时，可以对装饰器传递参数，如@use_logging(level)

def use_logging(level):
	def decorator(func):
		def wrapper(*args, **kwargs):
			if level == "warn":
				logging.warn("%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能够发现这一层的封装，并把参数传递到装饰器的环境中。

类装饰器
相比函数装饰器，类装饰器具有灵活度大、高内聚、封装性等优点。使用类装饰器还可以依靠类内部的__call__方法，当使用 @ 形式将装饰器附加到函数上时，就会调用此方法。

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()

functools.wraps
使用装饰器极大地复用了代码，但是他有一个缺点就是原函数的元信息不见了，比如函数的docstring、__name__、参数列表：

def logged(func):
	def with_logging(*args, **kwargs):
		print func.__name__ + " was called"
		return func(*args, **kwargs)
	return with_logging

@logged
def f(x):
	"""does some math"""
	return x + x * x

该函数完成等价于：

def f(x):
	"""does some math"""
	return x + x * x

f = logged(f)

不难发现，函数f被with_logging取代了，当然它的docstring，__name__就是变成了with_logging函数的信息了。

functools.wraps能解决这一问题。wraps本身也是一个装饰器，它能把原函数的元信息拷贝到装饰器函数中，这使得装饰器函数也有和原函数一样的元信息了。

from functools import wraps

def logged(func):
	@wraps(func)  # add
	def with_logging(*args, **kwargs):
		print func.__name__ + " was called"
		return func(*args, **kwargs)
	return with_logging

@logged
def f(x):
	"""does some math"""
	return x + x * x
	print f.__name__ # prints 'f'print f.__doc__ # prints 'does some math'

内置装饰器
@staticmathod、@classmethod、@property

装饰器的顺序:

@a
@b
@c
def f ():

等效于f = a(b(c(f)))

偏函数

偏函数可以设定函数的默认行为.
例子：通过设定参数来让int()函数默认转换成八进制数字

# 首先导入 functools 模块
import functools

# 定义一个默认转换为二进制的int函数
int2 = functools.partial(int, base=2)
# 调用 
int2('10110101')
181

functools.partial的作用就是将固定一个函数的默认行为，从而简化之后的使用
这个方法可以接收函数、*args、**kwargs这些对象

当函数的参数个数太多，需要简化时，使用functools.partial可以创建一个新的函数，这个新函数可以固定住原函数的部分参数，从而在调用时更简单。

参考:

• https://www.zhihu.com/question/26930016
• https://www.cnblogs.com/weihengblog/p/9379601.html
• https://zhuanlan.zhihu.com/p/48038848