Share
Les générateurs facilitent la création d'itérations en Python et l'écriture de moins de code. Ce tutoriel vous présentera les générateurs Python, leurs avantages et leur fonctionnement.
Un générateur est une fonction qui renvoie un objet générateur sur lequel vous pouvez appeler le suivant() méthode, de sorte que pour chaque appel, il retourne une valeur ou la valeur suivante. Une fonction Python normale utilise le revenir mot-clé pour retourner des valeurs, mais les générateurs utilisent le mot-clé rendement pour renvoyer des valeurs. Cela signifie que toute fonction Python contenant un rendement instruction est une fonction génératrice.
le rendement instruction arrête généralement la fonction et enregistre l'état local afin qu'il puisse être repris là où il s'est arrêté. Les fonctions de générateur peuvent avoir un ou plusieurs rendement des déclarations.
Un générateur est aussi un itérateur, mais qu'est-ce qu'un itérateur? Avant de plonger dans les détails des générateurs, je pense qu'il est important de savoir ce que sont les itérateurs, car ils font partie intégrante de la discussion..
Un itérateur Python est simplement une classe qui définit un __iter __ () méthode. La plupart des objets Python sont itératifs, ce qui signifie que vous pouvez effectuer une boucle sur chaque élément de ces objets. Des exemples d'itérables en Python incluent des chaînes, des listes, des n-uplets, des dictionnaires et des plages..
Prenons l'exemple ci-dessous, dans lequel nous parcourons une liste de couleurs:
couleurs = [“rouge”, “bleu”, “jaune”] def my_funct (): pour la couleur en couleur: couleur d'impression
Dans les coulisses, le pour déclaration appellera iter () sur l'objet liste. La fonction retournera ensuite un objet itérateur définissant la méthode. __suivant__(), qui accédera ensuite à chaque couleur, une à la fois. Quand il n'y a plus de couleurs, __suivant__ va soulever une stopIteration exception, qui informera à son tour le pour boucle pour terminer.
d = 'x': 10, 'y': 20, 'z': 30 pour k, v dans d.items (): print k, v #résultat # y 20 # x 10 # z 30
Accentsconagua
importer csv avec open ('fichier.csv', newline = ") en tant que fichier: lecteur = csv.reader (fichier) pour la ligne dans le lecteur: ligne de rendementmy_string = 'Générateurs' pour la chaîne dans my_string: print (chaîne) #résultat # G # e # n # e # r # a # t # o # r # s
Discutons certains des avantages de l’utilisation de générateurs par opposition aux itérateurs:
Pour construire un itérateur en Python, vous devrez implémenter une classe avec __iter __ () et __suivant__() méthodes, ainsi que de prendre soin de toute erreur qui peut causer un stopIteration Erreur.
class Reverse: "" "Itérateur pour la lecture en boucle d'une séquence." "" def __init __ (self, data): self.data = data self.index = len (data) def __iter __ (self): retourne self def __next __ (self ): si self.index == 0: lève StopIteration self.index = self.index - 1 renvoie self.data [self.index]
Comme vous pouvez le voir ci-dessus, la mise en œuvre est très longue. Tout ce fardeau est automatiquement géré par les générateurs.
Les générateurs aident à minimiser la consommation de mémoire, en particulier lors du traitement de grands ensembles de données, car un générateur ne renvoie qu'un élément à la fois..
Les générateurs sont paresseux dans la nature. Cela signifie qu'ils ne génèrent des valeurs que lorsque cela est nécessaire. Contrairement à un itérateur normal, où toutes les valeurs sont générées, qu'elles soient utilisées ou non, les générateurs ne génèrent que les valeurs nécessaires. Cela accélérera votre programme..
Créer un générateur est très facile. Tout ce que vous avez à faire est d’écrire une fonction normale, mais avec un rendement déclaration au lieu d'un revenir déclaration, comme indiqué ci-dessous.
def gen_function (): donne "python"
Alors qu'un revenir déclaration termine une fonction entièrement, rendement met juste en pause la fonction jusqu’à ce qu’elle soit rappelée par le suivant() méthode.
Par exemple, le programme ci-dessous utilise à la fois le rendement et suivant() des déclarations.
def myGenerator (l): total = 1 pour n en l: rendement total total + = n newGenerator = myGenerator ([10,3]) print (next (newGenerator)) print (next (newGenerator))
Voyons comment fonctionnent les générateurs. Considérons l'exemple ci-dessous.
# generator_example.py def myGenerator (l): total = 0 pour n dans l: total + = n rendement total newGenerator = myGenerator ([10,20,30]) print (next (newGenerator)) print (next (newGenerator)) print (next (newGenerator))
Dans la fonction ci-dessus, nous définissons un générateur nommé mon générateur, qui prend une liste l comme argument. On définit alors une variable total et lui assigner une valeur de zéro. De plus, nous parcourons chaque élément de la liste et l’ajoutons ensuite à la variable totale..
Nous instancions alors nouveauGénérateur et appelez le suivant() méthode sur elle. Cela exécutera le code jusqu'à ce qu'il produise la première valeur de total, qui sera 0 dans ce cas. La fonction conserve ensuite la valeur de la variable totale jusqu'au prochain appel de la fonction. Contrairement à une normale revenir déclaration, qui renverra toutes les valeurs à la fois, le générateur reprendra là où il s'était arrêté.
Ci-dessous les valeurs suivantes restantes.
# generator_example.py def myGenerator (l): total = 0 pour n en l: rendement total + = n newGenerator = myGenerator ([10,20,30]) print (next (newGenerator)) print (next (newGenerator)) print (next (newGenerator)) # résultat # 0 # 10 # 30
Si vous essayez d’appeler la fonction une fois la boucle terminée, vous obtiendrez un StopIteration Erreur.
UNE StopIteration est élevé par le suivant() méthode pour signaler qu'il n'y a plus d'articles produits par l'itérateur.
0 10 30 Traceback (dernier appel passé): fichier "python", ligne 15, dansFonction StopIterationNormal
Dans cet exemple, nous montrons comment utiliser plusieurs déclarations de rendement dans une fonction.
# colors.py def colors (): rendement "rouge" rendement "bleu" rendement "vert" next_color = colors () print (next (next_color)) print (next (next_color)) print (next (next_color)) # résultat # rouge # bleu # vert
Alors qu’une fonction normale renvoie toutes les valeurs lorsque la fonction est appelée, un générateur attend jusqu’à ce que le suivant() La méthode est appelée à nouveau. Une fois que suivant() est appelée, la fonction de couleurs reprend là où elle s’était arrêtée.
Les générateurs utilisent plus efficacement la mémoire, en particulier lorsque vous travaillez avec de très grandes listes ou de gros objets. En effet, vous pouvez utiliser les rendements pour travailler sur des bits plus petits plutôt que de conserver toutes les données en mémoire en une seule fois..
De plus, n'oubliez pas de voir ce que nous avons à vendre et à étudier sur le marché Envato, et n'hésitez pas à poser des questions et à fournir vos précieux commentaires en utilisant le flux ci-dessous..
De plus, si vous vous sentez bloqué, il y a un très bon cours sur les générateurs Python dans la section cours.
