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

444

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?

thechrishaddad
la source

Réponses:

531

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 .

agf
la source
1
Notez que les collections.abc.AsyncIteratortests __aiter__et les __anext__méthodes. Il s'agit d'un nouvel ajout en 3.6.
Janus Troelsen
1
@jlh pourquoi serait __len__nécessairement lié à l'itération? Comment le fait de connaître la longueur de quelque chose vous aiderait-il à le répéter?
shadowtalker
2
@shadowtalker, il serait utile de savoir quels index sont valides, donc vous savez avec quels index peuvent être utilisés __getitem__.
jlh
4
@jlh il semble que vous proposiez un comportement dfeault très perspicace. Considérez que la {'a': 'hi', 'b': 'bye'}longueur est de 2, mais ne peut pas être indexée par 0, 1 ou 2.
shadowtalker
2
@shadowtalker. Mais un dict a une __iter__méthode. Je pense que jlh fait référence à des objets qui sont itérables spécifiquement parce qu'ils définissent: "une __getitem__méthode qui peut prendre des index séquentiels à partir de zéro".
Rich
337

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
Raymond Hettinger
la source
qu'entendez-vous par nouvel itérateur?
lmiguelvargasf
13
@lmiguelvargasf "Frais" comme dans "nouveau et non consommé" par opposition à "épuisé ou partiellement consommé". L'idée est qu'un nouvel itérateur commence au début, tandis qu'un itérateur partiellement utilisé reprend là où il s'était arrêté.
Raymond Hettinger
Vos 2e, 3e et 4e puces indiquent clairement ce que vous voulez dire, en termes de constructions python spécifiques ou intégrées ou d'appels de méthode. Mais la 1ère puce ("tout ce qui peut être bouclé") n'a pas cette clarté. En outre, la 1ère puce semble avoir un chevauchement avec la 2ème puce, car la 2ème puce concerne les forboucles et la 1ère puce concerne le "bouclage". Pourriez-vous les aborder?
fountainhead
2
Les pls envisagent de reformuler "tout ce que vous pouvez appeler iter()" comme "tout ce que vous pouvez transmettre iter()"
fountainhead
98

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.

Alois Mahdal
la source
1
C'est super - mais je suis toujours un peu confus. Je pensais que votre boîte jaune disait qu'une forboucle a besoin d'un itérateur ("Regardez, une boucle for. On dirait un travail pour un itérateur ... Prenons-en un."). Mais alors vous dites dans les notes à la fin que "Iterator ne peut pas être utilisé comme source dans une forboucle" ...?
Racing Tadpole
Pourquoi mettez-vous juste passdans le code de ces nextdéfinitions? Je suppose que vous voulez simplement dire que quelqu'un doit mettre en œuvre un moyen d'obtenir le suivant, car le prochain doit retourner quelque chose.
nealmcb
@nealmcb Oui, je pense que c'est ce que voulait dire passé moi. (C'est à cela que passsert , après tout.)
Alois Mahdal
@AloisMahdal Ahh, je n'avais jamais vu cette utilisation auparavant. Quand je vois pass, je pense que c'est là pour des raisons syntaxiques. Je viens de parcourir les réponses à des points de suspension qui sont assez intéressants: vous pouvez utiliser ...pour indiquer un bloc "todo later". NotImplementedest également disponible.
nealmcb
Bien que j'aime que vous insistiez sur la distinction entre un itérateur et un itérable, cette réponse se contredit. D'abord, vous écrivez: «Les itérateurs sont eux-mêmes également itérables» (ce qui correspond à ce qui est écrit dans la documentation Python ). Mais plus tard, vous écrivez: «l' itérateur n'est pas itérable . L'itérateur ne peut pas être utilisé comme "source" en forboucle '. Je comprends l'essentiel de votre réponse, et j'aime bien le contraire, mais je pense qu'il serait avantageux de régler ce problème.
Rich
22

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
glglgl
la source
Alors vraiment, c'est juste un objet qui passe à travers le conteneur? cela serait-il utile?
thechrishaddad
Souvent, mais pas toujours. Un générateur, un fichier ou un curseur de base de données ne peuvent être itérés qu'une seule fois et sont donc leurs propres itérateurs.
glglgl
Je suppose que b2 n'a pas à être indépendant de b1? pour ce cas particulier, il est indépendant, bien sûr je peux le rendre non indépendant mais aussi valide Iterable.
Bin
@Bin Oui. Comme et Iteratorest toujours Iterableet est le sien Iterator, deux appels de iter()ne donnent pas nécessairement deux Iterators indépendants .
glglgl
13

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
AXO
la source
1
Dans le quiz, je n'ai compris que le 1er point. ie itérateur devient un itérable comme il a la __iter__méthode. Pouvez-vous développer les 2e et 3e points en modifiant cette réponse
AnV
@AnV: Pour autant que je comprends: re 2.: __iter__()Renvoie un itérateur. Un générateur est un itérateur, il peut donc être utilisé à cette fin. re 3.: Je ne peux que deviner ici, mais je pense que s'il __iter__()manque, ou ne revient pas self, ce n'est pas un itérateur, car un itérateur __iter__()doit revenir self.
glglgl
10

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.

Nikolay Dudaev
la source
6

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
Vicrobot
la source
4

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é

Kimvais
la source
3
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

arpan kumar
la source
3

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.

techkuz
la source
2

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
Ombre
la source
Juste une observation: y = iter (x) n'est pas exactement y = [1,2,3,4] puisque y est maintenant un objet itérateur. Vous devriez peut-être ajouter un commentaire pour clarifier qu'il ne s'agit pas d'une liste mais d'un objet itérateur ou modifier la représentation.
coelhudo
-6

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

user93097373
la source
6
les objets qui ne sont pas des collections ne sont pas itérables n'est généralement pas vrai. Pour ne donner que quelques exemples, les générateurs sont itérables mais ne sont pas des collections, et les objets itérateurs créés en faisant appel iter()aux types de collections standard sont itérables mais ne sont pas eux-mêmes des collections.
Mark Amery