Comment mettre en œuvre __iter__(self) pour un conteneur d'objet (Python)

J'ai écrit un conteneur personnalisé objet.

Selon cette page, j'ai besoin de mettre en œuvre cette méthode sur mon objet:

__iter__(self)

Cependant, en suivant le lien vers Types Iterator dans le Python manuel de référence, il n'existe pas d'exemples de comment implémenter votre propre.

Quelqu'un peut poster un extrait de code (ou un lien vers une ressource), qui montre comment faire cela?

Le conteneur je suis en train d'écrire, est une carte (c'est à dire des magasins de valeurs de clés uniques).
dicts peut être itéré comme ceci:

for k, v in mydict.items()

Dans ce cas j'ai besoin d'être en mesure de retourner deux éléments (un tuple?) dans l'itérateur.
Il n'est pas encore clair comment mettre en œuvre un itérateur (malgré les quelques réponses qui ont été aimablement fournie). Quelqu'un pourrait s'il vous plaît faire plus de lumière sur la façon de mettre en œuvre un itérateur sur une carte comme objet de conteneur? (c'est à dire une classe personnalisée qui agit comme un dict)?

InformationsquelleAutor skyeagle | 2010-10-26
  1. 96

    Normalement, je voudrais utiliser un générateur de fonction. Chaque fois que vous utilisez une instruction rendement, il sera l'ajout d'un élément de la séquence.

    La suite de créer un itérateur qui renvoie cinq, et ensuite, tous les éléments dans some_list.

    def __iter__(self):
   yield 5
   yield from some_list

    Pré-3.3, yield from n'existe pas, de sorte que vous avez à faire:

    def __iter__(self):
   yield 5
   for x in some_list:
      yield x
    • T-on besoin pour élever StopIteration? Comment cette distinction quand s'arrêter?
    • Lorsque tous les éléments de some_list ont été donné.
    • En fait, avec ce cas d'utilisation, il vous suffit de soulever StopIteration si vous souhaitez arrêter de rendement des valeurs de avant some_list est épuisé.
    • StopIteration est automatiquement soulevé par Python lorsque le générateur de fonction retourne une valeur, soit en vous appelant explicitement return ou en atteignant la fin de la fonction (qui, comme toutes les fonctions implicite return None à la fin). Explicitement élever StopIteration n'est pas nécessaire et que de Python 3.5 y aura effectivement pas de travail (voir la section PEP 479): tout comme les générateurs de tourner return en StopIteration, ils se tournent explicite raise StopIteration dans un RuntimeError.
    InformationsquelleAutor mikerobi
  2. 25

    Une autre option est d'hériter de la classe de base abstraite de la " collections module comme indiqué ici.

    Dans le cas où le conteneur est son propre itérateur, vous pouvez hériter de
    collections.Iterator. Vous avez seulement besoin de mettre en œuvre les next méthode, puis.

    En est un exemple:

    >>> from collections import Iterator
>>> class MyContainer(Iterator):
...     def __init__(self, *data):
...         self.data = list(data)
...     def next(self):
...         if not self.data:
...             raise StopIteration
...         return self.data.pop()
...         
...     
... 
>>> c = MyContainer(1, "two", 3, 4.0)
>>> for i in c:
...     print i
...     
... 
4.0
3
two
1

    Pendant que vous êtes à la recherche à la collections module, pensez à hériter de Sequence, Mapping ou d'une autre classe de base abstraite si cela est plus approprié. Voici un exemple pour un Sequence sous-classe:

    >>> from collections import Sequence
>>> class MyContainer(Sequence):
...     def __init__(self, *data):
...         self.data = list(data)
...     def __getitem__(self, index):
...         return self.data[index]
...     def __len__(self):
...         return len(self.data)
...         
...     
... 
>>> c = MyContainer(1, "two", 3, 4.0)
>>> for i in c:
...     print i
...     
... 
1
two
3
4.0

    NB: Grâce à Glenn Maynard pour attiré mon attention sur la nécessité de clarifier la différence entre les itérateurs, d'une part, et les conteneurs qui sont iterables plutôt que de les itérateurs sur les autres.

    • Ne mélangez pas itérable des objets et des itérateurs--vous ne voulez pas hériter de Itérateur pour un objet iterable objet qui n'est pas un itérateur lui-même (par exemple. un conteneur).
    • Vous avez raison qu'un type de conteneur n'est pas un itérateur. J'ai simplement suivi la question, qui mentionne l'itérateur types. Je pense qu'il est plus approprié d'hériter d'une solution plus appropriée comme je l'ai dit à la fin de la réponse. Je vais préciser ce point dans la réponse.
    InformationsquelleAutor Muhammad Alkarouri
  3. 13

    généralement __iter__() juste retour de l'auto si vous avez déjà définir la méthode next () (générateur d'objet):

    ici est un Mannequin exemple d'un générateur :

    class Test(object):

    def __init__(self, data):
       self.data = data

    def next(self):
        if not self.data:
           raise StopIteration
        return self.data.pop()

    def __iter__(self):
        return self

    mais __iter__() peut également être utilisé comme ceci:
    http://mail.python.org/pipermail/tutor/2006-January/044455.html

    • C'est ce que vous faites pour itérateur classes, mais la question est à propos des objets conteneurs.
    InformationsquelleAutor mouad
  4. 11

    Si votre objet contient un ensemble de données que vous voulez lier votre objet iter, vous pouvez tricher et de faire cela:

    >>> class foo:
    def __init__(self, *params):
           self.data = params
    def __iter__(self):
        if hasattr(self.data[0], "__iter__"):
            return self.data[0].__iter__()
        return self.data.__iter__()
>>> d=foo(6,7,3,8, "ads", 6)
>>> for i in d:
    print i
6
7
3
8
ads
6
    • Au lieu de vérifier hasattr, utilisez try/except AttributeError
    InformationsquelleAutor Squirrelsama
  5. 8

    La "itératif" interface en python se compose de deux méthodes __next__() et __iter__(). Le __next__ de la fonction est le plus important, car il définit l'itérateur de comportement - qui est, la fonction détermine quelle valeur doit être retourné suivant. Le __iter__() méthode est utilisée pour réinitialiser le point de départ de l'itération. Souvent, vous trouverez que __iter__() pouvez simplement retourner auto quand __init__() est utilisé pour définir le point de départ.

    Voir le code suivant pour définir une Classe Inversée qui met en place la "itératif" interface " et définit un itérateur sur toute instance à partir d'une séquence de classe. Le __next__() méthode commence à la fin de la séquence et retourne les valeurs dans l'ordre inverse de la séquence. Notez que les instances d'une classe de mise en œuvre de la "séquence" d'interface doit définir un __len__() et un __getitem__() méthode. 

    class Reverse:
    """Iterator for looping over a sequence backwards."""
    def __init__(self, seq):
        self.data = seq
        self.index = len(seq)

    def __iter__(self):
        return self

    def __next__(self):
        if self.index == 0:
            raise StopIteration
        self.index = self.index - 1
        return self.data[self.index]

>>> rev = Reverse('spam')
>>> next(rev)   # note no need to call iter()
'm'
>>> nums = Reverse(range(1,10))
>>> next(nums)
9
    InformationsquelleAutor FredAKA
  6. 6

    Pour répondre à la question sur mappages: votre condition __iter__ doit effectuer une itération sur les clés de la cartographie. Le suivant est un exemple simple qui crée un mappage x -> x * x et travaille sur Python3 l'extension de l'ABC de la cartographie.

    import collections.abc

class MyMap(collections.abc.Mapping):
    def __init__(self, n):
        self.n = n

    def __getitem__(self, key): # given a key, return it's value
        if 0 <= key < self.n:
            return key * key
        else:
            raise KeyError('Invalid key')

    def __iter__(self): # iterate over all keys
        for x in range(self.n):
            yield x

    def __len__(self):
        return self.n

m = MyMap(5)
for k, v in m.items():
    print(k, '->', v)
# 0 -> 0
# 1 -> 1
# 2 -> 4
# 3 -> 9
# 4 -> 16
    InformationsquelleAutor Juan A. Navarro
  7. 4

    Dans le cas où vous ne voulez pas hériter de dict comme d'autres l'ont suggéré, ici est la réponse directe à la question sur la façon de mettre en œuvre __iter__ pour un exemple brut d'une coutume dict:

    class Attribute:
    def __init__(self, key, value):
        self.key = key
        self.value = value

class Node(collections.Mapping):
    def __init__(self):
        self.type  = ""
        self.attrs = [] # List of Attributes

    def __iter__(self):
        for attr in self.attrs:
            yield attr.key

    Qui utilise un générateur, qui est bien décrite ici.

    Puisque nous allons hériter de Mapping, vous devez également mettre en œuvre __getitem__ et __len__:

        def __getitem__(self, key):
        for attr in self.attrs:
            if key == attr.key:
                return attr.value
        raise KeyError

    def __len__(self):
        return len(self.attrs)
    InformationsquelleAutor jfritz42
  8. 1

    Une option qui pourrait fonctionner pour certains cas, est de faire de votre classe personnalisée hériter de dict. Cela semble être un choix logique si il agit comme un dict; peut-être qu'il devrait être un dict. De cette façon, vous obtenez dict-comme d'itération pour gratuit.

    class MyDict(dict):
    def __init__(self, custom_attribute):
        self.bar = custom_attribute

mydict = MyDict('Some name')
mydict['a'] = 1
mydict['b'] = 2

print mydict.bar
for k, v in mydict.items():
    print k, '=>', v

    De sortie:

    Some name
a => 1
b => 2
    InformationsquelleAutor Eddified
  9. 1

    exemple pour inhert de dict, de modifier ses iter, par exemple, ignorer clé 2 quand en boucle

    # method 1
class Dict(dict):
    def __iter__(self):
        keys = self.keys()
        for i in keys:
            if i == 2:
                continue
            yield i

# method 2
class Dict(dict):
    def __iter__(self):
        for i in super(Dict, self).__iter__():
            if i == 2:
                continue
            yield i
    InformationsquelleAutor WeizhongTu