Que sont les générateurs et les décorateurs en Python ?

Dans cet article, nous allons vous expliquer ce que sont les générateurs et les décorateurs en Python.

Les générateurs constituent une partie importante de Python depuis leur introduction dans la PEP 255.

Un générateur en Python est une routine spéciale qui peut être utilisée pour contrôler le comportement itératif d'une boucle. Les générateurs sont comme des fonctions qui renvoient des tableaux. Le générateur a un paramètre que nous pouvons appeler et générer une séquence de nombres. Mais contrairement aux fonctions qui renvoient un tableau entier, les générateurs génèrent les valeurs une par une, nécessitant moins de mémoire.

Toute fonction Python avec le mot-clé « rendement » peut être appelée un générateur. Une fonction Python normale commence l'exécution à partir de la première ligne et continue jusqu'à ce que nous recevions une instruction de retour ou une exception ou que la fonction se termine. Cependant, toutes les variables locales créées pendant la portée de la fonction sont détruites et ne sont plus accessibles. Pour un générateur, lorsqu'il rencontre le mot-clé rendement, l'état de la fonction sera gelé et toutes les variables seront stockées en mémoire jusqu'à ce que le générateur soit à nouveau appelé.

Nous pouvons utiliser des générateurs basés sur des itérateurs ou les appeler explicitement en utilisant le mot-clé "next".

Habituellement, un générateur en Python -

• Utilisez la définition de mot-clé def

• Utilisez le mot-clé de rendement

• Peut contenir plusieurs mots-clés de revenus.

• Renvoie un itérateur.

Les

Generators sont des fonctions qui renvoient des objets Iterablegenerator. Étant donné que les valeurs de l'objet générateur sont récupérées une par une plutôt que la liste entière à la fois, vous pouvez utiliser une fonction de boucle for, next() ou list() pour obtenir les valeurs réelles.

Fonction générateur

Les générateurs peuvent être créés à l'aide de fonctions génératrices et d'expressions génératrices.

Une fonction génératrice est similaire à une fonction normale, mais au lieu de renvoyer une valeur, elle possède le mot-clé rendement.

Pour créer une fonction génératrice, ajoutez le mot-clé yield. L'exemple suivant montre comment écrire une fonction génératrice.

Générateurs avec itérateurs

Exemple

# creating a function
def generatorExample():
   yield "T"
   yield "U"
   yield "T"
   yield "O"
   yield "R"
   yield "I"
   yield "A"
   yield "L"
   yield "S"
# calling the generatorExample() function which is created above
result = generatorExample()
# Traversing in the above result(generator object)
for k in result:
   # Printing the corresponding value
   print(k)

Sortie

T
U
T
O
R
I
A
L
S

Lisez la valeur de sortie du générateur

Les méthodes

list(), for-loop et next() peuvent être utilisées pour lire les valeurs des objets générateurs.

Utilisez next() pour lire la valeur de l'objet générateur

La méthode

next() renvoie l'élément suivant dans une liste, un tableau ou un objet. Lorsque la liste est vide et que next() est appelé, elle renvoie une erreur avec le signal stopIteration. Cette erreur indique qu'il n'y a plus d'entrées dans la liste.

Exemple

# creating a function that accepts a number as an argument
def oddNumbers(num):
   # traversing till that number passed
   for i in range(num):
      # checking whether the iterator index value is an odd number
      if (i%2!=0):
         # getting the iterator index value if the condition is true using the yield keyword
         yield i
# calling the above function to get the odd numbers below 8
result = oddNumbers(8)
# calling the next items in the result list
print(next(result))
print(next(result))
print(next(result))
print(next(result))
# throws an error since the list has no more elements
print(next(result))

Sortie

1
3
5
7
Traceback (most recent call last):
File "main.py", line 17, in <module>
    print(next(result))
StopIteration

Décorateurs en Python

Python fournit un outil étonnant appelé Decorator pour ajouter des fonctionnalités au code existant.

Cela est également appelé métaprogrammation car une partie du programme essaie de modifier une autre partie du programme au moment de la compilation.

Un décorateur utilise une fonction comme paramètre dans une autre fonction, puis appelle cette fonction dans la fonction wrapper.

Grammaire

@tutorials_decorator
def python_decorator():
   print("Hello tutorials Point")
'''Above code is equivalent to -
def python_decorator():
   print("Hello tutorials Point")
python_decorator = tutorials_decorator(python_decorator)'''

Le tutoriels_decorator ici est une fonction callable qui ajoute du code au-dessus d'une autre fonction callable python_decorator et renvoie une fonction wrapper.

Exemple

Ici func est la fonction décorée, python_decorator est la fonction utilisée pour la décorer

# defining a decorator
def python_decorator(func):
   def wrapper():
      print("Text before calling the function")
      func()
      print("Text after calling the function")
   return wrapper
def tutorials_decorator():
   print("Hello tutorials Point!!!")
tutorials_decorator = python_decorator(tutorials_decorator)
tutorials_decorator()

Sortie

Text before calling the function
Hello tutorials Point!!!
Text after calling the function

python_decorator(func) - Il s'agit d'une fonction de décorateur ; elle accepte une autre fonction comme argument et la "décore", c'est-à-dire qu'elle la modifie et renvoie la version modifiée.

wrapper - Nous définissons une autre fonction interne appelée wrapper à l'intérieur de la fonction décorateur. Il s'agit de la fonction réelle qui modifie la fonction passée func en l'enveloppant.

La fonction wrapper est renvoyée par le décorateur.

tutorials_decorator - C'est une fonction normale que nous devons décorer. Ici, imprimez simplement une déclaration simple.

Décorateur de syntaxe

Le modèle de décorateur décrit ci-dessus est populaire dans la communauté Python, mais il est un peu compliqué. Nous devons écrire le nom de la fonction trois fois et la décoration est cachée sous la définition de la fonction.

Par conséquent, Python a ajouté une nouvelle façon d'utiliser les décorateurs, y compris le sucre syntaxique en utilisant le symbole @.

Grammaire

@decorator
def func(arg1, arg2, ...):
   pass

Le sucre syntaxique est une syntaxe utilisée dans les langages de programmation pour rendre le contenu plus facile à lire ou à exprimer.

Exemple

L'exemple suivant effectue la même opération que l'exemple précédent -

# defining a decorator
def python_decorator(func):
   def wrapper():
      print("Text before calling the function")
      func()
      print("Text after calling the function")
   return wrapper
@python_decorator
def tutorials_decorator():
   print("Hello tutorials Point!!!")
tutorials_decorator()

Sortie

Text before calling the function
Hello tutorials Point!!!
Text after calling the function

Identique à l'exemple précédent, la seule différence est que nous utilisons @python_decorator au lieu de

tutorials_decorator = python_decorator(tutorials_decorator)

Conclusion

Dans cet article, nous avons jeté un bref aperçu des générateurs et décorateurs en Python. Nous avons également montré comment utiliser des générateurs et des décorateurs lors de l'écriture de code.

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!