Pour implémenter un itérateur personnalisé, vous devez définir les méthodes __iter__ et __Next__ dans la classe. ① La méthode __iter__ renvoie l'objet itérateur lui-même, généralement soi, pour être compatible avec des environnements itératifs tels que pour les boucles; ② La méthode __Next__ contr?le la valeur de chaque itération, renvoie l'élément suivant dans la séquence, et lorsqu'il n'y a plus d'éléments, une exception d'arrêt doit être lancée; ③ L'état doit être suivi correctement et les conditions de terminaison doivent être définies pour éviter les boucles infinies; ④ La logique complexe telle que le filtrage des lignes de fichiers peut être encapsulée, et le nettoyage des ressources et la gestion de la mémoire peuvent être prêts à l'attention; ⑤ Pour une logique simple, vous pouvez envisager d'utiliser le rendement de la fonction du générateur à la place, mais vous devez choisir une méthode appropriée basée sur le scénario spécifique.

Pour implémenter des itérateurs personnalisés dans Python, vous devez définir les méthodes __iter__ et __next__ dans votre classe. Ces deux méthodes spéciales permettent à votre objet d'être itérable et de contr?ler comment l'itération se comporte étape par étape.

Comprendre __iter__ et __next__

La méthode __iter__ doit renvoyer l'objet itérateur lui-même - généralement self . C'est ce qui rend votre objet compatible avec les boucles pour les boucles et autres contextes d'itération.

La méthode __next__ définit ce qui se passe chaque fois que l'élément suivant est demandé. Il doit renvoyer la valeur suivante dans la séquence ou augmenter StopIteration lorsqu'il n'y a plus d'éléments à retourner.

Si vous ne soulevez pas StopIteration à la fin de votre séquence, votre itérateur continuera de fonctionner indéfiniment, ce qui peut provoquer des problèmes tels que des boucles infinies.

Création d'un itérateur personnalisé simple

Disons que vous souhaitez créer un itérateur qui passe par une gamme de nombres mais saute chaque deuxième numéro.

 Classe Skipevenerator:
    def __init __ (self, max_value):
        self.current = 0
        self.max_value = max_value

    def __iter __ (soi):
        Se retourner

    def __Next __ (self):
        Si self.current> self.max_value:
            augmenter la pertinence
        résultat = self.Current
        self.current = 2
        Résultat de retour

Vous pouvez maintenant l'utiliser dans une boucle:

 Pour Num dans Skipeveniterator (10):
    imprimer (num)

Cela sortirait: 0, 2, 4, 6, 8, 10.

Quelques choses à retenir:

• Votre méthode __next__ doit suivre correctement l'état.
• Incluez toujours une condition d'arrêt pour éviter les boucles infinies.
• Vous pouvez stocker n'importe quel type d'état à l'intérieur de votre objet - entiers, cordes, même d'autres objets.

Gérer la logique d'itération plus complexe

Parfois, vous ne voudrez peut-être pas simplement parcourir les chiffres. Par exemple, imaginez itérer les lignes dans un fichier qui correspondent à un certain modèle.

Dans ces cas, votre __iter__ pourrait ouvrir un fichier ou préparer une source de données, et __next__ traite l'informatique ligne par ligne ou élément par élément.

Voici une version simplifiée:

 Class GrepLILLIVREITERATOR:
    Def __init __ (self, nom de fichier, mot-clé):
        self.filename = nom de fichier
        Self.Keyword = mot-clé
        self.file = aucun
        self.line = aucun

    def __iter __ (soi):
        self.file = ouvert (self.filename, 'r')
        Se retourner

    def __Next __ (self):
        Bien que vrai:
            line = self.file.readline ()
            Si ce n'est pas la ligne:
                self.file.close ()
                augmenter la pertinence
            Si l'auto-clé en ligne:
                return line.strip ()

Cela vous permet de faire quelque chose comme:

 pour la ligne dans greplikeIterator ('data.txt', 'error'):
    Imprimer (ligne)

Assurez-vous simplement:

• Vous gérez correctement le nettoyage des ressources (comme la fermeture des fichiers).
• évitez de charger de grands ensembles de données dans la mémoire à la fois.
• Assurez-vous que votre logique ne saute pas accidentellement les valeurs ou ne les répéterait pas involontairement.

Quand utiliser les générateurs à la place

Bien que la mise en ?uvre __iter__ et __next__ vous donne un contr?le total, l'utilisation parfois d'une fonction de générateur avec yield est plus simple et plus propre. Si votre logique d'itération n'est pas trop complexe, envisagez d'écrire un générateur à la place.

Par exemple:

 def skip_even_generator (max_value):
    courant = 0
    Tandis que le courant <= max_value:
        courant de rendement
        courant = 2

Vous pouvez toujours l'utiliser dans une boucle et Python gère automatiquement l'état.

Mais si vous avez besoin d'encapsuler l'état et le comportement ensemble - en particulier lorsque vous combinez avec d'autres fonctionnalités orientées objet - la définition d'une classe d'itérateur personnalisée est la bonne approche.

Alors oui, la mise en ?uvre des itérateurs personnalisés dans Python signifie écrire des cours avec __iter__ et __next__ , gérer vous-même et s'assurer de s'arrêter proprement. Pas trop dur une fois que vous avez compris, mais certainement facile à gacher de petits détails comme oublier de soulever StopIteration .

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!