说说Python中的装饰器是什么？装潢师是如何工作的？相信朋友们也应该密切关注这个话题。现在，Python中的装饰器对我的朋友来说是什么？装潢师是如何工作的？边肖还收集了关于Python中什么是装饰器的信息。装潢师是如何工作的？我希望你看到后会喜欢。

Python很早就引入了decorator ——作为简化PEP-318中函数和方法定义的机制。这些函数和方法必须在初始定义后进行修改。

这样做的最初动机之一是使用诸如classmethod和staticmethod这样的函数来转换方法的原始定义，但是它们需要一行额外的代码来修改函数的原始定义。

一般来说，每次转换必须应用于函数时，我们必须用修饰符函数调用它，然后将它重新分配给最初定义时的函数名。

例如，假设有一个名为origin的函数，其上有一个改变origin行为的函数(称为修饰符)，那么我们必须这样写：

def原件(.):

.

Original=修改器(Original)(相关免费学习推荐：python视频教程)

请注意我们如何更改函数并将其重新分配到相同的名称。这很混乱，容易出错(假设有人忘记重新分配函数或重新分配函数，但它不在函数定义后面的行中，而是在更远的地方)并且很麻烦。为此，Python语言增加了一些语法支持。

前面的例子可以改写如下：

@修饰符

def原件(.):

.这意味着装饰器只是语法糖用来调用装饰器作为装饰器本身的第一个参数之后的内容，结果将是装饰器返回的内容。

为了与Python术语保持一致，在我们的示例中，修饰符被称为decorator。original是一个装饰函数，也称为wrapper对象。

虽然这个函数最初被认为是用于方法和函数的，但是实际的语法允许它修饰任何类型的对象，所以我们将研究应用于函数、方法、生成器和类的修饰器。

最后要注意的是，尽管装饰器的名称是正确的(毕竟，装饰器实际上是在更改、扩展或处理包装器函数)，但不要将其与装饰器设计模式混淆。

装饰器功能

函数可能是可以修饰的Python对象的最简单表示。我们可以使用装饰器将各种逻辑应用于函数。——我们可以验证参数、检查前提条件、完全改变行为、修改它们的签名、缓存结果(创建原始函数的内存版本)等等。

例如，我们将创建一个实现重试机制的基本装饰器来控制特定的域级异常，并重试一定次数：

# decorator_function_1.py

类控制器异常(异常):

“”程序域中的一般异常''

def重试(操作):

@包装(操作)

def包装(*args，**kwargs):

最后提出=无

RETRIES_LIMIT=3

for _ in范围(RETRIES_LIMIT):

尝试：

返回操作(*args，**kwargs)

除了控制器例外，如e:

logger.info('正在重试%s '，操作。__qualname__)

last_raised=e

最后一次加注

返回包装现在可以忽略@wrap的使用，因为它将在另一节中讨论。在for循环中使用“_”意味着这个数字被分配给一个我们目前不感兴趣的变量，因为它没有在for循环中使用(命名一个被忽略的值“_”是Python中常见的习惯用法)。

重试装饰器不接收任何参数，因此它可以很容易地应用于任何函数，如下所示：

@重试

def运行操作(任务):

''运行特定任务，模拟其执行中的一些失败。'''

Return task.run正如开头所解释的，run_operation上面@retry的定义只是Python为实际执行run _ operation=retry(run _ operation)提供的语法糖。

在这个有限的例子中，我们可以看到如何用decorator创建一个通用retr。

y操作在某些确定的条件下（在本示例中表示为可能与超时相关的异常）该操作将允许多次调用装饰后的代码。

5.1.2　装饰类

类也可以被装饰（PEP-3129）其装饰方法与语法函数的装饰方法相同。唯一的区别是在为装饰器编写代码时我们必须考虑到所接收的是一个类而不是一个函数。

一些实践者可能会认为装饰类是相当复杂的事情这样的场景可能会损害可读性因为我们将在类中声明一些属性和方法但是在幕后装饰器可能会应用一些变化从而呈现一个完全不同的类。

这种评定是正确的但只有在装饰类技术被严重滥用的情况下成立。客观上这与装饰功能没有什么不同；毕竟类和函数一样都只是Python生态系统中的一种类型的对象而已。在5.4节中我们将再次审视这个问题的优缺点但是这里只探索装饰器的优点尤其是适用于类的装饰器的优点。

（1）重用代码和DRY原则的所有好处。类装饰器的一个有效情况是强制多个类符合特定的接口或标准（通过只在将应用于多个类的装饰器中进行一次检查）。

（2）可以创建更小或更简单的类——这些类稍后将由装饰器进行增强。

（3）如果使用装饰器那么需要应用到特定类上的转换逻辑将更容易维护而不会使用更复杂的（通常是不鼓励使用的）方法如元类。

在装饰器的所有可能应用程序中我们将探索一个简单的示例以了解装饰器可以用于哪些方面。记住这不是类装饰器的唯一应用程序类型而且给出的代码还可以有许多其他解决方案。所有这些解决方案都有优缺点之所以选择装饰器是为了说明它们的用处。

回顾用于监视平台的事件系统现在需要转换每个事件的数据并将其发送到外部系统。然而在选择如何发送数据时每种类型的事件可能都有自己的特殊性。

特别是登录事件可能包含敏感信息例如我们希望隐藏的凭据。时间戳等其他领域的字段可能也需要一些转换因为我们希望以特定的格式显示它们。符合这些要求的第一次尝试很简单就像有一个映射到每个特定事件的类并知道如何序列化它那样：

class LoginEventSerializer: def __init__(self, event): self.event = event def serialize(self) -> dict: return { "username": self.event.username, "password": "**redacted**", "ip": self.event.ip, "timestamp": self.event.timestamp.strftime("%Y-%m-%d %H:%M"), } class LoginEvent: SERIALIZER = LoginEventSerializer def __init__(self, username, password, ip, timestamp): self.username = username self.password = password self.ip = ip self.timestamp = timestamp def serialize(self) -> dict: return self.SERIALIZER(self).serialize

在这里我们声明一个类。该类将直接映射到登录事件其中包含它的一些逻辑——隐藏密码字段并根据需要格式化时间戳。

虽然这是可行的可能开始看起来是一个不错的选择但随着时间的推移若要扩展系统就会发现一些问题。

（1）类太多。随着事件数量的增多序列化类的数量将以相同的量级增长因为它们是一一映射的。

（2）解决方案不够灵活。如果我们需要重用部分组件（例如需要把密码藏在也有类似需求的另一个类型的事件中）就不得不将其提取到一个函数但也要从多个类中调用它这意味着我们没有重用那么多代码。

（3）样板文件。serialize方法必须出现在所有事件类中同时调用相同的代码。尽管我们可以将其提取到另一个类中（创建mixin）但这似乎没有很好地使用继承。

另一种解决方案是能够动态构造一个对象：给定一组过滤器（转换函数）和一个事件实例该对象能够通过将过滤器应用于其字段的方式序列化它。然后我们只需要定义转换每种字段类型的函数并通过组合这些函数创建序列化器。

一旦有了这个对象我们就可以装饰类以添加serialize方法。该方法只会调用这些序列化对象本身：

def hide_field(field) -> str: return "**redacted**" def format_time(field_timestamp: datetime) -> str: return field_timestamp.strftime("%Y-%m-%d %H:%M") def show_original(event_field): return event_field class EventSerializer: def __init__(self, serialization_fields: dict) -> None: self.serialization_fields = serialization_fields def serialize(self, event) -> dict: return { field: transformation(getattr(event, field)) for field, transformation in self.serialization_fields.items } class Serialization: def __init__(self, **transformations): self.serializer = EventSerializer(transformations) def __call__(self, event_class): def serialize_method(event_instance): return self.serializer.serialize(event_instance) event_class.serialize = serialize_method return event_class @Serialization( username=show_original, password=hide_field, ip=show_original, timestamp=format_time, ) class LoginEvent: def __init__(self, username, password, ip, timestamp): self.username = username self.password = password self.ip = ip self.timestamp = timestamp

注意装饰器让你更容易知道如何处理每个字段而不必查看另一个类的代码。仅通过读取传递给类装饰器的参数我们就知道用户名和IP地址将保持不变密码将被隐藏时间戳将被格式化。

现在类的代码不需要定义serialize方法也不需要从实现它的mixin类进行扩展因为这些都将由装饰器添加。实际上这可能是创建类装饰器的唯一理由因为如果不是这样的话序列化对象可能是LoginEvent的一个类属性但是它通过向该类添加一个新方法来更改类这使得创建该类装饰器变得不可能。

我们还可以使用另一个类装饰器通过定义类的属性来实现init方法的逻辑但这超出了本例的范围。

通过使用Python 3.7+ 中的这个类装饰器（PEP-557）可以按更简洁的方式重写前面的示例而不使用init的样板代码如下所示：

from dataclasses import dataclass from datetime import datetime @Serialization( username=show_original, password=hide_field, ip=show_original, timestamp=format_time, ) @dataclass class LoginEvent: username: str password: str ip: str timestamp: datetime

5.1.3　其他类型的装饰器

既然我们已经知道了装饰器的@语法的实际含义就可以得出这样的结论：可以装饰的不仅是函数、方法或类；实际上任何可以定义的东西（如生成器、协同程序甚至是装饰过的对象）都可以装饰这意味着装饰器可以堆叠起来。

前面的示例展示了如何链接装饰器。我们先定义类然后将@dataclass应用于该类——它将该类转换为数据类充当这些属性的容器。之后通过@Serialization把逻辑应用到该类上从而生成一个新类其中添加了新的serialize方法。

装饰器另一个好的用法是用于应该用作协同程序的生成器。我们将在第7章中探讨生成器和协同程序的细节其主要思想是在向新创建的生成器发送任何数据之前必须通过调用next将后者推进到下一个yield语句。这是每个用户都必须记住的手动过程因此很容易出错。我们可以轻松创建一个装饰器使其接收生成器作为参数调用next然后返回生成器。

5.1.4　将参数传递给装饰器

至此我们已经将装饰器看作Python中的一个强大工具。如果我们可以将参数传递给装饰器使其逻辑更加抽象那么其功能可能会更加强大。

有几种实现装饰器的方法可以接收参数但是接下来我们只讨论最常见的方法。第一种方法是将装饰器创建为带有新的间接层的嵌套函数使装饰器中的所有内容深入一层。第二种方法是为装饰器使用一个类。

通常第二种方法更倾向于可读性因为从对象的角度考虑其要比3个或3个以上使用闭包的嵌套函数更容易。但是为了完整起见我们将对这两种方法进行探讨以便你可以选择使用最适合当前问题的方法。

1．带有嵌套函数的装饰器

粗略地说装饰器的基本思想是创建一个返回函数的函数（通常称为高阶函数）。在装饰器主体中定义的内部函数将是实际被调用的函数。

现在如果希望将参数传递给它就需要另一间接层。第一个函数将接收参数在该函数中我们将定义一个新函数（它将是装饰器）而这个新函数又将定义另一个新函数即装饰过程返回的函数。这意味着我们将至少有3层嵌套函数。

如果你到目前为止还不明白上述内容的含义也不用担心待查看下面给出的示例之后就会明白了。

第一个示例是装饰器在一些函数上实现重试功能。这是个好主意只是有个问题：实现不允许指定重试次数只允许在装饰器中指定一个固定的次数。

现在我们希望能够指出每个示例有多少次重试也许甚至可以为这个参数添加一个默认值。为了实现这个功能我们需要用到另一层嵌套函数——先用于参数然后用于装饰器本身。

这是因为如下代码：

@retry(arg1, arg2,... )

必须返回装饰器因为@语法将把计算结果应用到要装饰的对象上。从语义上讲它可以翻译成如下内容：

<original_function> = retry(arg1, arg2, ....)(<original_function>)

除了所需的重试次数我们还可以指明希望控制的异常类型。支持新需求的新版本代码可能是这样的：

RETRIES_LIMIT = 3 def with_retry(retries_limit=RETRIES_LIMIT, allowed_exceptions=None): allowed_exceptions = allowed_exceptions or (ControlledException,) def retry(operation): @wraps(operation) def wrapped(*args, **kwargs): last_raised = None for _ in range(retries_limit): try: return operation(*args, **kwargs) except allowed_exceptions as e: logger.info("retrying %s due to %s", operation, e) last_raised = e raise last_raised return wrapped return retry

下面是这个装饰器如何应用于函数的一些示例其中显示了它接收的不同选项：

# decorator_parametrized_1.py @with_retry def run_operation(task): return task.run @with_retry(retries_limit=5) def run_with_custom_retries_limit(task): return task.run @with_retry(allowed_exceptions=(AttributeError,)) def run_with_custom_exceptions(task): return task.run @with_retry( retries_limit=4, allowed_exceptions=(ZeropisionError, AttributeError) ) def run_with_custom_parameters(task): return task.run

2．装饰器对象

前面的示例需要用到3层嵌套函数。首先这将是一个用于接收我们想要使用的装饰器的参数。在这个函数中其余的函数是使用这些参数和装饰器逻辑的闭包。

更简洁的实现方法是用一个类定义装饰器。在这种情况下我们可以在__init__方法中传递参数然后在名为__call__的魔法方法上实现装饰器的逻辑。

装饰器的代码如下所示：

class WithRetry: def __init__(self, retries_limit=RETRIES_LIMIT, allowed_exceptions=None): self.retries_limit = retries_limit self.allowed_exceptions = allowed_exceptions or (ControlledException,) def __call__(self, operation): @wraps(operation) def wrapped(*args, **kwargs): last_raised = None for _ in range(self.retries_limit): try: return operation(*args, **kwargs) except self.allowed_exceptions as e: logger.info("retrying %s due to %s", operation, e) last_raised = e raise last_raised return wrapped

这个装饰器可以像之前的一样应用就像这样：

@WithRetry(retries_limit=5) def run_with_custom_retries_limit(task): return task.run

注意Python语法在这里是如何起作用的这一点很重要。首先我们创建对象这样在应用@操作之前对象已经创建好了并且其参数传递给它了用这些参数初始化这个对象如init方法中定义的那样。在此之后我们将调用@操作这样该对象将包装名为run_with_custom_reries_limit的函数而这意味着它将被传递给call这个魔法方法。

在call这个魔法方法中我们定义了装饰器的逻辑就像通常所做的那样——包装了原始函数返回一个新的函数其中包含所要的逻辑。

5.1.5　充分利用装饰器

本节介绍一些充分利用装饰器的常见模式。在有些常见的场景中使用装饰器是个非常好的选择。

可用于应用程序的装饰器数不胜数下面仅列举几个最常见或相关的。

（1）转换参数。更改函数的签名以公开更好的API同时封装关于如何处理和转换参数的详细信息。

（2）跟踪代码。记录函数及其参数的执行情况。

（3）验证参数。

（4）实现重试操作。

（5）通过把一些（重复的）逻辑移到装饰器中来简化类。

接下来详细讨论前两个应用程序。

1．转换参数

前文提到装饰器可以用来验证参数（甚至在DbC的概念下强制一些前置条件或后置条件）因此你可能已经了解到这是一些处理或者操控参数时使用装饰器的常用方法。

特别是在某些情况下我们会发现自己反复创建类似的对象或者应用类似的转换而我们希望将这些转换抽象掉。大多数时候我们可以通过简单地用装饰器实现这一点。

2．跟踪代码

在本节中讨论跟踪时我们将提到一些更通用的内容这些内容与处理所要监控的函数的执行有关具体是指：

（1）实际跟踪函数的执行（例如通过记录函数执行的行）；

（2）监控函数的一些指标（如CPU使用量或内存占用）；

（3）测量函数的运行时间；

（4）函数被调用时的日志以及传递给它的参数。

我们将在5.2节剖析一个简单的装饰器示例该示例记录了函数的执行情况包括函数名和运行时间。

本文摘自《编写整洁的Python代码》

本书介绍Python软件工程的主要实践和原则旨在帮助读者编写更易于维护和更整洁的代码。全书共10章：第1章介绍Python语言的基础知识和搭建Python开发环境所需的主要工具；第2章描述Python风格代码介绍Python中的第一个习惯用法；第3章总结好代码的一般特征回顾软件工程中的一般原则；第4章介绍一套面向对象软件设计的原则即SOLID原则；第5章介绍装饰器它是Python的**特性之一；第6章探讨描述符介绍如何通过描述符从对象中获取更多的信息；第7章和第8章介绍生成器以及单元测试和重构的相关内容；第9章回顾Python中最常见的设计模式；第10章再次强调代码整洁是实现良好架构的基础。

本书适合所有Python编程爱好者、对程序设计感兴趣的人以及其他想学习更多Python知识的软件工程的从业人员。

相关免费学习推荐：python教程（视频）

以上就是Python中的装饰器是什么装饰器是如何工作的的详细内容！

来源：php中文网