Générateurs Python et itérateurs plongée profonde

Si vous avez déjà rencontré des problèmes de mémoire tout en travaillant avec de grands ensembles de données dans Python ou si vous vouliez un moyen plus propre de gérer les séquences, les générateurs et les itérateurs pourraient être exactement ce dont vous avez besoin. Il ne s'agit pas seulement d'économiser de la mémoire - ils peuvent rendre votre code plus lisible et efficace.

Décomposons ce que vous devez vraiment savoir lorsque vous travaillez avec ces deux concepts étroitement liés mais distincts.

Quelle est la différence entre un itérateur et un générateur?

C'est l'une des questions les plus courantes lors de la plongée dans les outils d'itération de Python.

Un itérateur est tout objet qui met en œuvre le protocole d'itérateur ( __iter__() et __next__() ) et vous permet de parcourir les éléments un à la fois. Les listes, les dictionnaires et les chaînes sont tous itérables car ils renvoient un itérateur lorsque vous appelez iter() sur eux.

Un générateur , en revanche, est un type d'itérateur spécial que vous définissez en utilisant une fonction avec yield au lieu du return . Vous n'avez pas à implémenter manuellement __next__() —Python gère cela pour vous dans les coulisses.

Donc, en bref:

• Tous les générateurs sont des itérateurs.
• Tous les itérateurs ne sont pas des générateurs.

Par exemple:

 def simple_generator ():
    rendement 1
    rendement 2

gen = simple_generator ()
print (suivant (gen)) # sortie: 1
imprimer (suivant (gen)) # sortie: 2

Si vous avez affaire à de grands flux de données ou si vous souhaitez une évaluation paresseuse, les générateurs vous offrent un moyen propre et économe en mémoire de le faire.

Quand devriez-vous utiliser des générateurs au lieu de listes?

Utilisez des générateurs lorsque:

• Vous travaillez avec de grands ensembles de données et n'avez pas besoin de tous les éléments en mémoire à la fois.
• Vous construisez un pipeline où les données circulent d'une transformation à une autre.
• Vous souhaitez éviter des calculs inutiles jusqu'à ce qu'ils soient nécessaires.

Imaginez lire un énorme fichier journal ligne par ligne. Le chargement de l'ensemble du fichier dans une liste avec readlines() pourrait manger rapidement de la mémoire. Au lieu de cela, l'utilisation d'une expression de générateur ou d'une fonction de générateur vous permet de traiter chaque ligne au fur et à mesure.

Voici une comparaison simple:

 # Utilisation d'une liste (charge tout en même temps)
avec open ('big_file.txt') comme f:
    lignes = f.readlines () # charge toutes les lignes en mémoire

# Utilisation d'un générateur (lit ligne par ligne)
avec open ('big_file.txt') comme f:
    lignes = (line.strip () pour la ligne en f) # traite une ligne à la fois

Vous ne remarquerez pas une grande différence avec de petits fichiers, mais la deuxième approche évolue mieux et maintient votre application légère.

Comment construisez-vous des itérateurs personnalisés?

Parfois, les iterables intégrés ne sont pas suffisants et vous souhaitez créer votre propre comportement personnalisé. C'est là que l'écriture d'une classe Iterator personnalisée est utile.

Pour en faire un, vous devrez définir au moins deux méthodes:

• __iter__() - Renvoie l'objet Iterator lui-même.
• __next__() - Renvoie la valeur suivante. S'il n'y a plus d'articles, cela devrait augmenter StopIteration .

Voici un exemple de base d'un compteur qui passe de 1 à un numéro donné:

 compteur de classe:
    def __init __ (self, limite):
        self.limit = limite
        self.current = 1

    def __iter __ (soi):
        se retourner

    def __Next __ (self):
        Si self.current> self.limit:
            augmenter la pertinence
        autre:
            valeur = self.Current
            self.current = 1
            valeur de retour

pour num dans le compteur (5):
    imprimer (num)

Cela vous donne un contrôle total sur le comportement de l'itération. Il est utile lorsque vous avez besoin d'une logique d'itération avec état qui n'est pas facile à exprimer avec une fonction générateur seule.

Conseils et gotchas lorsque vous travaillez avec des générateurs

Les générateurs sont puissants, mais ils viennent avec des bizarreries que vous devez garder à l'esprit:

• ? Une fois consommés, les générateurs ne réinitialisent pas. Si vous devez réutiliser les valeurs, les stocker d'abord dans une liste.
• ⚠️ Les générateurs ne prennent pas en charge l'indexation. Ainsi, des choses comme my_gen[0] ne fonctionneront pas.
• ? Vous pouvez construire des pipelines en utilisant plusieurs générateurs enchaînés. Par exemple, filtrez → Transformer → Sortie.
• ? Les générateurs infinis sont possibles, mais les utilisent uniquement lorsque vous avez une condition d'arrêt claire en dehors du générateur.

Voici un exemple rapide de deux expressions de générateur:

 nombres = (x pour x dans la gamme (100))
evens = (x pour x en nombre si x% 2 == 0)
carré = (x * x pour x dans evens)

Pour Val en carré:
    Imprimer (Val)

Il s'agit d'un moyen propre de structurer les transformations sans tout charger en mémoire.

L'utilisation efficace des générateurs et des itérateurs peut enregistrer la mémoire, améliorer les performances et conduire à un code plus maintenable. Que vous traitiez des journaux, en streaming ou en nettoyant simplement les boucles, en sachant quand et comment les utiliser fait une réelle différence.

Et c'est à peu près tout - vous n'avez pas besoin de trucs de fantaisie pour en tirer le meilleur parti. Juste une solide compréhension de la façon dont ils travaillent sous le capot.

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!