Que sont exactement l'itérateur, l'itérable et l'itération?

Quelle est la définition la plus élémentaire de "itérable", "itérateur" et "itération" en Python?

J'ai lu plusieurs définitions mais je ne parviens pas à en identifier la signification exacte car elle ne s'enracinera toujours pas.

Quelqu'un peut-il m'aider s'il vous plaît avec les 3 définitions en termes simples?

L'itération est un terme général pour prendre chaque élément de quelque chose, l'un après l'autre. Chaque fois que vous utilisez une boucle, explicite ou implicite, pour parcourir un groupe d'éléments, c'est l'itération.

En Python, itérable et itérateur ont des significations spécifiques.

Un itérable est un objet qui a une __iter__méthode qui retourne un itérateur , ou qui définit une __getitem__méthode qui peut prendre des index séquentiels à partir de zéro (et déclenche un IndexErrorlorsque les index ne sont plus valides). Un itérable est donc un objet dont vous pouvez obtenir un itérateur .

Un itérateur est un objet avec une méthode next(Python 2) ou __next__(Python 3).

Chaque fois que vous utilisez une forboucle, ou map, ou une compréhension de liste, etc. en Python, la nextméthode est appelée automatiquement pour obtenir chaque élément de l' itérateur , passant ainsi par le processus d' itération .

Un bon endroit pour commencer à apprendre serait la section itérateurs du didacticiel et la section types d'itérateurs de la page des types standard . Après avoir compris les bases, essayez la section itérateurs du HOWTO de programmation fonctionnelle .

Voici l'explication que j'utilise dans l'enseignement des classes Python:

Un ITERABLE c'est:

• tout ce qui peut être bouclé (c'est-à-dire que vous pouvez boucler sur une chaîne ou un fichier) ou
• tout ce qui peut apparaître sur le côté droit d'une boucle for: for x in iterable: ... ou
• tout ce que vous pouvez appeler avec iter()cela retournera un ITERATOR: iter(obj)ou
• un objet qui définit __iter__qui renvoie un nouvel ITERATOR, ou il peut avoir une __getitem__méthode appropriée pour la recherche indexée.

Un ITERATOR est un objet:

• avec un état qui se souvient où il se trouve pendant l'itération,
• avec une __next__méthode qui:
  • renvoie la valeur suivante dans l'itération
  • met à jour l'état pour pointer sur la valeur suivante
  • signale quand il est fait en augmentant StopIteration
• et qui est auto-itérable (ce qui signifie qu'il a une __iter__méthode qui revient self).

Remarques:

• La __next__méthode en Python 3 est orthographiée nexten Python 2, et
• La fonction intégrée next()appelle cette méthode sur l'objet qui lui est transmis.

Par exemple:

>>> s = 'cat'      # s is an ITERABLE
                   # s is a str object that is immutable
                   # s has no state
                   # s has a __getitem__() method 

>>> t = iter(s)    # t is an ITERATOR
                   # t has state (it starts by pointing at the "c"
                   # t has a next() method and an __iter__() method

>>> next(t)        # the next() function returns the next value and advances the state
'c'
>>> next(t)        # the next() function returns the next value and advances
'a'
>>> next(t)        # the next() function returns the next value and advances
't'
>>> next(t)        # next() raises StopIteration to signal that iteration is complete
Traceback (most recent call last):
...
StopIteration

>>> iter(t) is t   # the iterator is self-iterable

Les réponses ci-dessus sont excellentes, mais comme la plupart de ce que j'ai vu, n'insistez pas sur la distinction assez sur pour les gens comme moi.

De plus, les gens ont tendance à devenir "trop ​​Pythonique" en mettant des définitions comme "X est un objet qui a __foo__() méthode" auparavant. De telles définitions sont correctes - elles sont basées sur la philosophie du typage du canard, mais l'accent mis sur les méthodes tend à se mettre entre les deux lorsque l'on essaie de comprendre le concept dans sa simplicité.

J'ajoute donc ma version.

En langage naturel,

• l'itération est le processus consistant à prendre un élément à la fois dans une rangée d'éléments.

En Python,

• itérable est un objet qui est, bien, itérable, ce qui signifie simplement qu'il peut être utilisé en itération, par exemple avec une forboucle. Comment? En utilisant l' itérateur . J'expliquerai ci-dessous.

• ... tandis que l' itérateur est un objet qui définit comment faire réellement l'itération - en particulier quel est l' élément suivant . C'est pourquoi il doit avoir une next()méthode.

Les itérateurs sont eux-mêmes également itérables, à la différence près que leur __iter__()méthode renvoie le même objet ( self), que ses éléments aient ou non été consommés par des appels précédents à next().

Alors, que pense l'interprète Python quand il voit une for x in obj:déclaration?

Regardez, une forboucle. On dirait un travail pour un itérateur ... Prenons-en un. ... Il y a ce objgars, alors demandons-lui.

"M. obj, avez-vous votre itérateur?" (... appels iter(obj), qui appelle obj.__iter__(), qui distribue avec bonheur un nouvel itérateur brillant _i.)

OK, c'était facile ... Commençons alors à répéter. ( x = _i.next()... x = _i.next()...)

Puisque M. a objréussi ce test (en ayant une certaine méthode renvoyant un itérateur valide), nous le récompensons avec un adjectif: vous pouvez maintenant l'appeler "M. itérable obj".

Cependant, dans des cas simples, vous ne bénéficiez pas normalement d'avoir un itérateur et un itérable séparément. Vous définissez donc un seul objet, qui est également son propre itérateur. (Python ne se soucie pas vraiment de ce que _idistribué par objn'était pas si brillant, mais juste objlui - même.)

C'est pourquoi dans la plupart des exemples que j'ai vus (et ce qui m'avait confus encore et encore), vous pouvez voir:

class IterableExample(object):

    def __iter__(self):
        return self

    def next(self):
        pass

au lieu de

class Iterator(object):
    def next(self):
        pass

class Iterable(object):
    def __iter__(self):
        return Iterator()

Il y a des cas, cependant, où vous pouvez bénéficier d'avoir l'itérateur séparé de l'itérable, comme quand vous voulez avoir une ligne d'éléments, mais plus de "curseurs". Par exemple, lorsque vous souhaitez travailler avec des éléments "actuels" et "à venir", vous pouvez avoir des itérateurs séparés pour les deux. Ou plusieurs threads tirés d'une énorme liste: chacun peut avoir son propre itérateur pour parcourir tous les éléments. Voir @ Raymond's et @ glglgl's réponses de ci-dessus.

Imaginez ce que vous pourriez faire:

class SmartIterableExample(object):

    def create_iterator(self):
        # An amazingly powerful yet simple way to create arbitrary
        # iterator, utilizing object state (or not, if you are fan
        # of functional), magic and nuclear waste--no kittens hurt.
        pass    # don't forget to add the next() method

    def __iter__(self):
        return self.create_iterator()

Remarques:

• Je le répète: l' itérateur n'est pas itérable . L'itérateur ne peut pas être utilisé comme "source" en forboucle. Ce dont la forboucle a principalement besoin est __iter__() (qui renvoie quelque chose avec next()).

• Bien sûr, ce forn'est pas la seule boucle d'itération, donc ci-dessus s'applique également à d'autres constructions ( while...).

• Les itérateurs next()peuvent lancer StopIteration pour arrêter l'itération. Cela ne doit pas, cependant, il peut répéter pour toujours ou utiliser d'autres moyens.

• Dans le "processus de pensée" ci-dessus, _in'existe pas vraiment. J'ai inventé ce nom.

• Il y a un petit changement dans Python 3.x: la next()méthode (pas la fonction intégrée) doit maintenant être appelée __next__(). Oui, ça aurait dû être comme ça tout le temps.

• Vous pouvez également penser à cela comme ceci: l'itérable a les données, l'itérateur tire l'élément suivant

Avertissement: je ne suis pas un développeur d'interpréteur Python, donc je ne sais pas vraiment ce que "l'interprète" pense. Les réflexions ci-dessus sont uniquement une démonstration de la façon dont je comprends le sujet à partir d'autres explications, expériences et expériences réelles d'un débutant en Python.

Un itérable est un objet qui a une __iter__()méthode. Il peut éventuellement être répété plusieurs fois, comme list()s et tuple()s.

Un itérateur est l'objet qui itère. Il est retourné par une __iter__()méthode, se retourne via sa propre __iter__()méthode et possède une next()méthode ( __next__()en 3.x).

L'itération est le processus d'appeler ce next()resp. __next__()jusqu'à ce qu'il monte StopIteration.

Exemple:

>>> a = [1, 2, 3] # iterable
>>> b1 = iter(a) # iterator 1
>>> b2 = iter(a) # iterator 2, independent of b1
>>> next(b1)
1
>>> next(b1)
2
>>> next(b2) # start over, as it is the first call to b2
1
>>> next(b1)
3
>>> next(b1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>> b1 = iter(a) # new one, start over
>>> next(b1)
1

Voici ma feuille de triche:

 sequence
  +
  |
  v
   def __getitem__(self, index: int):
  +    ...
  |    raise IndexError
  |
  |
  |              def __iter__(self):
  |             +     ...
  |             |     return <iterator>
  |             |
  |             |
  +--> or <-----+        def __next__(self):
       +        |       +    ...
       |        |       |    raise StopIteration
       v        |       |
    iterable    |       |
           +    |       |
           |    |       v
           |    +----> and +-------> iterator
           |                               ^
           v                               |
   iter(<iterable>) +----------------------+
                                           |
   def generator():                        |
  +    yield 1                             |
  |                 generator_expression +-+
  |                                        |
  +-> generator() +-> generator_iterator +-+

Quiz: Voyez-vous comment ...

1. chaque itérateur est un itérable?
2. la __iter__()méthode d' un objet conteneur peut être implémentée en tant que générateur?
3. un itérable qui a une __next__méthode n'est pas nécessairement un itérateur?

Réponses:

1. Chaque itérateur doit avoir une __iter__méthode. Avoir __iter__suffit pour être un itérable. Par conséquent, chaque itérateur est un itérable.

2. Quand __iter__est appelé, il doit retourner un itérateur ( return <iterator>dans le diagramme ci-dessus). L'appel d'un générateur renvoie un itérateur de générateur qui est un type d'itérateur.

   class Iterable1:
       def __iter__(self):
           # a method (which is a function defined inside a class body)
           # calling iter() converts iterable (tuple) to iterator
           return iter((1,2,3))
   
   class Iterable2:
       def __iter__(self):
           # a generator
           for i in (1, 2, 3):
               yield i
   
   class Iterable3:
       def __iter__(self):
           # with PEP 380 syntax
           yield from (1, 2, 3)
   
   # passes
   assert list(Iterable1()) == list(Iterable2()) == list(Iterable3()) == [1, 2, 3]

3. Voici un exemple:

   class MyIterable:
   
       def __init__(self):
           self.n = 0
   
       def __getitem__(self, index: int):
           return (1, 2, 3)[index]
   
       def __next__(self):
           n = self.n = self.n + 1
           if n > 3:
               raise StopIteration
           return n
   
   # if you can iter it without raising a TypeError, then it's an iterable.
   iter(MyIterable())
   
   # but obviously `MyIterable()` is not an iterator since it does not have
   # an `__iter__` method.
   from collections.abc import Iterator
   assert isinstance(MyIterable(), Iterator)  # AssertionError

Je ne sais pas si cela aide quelqu'un, mais j'aime toujours visualiser les concepts dans ma tête pour mieux les comprendre. Donc, comme j'ai un petit fils, je visualise le concept itérable / itérateur avec des briques et du papier blanc.

Supposons que nous soyons dans la pièce sombre et que nous ayons au sol des briques pour mon fils. Les briques de différentes tailles, couleurs n'ont plus d'importance maintenant. Supposons que nous ayons 5 briques comme celles-ci. Ces 5 briques peuvent être décrites comme un objet - disons un kit de briques . Nous pouvons faire beaucoup de choses avec ce kit de briques - peut en prendre un, puis prendre le deuxième, puis le troisième, peut changer l'emplacement des briques, mettre la première brique au-dessus de la seconde. Nous pouvons faire beaucoup de choses avec ceux-ci. Par conséquent, ce kit de briques est un objet ou une séquence itérable car nous pouvons parcourir chaque brique et en faire quelque chose. Nous ne pouvons le faire que comme mon petit fils - nous pouvons jouer avec une brique à la fois . Encore une fois, je m'imagine que ce kit de briques est unitérable .

Rappelez-vous maintenant que nous sommes dans la pièce sombre. Ou presque sombre. Le fait est que nous ne voyons pas clairement ces briques, leur couleur, leur forme, etc. Donc, même si nous voulons faire quelque chose avec elles - aka itérer à travers elles - nous ne savons pas vraiment quoi et comment trop sombre.

Ce que nous pouvons faire, c'est près de la première brique - en tant qu'élément d'un kit de briques - nous pouvons mettre un morceau de papier fluorescent blanc afin que nous puissions voir où se trouve le premier élément de brique. Et chaque fois que nous prenons une brique d'un kit, nous remplaçons le morceau de papier blanc par une brique suivante afin de pouvoir le voir dans la pièce sombre. Cette feuille de papier blanche n'est rien de plus qu'un itérateur . C'est aussi un objet . Mais un objet avec ce que nous pouvons travailler et jouer avec des éléments de notre objet itérable - le kit de briques.

Cela explique d'ailleurs ma première erreur lorsque j'ai essayé ce qui suit dans un IDLE et obtenu une TypeError:

 >>> X = [1,2,3,4,5]
 >>> next(X)
 Traceback (most recent call last):
    File "<pyshell#19>", line 1, in <module>
      next(X)
 TypeError: 'list' object is not an iterator

La liste X ici était notre kit de briques mais PAS un morceau de papier blanc. Je devais d'abord trouver un itérateur:

>>> X = [1,2,3,4,5]
>>> bricks_kit = [1,2,3,4,5]
>>> white_piece_of_paper = iter(bricks_kit)
>>> next(white_piece_of_paper)
1
>>> next(white_piece_of_paper)
2
>>>

Je ne sais pas si cela aide, mais cela m'a aidé. Si quelqu'un pouvait confirmer / corriger la visualisation du concept, je lui en serais reconnaissant. Cela m'aiderait à en savoir plus.

Iterable : - quelque chose qui est itérable est itérable; comme des séquences comme des listes, des chaînes, etc. Il possède également la __getitem__méthode ou une __iter__méthode. Maintenant, si nous utilisons la iter()fonction sur cet objet, nous aurons un itérateur.

Itérateur : - Lorsque nous obtenons l'objet itérateur de la iter()fonction; nous appelons __next__()méthode (en python3) ou simplement next()(en python2) pour obtenir les éléments un par un. Cette classe ou instance de cette classe est appelée un itérateur.

De documents: -

L'utilisation d'itérateurs imprègne et unifie Python. En arrière-plan, l'instruction for appelle  iter() l'objet conteneur. La fonction renvoie un objet itérateur qui définit la méthode  __next__() qui accède aux éléments du conteneur un par un. Lorsqu'il n'y a plus d'éléments,  __next__() déclenche une exception StopIteration qui indique à la boucle for de se terminer. Vous pouvez appeler la  __next__() méthode à l'aide de la  next() fonction intégrée; cet exemple montre comment tout cela fonctionne:

>>> s = 'abc'
>>> it = iter(s)
>>> it
<iterator object at 0x00A1DB50>
>>> next(it)
'a'
>>> next(it)
'b'
>>> next(it)
'c'
>>> next(it)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
    next(it)
StopIteration

Ex d'une classe: -

class Reverse:
    """Iterator for looping over a sequence backwards."""
    def __init__(self, data):
        self.data = data
        self.index = len(data)
    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')
>>> iter(rev)
<__main__.Reverse object at 0x00A1DB50>
>>> for char in rev:
...     print(char)
...
m
a
p
s

Je ne pense pas que vous puissiez l'obtenir beaucoup plus simple que la documentation , mais je vais essayer:

• Iterable est quelque chose qui peut être répété . En pratique, cela signifie généralement une séquence, par exemple quelque chose qui a un début et une fin et un moyen de parcourir tous les éléments qu'il contient.

• Vous pouvez penser Iterator comme une pseudo-méthode d'aide (ou pseudo-attribut) qui donne (ou détient) le prochain (ou premier) élément de l' itérable . (En pratique c'est juste un objet qui définit la méthode next())

• L'itération est probablement mieux expliquée par la définition Merriam-Webster du mot :

b: la répétition d'une séquence d'instructions informatiques un nombre spécifié de fois ou jusqu'à ce qu'une condition soit remplie - comparer la récursivité

iterable = [1, 2] 

iterator = iter(iterable)

print(iterator.__next__())   

print(iterator.__next__())   

donc,

1. iterableest un objet qui peut être bouclé . par exemple liste, chaîne, tuple, etc.

2. l'utilisation de la iterfonction sur notre iterableobjet retournera un objet itérateur.

3. maintenant cet objet itérateur a une méthode nommée __next__(en Python 3, ou juste nexten Python 2) par laquelle vous pouvez accéder à chaque élément d'itérable.

donc, LA SORTIE DU CODE CI-DESSUS SERA:

1

2

Les itérables ont une __iter__méthode qui instancie un nouvel itérateur à chaque fois.

Les itérateurs implémentent une __next__méthode qui renvoie des éléments individuels et une __iter__méthode qui renvoie self.

Par conséquent, les itérateurs sont également itérables, mais les itérables ne sont pas des itérateurs.

Luciano Ramalho, Fluent Python.

Avant de traiter les itérables et l'itérateur, le principal facteur qui décide de l'itérable et de l'itérateur est la séquence

Séquence: la séquence est la collecte de données

Iterable: Iterable sont les objets de type séquence qui prennent en charge la __iter__méthode.

Méthode Iter: la méthode Iter prend la séquence en entrée et crée un objet appelé itérateur

Itérateur: l'itérateur est l'objet qui appelle la méthode suivante et transverse à travers la séquence. En appelant la méthode suivante, elle retourne l'objet qu'elle a traversé actuellement.

exemple:

x=[1,2,3,4]

x est une séquence qui consiste en la collecte de données

y=iter(x)

En l'appelant, iter(x)il retourne un itérateur uniquement lorsque l'objet x a la méthode iter, sinon il déclenche une exception.Si il retourne l'itérateur, y est assigné comme ceci:

y=[1,2,3,4]

Comme y est un itérateur, il supporte donc la next()méthode

En appelant la méthode suivante, elle retourne les éléments individuels de la liste un par un.

Après avoir renvoyé le dernier élément de la séquence, si nous appelons à nouveau la méthode suivante, cela déclenche une erreur StopIteration

exemple:

>>> y.next()
1
>>> y.next()
2
>>> y.next()
3
>>> y.next()
4
>>> y.next()
StopIteration

En Python, tout est un objet. Lorsqu'un objet est dit itérable, cela signifie que vous pouvez parcourir (c'est-à-dire itérer) l'objet en tant que collection.

Les tableaux par exemple sont itérables. Vous pouvez les parcourir avec une boucle for et passer de l'index 0 à l'index n, n étant la longueur de l'objet tableau moins 1.

Les dictionnaires (paires clé / valeur, également appelés tableaux associatifs) sont également itérables. Vous pouvez parcourir leurs clés.

Evidemment les objets qui ne sont pas des collections ne sont pas itérables. Un objet booléen par exemple n'a qu'une seule valeur, True ou False. Ce n'est pas itérable (cela n'aurait aucun sens que ce soit un objet itérable).

Lire la suite. http://www.lepus.org.uk/ref/companion/Iterator.xml