Python——装饰器基础

装饰器基础

前面高速介绍了装饰器的语法,在这里,我们将深入装饰器内部工作机制。更具体更系统地介绍装饰器的内容,并学习自己编写新的装饰器的很多其它高级语法。

=================================================================================

什么是装饰器
装饰是为函数和类指定管理代码的一种方式。Python装饰器以两种形式呈现:
【1】函数装饰器在函数定义的时候进行名称重绑定。提供一个逻辑层来管理函数和方法或随后对它们的调用。
【2】类装饰器在类定义的时候进行名称重绑定,提供一个逻辑层来管理类。或管理随后调用它们所创建的实例。


简而言之,装饰器提供了一种方法,在函数和类定义语句的末尾插入自己主动执行的代码——对于函数装饰器。在def的末尾。对于类装饰器,在class的末尾。

这种代码能够扮演不同的角色。
装饰器提供了一些和代码维护性和审美相关的有点。此外,作为结构化工具,装饰器自然地促进了代码封装,这降低了冗余性并使得未来变得更easy。

=================================================================================

函数装饰器
通过在一个函数的def语句的末尾执行还有一个函数,把最初的函数名又一次绑定到结果。

----------------------------------------------------------------------------------------------------------------------------------------------

使用方法
装饰器在紧挨着定义一个函数或方法的def语句之前的一行编写,而且它由@符号以及紧随其后的对于元函数的一个引用组成——这是管理还有一个函数的一个函数(或其它可调用对象)。


在编码上,函数装饰器自己主动将例如以下语法:

@decorator
def F(arg):
	...
F(99)
映射为这个对等形式:

def F(arg):
	...
F = decorator(F)
F(99)
这里的装饰器是一个单參数的可调用对象,它返回与F具有同样数目的參数的一个可调用对象。
当随后调用F函数的时候。它自己主动调用装饰器所返回的对象。

换句话说,装饰实际把例如以下的第一行映射为第二行(虽然装饰器仅仅在装饰的时候执行一次)

fun(6,7)
decorator(func)(6,7)
这一自己主动名称重绑定也解释了之前介绍的静态方法和property装饰器语法的原因:
class C:
	@staticmethod
	def meth(...):...
	
	@property
	def name(self):...
----------------------------------------------------------------------------------------------------------------------------------------------
实现
装饰器自身是返回可调用对象的可调用对象。实际上,它能够是随意类型的可调用对象,而且返回随意类型的可调用对象:函数和类的不论什么组合都能够使用,虽然一些组合更适合于特定的背景。



有一种经常使用的编码模式——装饰器返回了一个包装器,包装器把最初的函数保持到一个封闭的作用域中:

def decorator(F):
	def wrapper(*args):
		# 使用 F 和 *args
		# 调用原来的F(*args)
	return wrapper

@decorator
def func(x,y):
	...

func(6,7)
当随后调用名称func的时候。它确实调用装饰器所返回的包装器函数。随后包装器函数可能执行最初的func。由于它在一个封闭的作用域中仍然能够使用。



为了对类做相同的事情,我们能够重载调用操作:

class decorator:
	def __init__(self,func):
		self.func = func
	def __call__(self,*args):
		# 使用self.func和args
		# self.func(*args)调用最初的func

@decorator
def func(x,y):
	...
func(6,7)
可是,要注意的是。基于类的代码中,它对于拦截简单函数有效,但当它应用于类方法函数时。并不非常有效:
例如以下反例:

class decorator:
	def __init__(self,func):
		self.func = func
	def __call__(self,*args):
		# 调用self.func(*args)失败,由于C实例參数无法传递

class C:
	@decorator
	def method(self,x,y):
		...
这时候装饰的方法重绑定到一个类的方法上,而不是一个简单的函数。这一点带来的问题是。当装饰器的方法__call__随后执行的时候,当中的self接受装饰器类实例,而且类C的实例不会包括到一个*args中。

这时候,嵌套函数的替代方法工作得更好:

def decorator:
	def warpper(*args):
		# ...
	return wrapper

@decorator
def func(x,y):
	...
func(6,7)

class C:
	@decorator
	def method(self,x,y):
		...

x = C()
x.method(6,7)
=================================================================================

类装饰器

类装饰器与函数装饰器使用同样的语法和很相似的编码方式。类装饰器是管理类的一种方式,或者用管理或扩展类所创建的实例的额外逻辑。来包装实例构建调用。


----------------------------------------------------------------------------------------------------------------------------------------------

使用方法
如果类装饰器返回一个可调用对象的一个单參数的函数,类装饰器的语法为

@decorator
class C:
	...
x = C(99)
等同于以下的语法:

class C:
	...
C = decorator(C)

x = C(99)
直接效果是随后调用类名会创建一个实例,该实例会触发装饰器所返回的可调用对象。而不是调用最初的类自身。
----------------------------------------------------------------------------------------------------------------------------------------------

实现
类装饰器返回的可调用对象,通常创建并返回最初的类的一个新的实例,以某种方式来扩展对其接口的管理。比如。以下的实例插入一个对象来拦截一个类实例的没有定义的属性:

def decorator(cls):
	class Wrapper:
		def __init__(self,*args):
			self.wrapped = cls(*args)
		def __getattr__(self,name):
			return getattr(self.wrapped,name)
	return Wrapper

@decorator
class C:				# C = decorator(C)
	def __init__(self,x,y):		# Run by Wrapper.__init__
		self.attr = 'spam'

x = C(6,7)				# 等价于Wrapper(6,7)
print(x.attr)
在这个样例中,装饰器把类的名称又一次绑定到还有一个类。这个类在一个封闭的作用域中保持了最初的类。

就像函数装饰器一样,类装饰器通常能够编写为一个创建并返回可调用对象的“工厂”函数。
=================================================================================

装饰器嵌套
有时候,一个装饰器不够。装饰器语法同意我们向一个装饰器的函数或方法加入包装器逻辑的多个层。这样的形式的装饰器的语法为

@A
@B
@C
def f(...):
	...
例如以下这样转换:
def f(...):
	...
f = A(B(C(f)))
这里。最初的函数通过3个不同的装饰器传递,每一个装饰器处理前一个结果。
=================================================================================

装饰器參数
函数装饰器和类装饰器都能接受參数,例如以下:

@decorator(A,B)
def F(arg):
	...
F(99)
自己主动映射到其对等形式:
def F(arg):
	...
F = decorator(A,B)(F)

F(99)
装饰器參数在装饰之前就解析了,而且它们通经常使用来保持状态信息供随后的调用使用。比如,这个样例中的装饰器函数。可能採用例如以下形式:
def decorator(A,B):
	# 保存或使用A和B
	def actualDecorator(F):
		# 保存或使用函数 F
		# 返回一个可调用对象
		return callable
	return actualDecorator

=================================================================================

以上,这是装饰器的基础知识。接下来将学习编写自己的装饰器

原文地址:https://www.cnblogs.com/wgwyanfs/p/7065992.html