Que sont les décorateurs en Python ? Comment travaillent les décorateurs ?

Python a introduit les décorateurs très tôt - dans PEP-318, en tant que mécanisme permettant de simplifier la façon dont les fonctions et les méthodes sont définies après leur définition initiale Revise.

L'une des motivations initiales pour faire cela était d'utiliser des fonctions comme classmethod et staticmethod pour transformer la définition originale d'une méthode, mais elles nécessitent une ligne de code supplémentaire pour modifier la définition initiale de la fonction.

De manière générale, chaque fois qu'une transformation doit être appliquée à une fonction, nous devons l'appeler avec la fonction modificateur puis lui attribuer le nom qu'elle avait lors de la définition initiale de la fonction.

Par exemple, supposons qu'il y ait une fonction appelée original, et qu'il y ait une fonction dessus qui change le comportement d'origine (appelée modificateur), alors nous devons écrire comme ceci :

def original(...):
    ...
original = modifier(original)

(Connexe apprentissage gratuit Recommandé : tutoriel vidéo Python )

Remarquez comment nous avons modifié la fonction et l'avons réaffectée au même nom. C'est déroutant, sujet aux erreurs (en supposant que quelqu'un oublie de réaffecter la fonction, ou réaffecte la fonction, mais pas sur la ligne après la définition de la fonction, mais quelque part plus loin) et fastidieux. Pour cette raison, le langage Python a ajouté une prise en charge de la syntaxe.

L'exemple précédent peut être réécrit comme suit :

@modifier
def original(...):
   ...

Cela signifie que le décorateur n'est qu'un sucre syntaxique car ce qui vient après que le décorateur soit appelé comme premier argument du décorateur lui-même, ce qui donne sera ce que le décorateur rendra.

Pour être cohérent avec la terminologie de Python, le modificateur dans notre exemple est appelé décorateur, et original est une fonction de décoration, souvent également appelée objet wrapper.

Bien que cette fonctionnalité ait été initialement conçue comme étant destinée aux méthodes et aux fonctions, la syntaxe actuelle lui permet de décorer tout type d'objet, nous examinerons donc les décorateurs appliqués aux fonctions, méthodes, générateurs et classes.

Une dernière remarque est que même si le nom du décorateur est correct (après tout, le décorateur apporte en fait des modifications, des extensions ou des manipulations à la fonction enveloppée), ne le comparez pas au modèle de conception du décorateur. Confus.

5.1.1 Fonctions de décorateur

Les fonctions sont probablement la représentation la plus simple des objets Python pouvant être décorés. Nous pouvons utiliser des décorateurs sur des fonctions pour appliquer toutes sortes de logiques - nous pouvons valider des paramètres, vérifier des conditions préalables, changer complètement le comportement, modifier sa signature, mettre en cache les résultats (créer une version en mémoire de la fonction d'origine), etc.

Par exemple, nous allons créer un décorateur de base qui implémente le mécanisme de nouvelle tentative, contrôle une exception spécifique au niveau du domaine et réessaye un certain nombre de fois :

# decorator_function_1.py
class ControlledException(Exception):
    """A generic exception on the program's domain."""

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

    return wrapped

Vous pouvez ignorer l'utilisation de @ Wrap pour l'instant, car cela sera discuté dans une autre section. Utiliser "_" dans une boucle for signifie que le numéro est attribué à une variable qui ne nous intéresse pas pour le moment car elle n'est pas utilisée dans la boucle for (en Python, il est courant de nommer des valeurs ignorées" _" usage idiomatique). Le décorateur

retry ne reçoit aucun paramètre, il peut donc être facilement appliqué à n'importe quelle fonction comme indiqué ci-dessous :

@retry
def run_operation(task):
    """Run a particular task, simulating some failures on its execution."""
    return task.run()

Comme expliqué au début, en plus de run_operation @retry La définition est juste du sucre syntaxique fourni par Python pour exécuter réellement run_operation = retry(run_operation).

Dans cet exemple limité, nous pouvons voir comment utiliser un décorateur pour créer une opération de nouvelle tentative générique qui, dans certaines conditions déterminées (dans cet exemple, exprimées comme une éventuelle exception liée au timeout), qui permettra au code décoré à appeler plusieurs fois.

5.1.2 Classes de décoration

Les classes peuvent également être décorées (PEP-3129), et leurs méthodes de décoration sont les mêmes que celles des fonctions syntaxiques. La seule différence est que lors de l'écriture du code pour le décorateur, nous devons tenir compte du fait que ce qui est reçu est une classe et non une fonction.

Certains praticiens peuvent penser que décorer une classe est une affaire assez compliquée, et un tel scénario peut nuire à la lisibilité car nous déclarerons certaines propriétés et méthodes dans la classe, mais en coulisses, le décorateur peut appliquer quelques modifications , rendant ainsi une classe complètement différente.

Cette évaluation est correcte, mais elle n'est vraie que lorsque la technologie décorative est gravement abusée. Objectivement, cela n'est pas différent de la décoration de fonctions ; après tout, les classes, comme les fonctions, ne sont qu'un type d'objet dans l'écosystème Python. Nous examinerons à nouveau les avantages et les inconvénients de ce problème dans la section 5.4, mais ici nous explorerons simplement les avantages des décorateurs, en particulier ceux qui s'appliquent aux classes.

(1) Tous les avantages de la réutilisation du code et du principe DRY. Un cas utile pour les décorateurs de classe est de forcer plusieurs classes à se conformer à une interface ou à une norme spécifique (en effectuant une seule vérification dans le décorateur qui sera appliquée à plusieurs classes).

(2) Vous pouvez créer des classes plus petites ou plus simples - ces classes seront ensuite améliorées par les décorateurs.

(3) Si vous utilisez des décorateurs, la logique de conversion qui doit être appliquée à une classe spécifique sera plus facile à maintenir sans utiliser de méthodes plus complexes (généralement déconseillées) telles que les métaclasses.

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

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

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

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) Suivez réellement l'exécution de la fonction (par exemple, en enregistrant les lignes d'exécution de la fonction

(2) Surveillez certaines métriques de la fonction (telles que l'utilisation du processeur ou l'utilisation de la mémoire) ; ;

(3) Mesurer le temps d'exécution de la fonction

(4) Enregistrez le moment où la fonction est appelée et les paramètres qui lui sont transmis.

Nous analyserons un exemple simple de décorateur dans la section 5.2, qui enregistre l'exécution de la fonction, y compris le nom de la fonction et la durée d'exécution.

Cet article est extrait de "Writing Clean Python Code"

Ce livre présente les principales pratiques et principes de l'ingénierie logicielle Python, dans le but d'aider les lecteurs à écrire du code qui soit code plus facile à maintenir et plus propre. Le livre comprend 10 chapitres au total : le chapitre 1 présente les connaissances de base du langage Python et les principaux outils nécessaires pour créer un environnement de développement Python ; le chapitre 2 décrit le code de style Python et présente le premier idiome de Python ; bon code Caractéristiques générales, passant en revue les principes généraux du génie logiciel ; le chapitre 4 présente un ensemble de principes pour la conception de logiciels orientés objet, à savoir les principes SOLID ; le chapitre 5 présente les décorateurs, qui sont l'une des fonctionnalités les plus uniques de Python ; Descripteurs, présentant comment obtenir plus d'informations à partir des objets via des descripteurs ; les chapitres 7 et 8 présentent les générateurs et le contenu associé sur les tests unitaires et la refactorisation ; le chapitre 9 passe en revue les modèles de conception les plus courants en Python ; le chapitre 10 Zhang souligne une fois de plus que le code propre est le meilleur ; base pour réaliser une bonne architecture.

Ce livre convient à tous les passionnés de programmation Python, aux personnes intéressées par la programmation et aux autres praticiens du génie logiciel qui souhaitent en savoir plus sur Python.

Recommandations d'apprentissage gratuites associées : Tutoriel Python(vidéo)

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!