À propos des décorateurs en Python

Bonjour à tous!

La traduction de l'article a été préparée pour les étudiants du cours "Développeur Web en Python" . Est-il intéressant de se développer dans cette direction? Inscrivez-vous au cours Open Doors Day et discutez en direct avec l'enseignant: diffusion en ligne le 23 juillet à 20h00, heure de Moscou!

Lorsque vous avez pratiqué la programmation en Python, vous devez avoir rencontré un concept comme les décorateurs. Ils sont l'un des outils les plus élégants et les plus utilisés dans les bibliothèques et les frameworks modernes. Les décorateurs sont un bon moyen d'encapsuler de nombreux détails de mise en œuvre, laissant une interface simple à la surface.

Examinons un exemple de décorateur de connexion simple qui vérifie qu'un utilisateur est connecté avant de lui donner la possibilité de modifier des messages. Ensuite, le décorateur redirige vers la page de connexion ou d'inscription, puis à l'aide de paramètres correctement définis, revient à la même page après une authentification réussie. Pour utiliser cette fonction, il vous suffit d'écrire @login_required avant la fonction cible.

@login_required def edit_post(post_id): ... 

Les décorateurs sont très faciles à travailler, mais la création de décorateurs n'est pas une tâche facile, même pour les programmeurs Python expérimentés. Dans cet article, nous allons voir étape par étape comment fonctionnent les décorateurs en Python.

Les fonctions

Les fonctions sont également appelées objets de première classe en Python. Les fonctions ont les mêmes valeurs que les nombres, les listes et les chaînes, comme illustré dans l'exemple suivant.

 >>> def foo(): ... return 1 ... >>> >>> foo() 1 >>> 

Les fonctions ont leur propre espace de noms, où elles recherchent les noms de variables en premier lieu lorsqu'elles apparaissent dans le corps d'une fonction. Écrivons une fonction simple pour comprendre la différence entre la portée globale et locale.

 >>> >>> a_string = "This is a global variable" >>> >>> def foo(): ... print(locals()) ... >>> >>> print(globals()) {..., 'a_string': 'This is a global variable'} >>> >>> foo() # 2 {} >>> 

Portée de la fonction en tant que variable

La règle de portée en Python dit que lorsqu'une variable est créée, une nouvelle variable locale est toujours créée, mais l'accès à la variable est déterminé dans la portée locale lorsqu'il recherche toutes les zones de correspondance les plus proches pour les noms de variable. Cela ne signifie pas que nous ne pouvons pas accéder aux variables globales à partir de notre fonction. Pour sortir une variable globale, nous changeons la fonction foo comme suit:

 >>> >>> a_string = "This is a global variable" >>> >>> def foo(): ... print(a_string) #1 ... >>> >>> foo() This is a global variable >>> 

Durée de vie variable

Non seulement les variables vivent dans l'espace de noms, mais elles ont également une durée de vie, ce qui est important à retenir. Prenons un exemple qui illustre non seulement les règles de portée et les problèmes qu'elles peuvent provoquer, mais aussi comment elles interagissent avec les appels de fonction et comment elles fonctionnent en Python et dans d'autres langages.

 >>> def foo(): ... x = 1 ... >>> foo() >>> >>> print(x) # 1 Traceback (most recent call last): ... NameError: name 'x' is not defined >>> 

Fonctions imbriquées

Vous pouvez créer des fonctions imbriquées en Python, ce qui signifie que nous pouvons déclarer des fonctions à l'intérieur des fonctions, et toutes les règles de portée et de durée de vie s'appliquent toujours.

 >>> >>> def outer(): ... x = 1 ... def inner(): ... print(x) # 1 ... inner() # 2 ... >>> outer() 1 >>> 

Décorateurs

Une fermeture qui prend une fonction en paramètre et renvoie une fonction est appelée décorateur. Prenons un exemple de décorateurs utiles.

 >>> >>> def outer(some_func): ... def inner(): ... print("before some_func") ... ret = some_func() # 1 ... return ret + 1 ... return inner ... >>> def foo(): ... return 1 ... >>> decorated = outer(foo) # 2 >>> >>> decorated() before some_func 2 >>> 

Une variable décorée est une version décorée de foo. En fait, nous pourrions remplacer foo par sa version décorée et ne pas apprendre la nouvelle syntaxe en réaffectant simplement la variable contenant notre fonction:

 >>> >>> foo = outer(foo) >>> >>> foo # doctest: +ELLIPSIS <function outer.<locals>.inner at 0x...> >>> 

Nous avons maintenant un beau décorateur pour suivre les appels de fonction. Les décorateurs peuvent être utilisés pour travailler avec n'importe quel langage de programmation utilisant Python. Il s'agit d'un outil extrêmement utile dont le mécanisme de travail doit être compris pour les appliquer correctement.