python：装饰器与偏函数

小咪咪 2023-07-11 12:57 2阅读 0赞

# 装饰器 #

对于某个函数或类，需要增添大量类似的需求。对于类来说，可以用继承解决，但是继承会增加大量的静态属性，子类会变得越来越臃肿；对于函数来说，每个需求增加一个函数封装过于繁琐。  
装饰器的出现解决了这一问题。装饰器本身是一个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.zhihu.com_question_26930016]
 *  [https://www.cnblogs.com/weihengblog/p/9379601.html][https_www.cnblogs.com_weihengblog_p_9379601.html]
 *  [https://zhuanlan.zhihu.com/p/48038848][https_zhuanlan.zhihu.com_p_48038848]

[https_www.zhihu.com_question_26930016]: https://www.zhihu.com/question/26930016
[https_www.cnblogs.com_weihengblog_p_9379601.html]: https://www.cnblogs.com/weihengblog/p/9379601.html
[https_zhuanlan.zhihu.com_p_48038848]: https://zhuanlan.zhihu.com/p/48038848