Quels sont exactement itérateur, itératif, et l'itération?

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

un itérable est:

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

un itérateur est un objet:

• avec un État qui se rappelle où il est pendant l'itération,
• avec une méthode __next__ qui:
  • renvoie la valeur suivante dans l'itération
  • met à jour l'État pour pointer vers la valeur suivante
  • signale quand il est fait en soulevant StopIteration
• et qui est auto-itérable (ce qui signifie qu'il a une méthode __iter__ qui retourne self ).

Notes:

• la méthode __next__ en Python 3 est appelée next en Python 2, et
• la fonction intégrée next() appelle cette méthode sur le l'objet est passé.

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 grandes, mais comme la plupart de ce que j'ai vu, ne mettez pas l'accent sur le distinction assez pour les gens comme moi.

aussi, les gens ont tendance à obtenir" trop Pythonic "en mettant des définitions comme "X est un objet qui a __foo__() méthode " avant. De telles définitions sont correctes-elles sont basées sur la philosophie du canard-typing, mais l'accent sur les méthodes a tendance à s'interposer lorsqu'on essaie de comprendre le concept dans sa simplicité.

donc j'ajoute ma version.

en langage naturel,

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

En Python,

• itérable est un objet qui est, bien, itératif, qui tout simplement, signifie que il peut être utilisé en itération, p.ex. avec une boucle for . Comment? En utilisant iterator . Je vais vous expliquer ci-dessous.

• ... alors que iterator est un objet qui définit comment faire réellement le itération -- spécifiquement Quel est le prochain élément . C'est pourquoi il doit avoir next() la méthode.

Les itérateurs sont eux aussi itérables, à la différence que leur méthode __iter__() renvoie le même objet ( self ), que ses articles aient été consommés ou non par des appels antérieurs à next() .

alors que pense Python interpreter quand il voit la déclaration for x in obj: ?

regardez, une boucle for . Ressemble à un travail pour un itérateur... Let's get un. ... Il y a ce obj , alors demandons-lui.

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

OK, c'était facile... Nous allons commencer à répéter ensuite. ( x = _i.next() ... x = _i.next() ...)

puisque M. obj a réussi ce test (en ayant une méthode retour d'un itérateur de validation), nous le récompensons par un adjectif: vous pouvez maintenant l'appeler "M. itérable obj ".

cependant, dans les cas simples, vous ne bénéficiez pas normalement d'avoir itérateur et itérable séparément. Ainsi, vous définissez seulement un objet, qui est aussi son propre itérateur. (Python ne se soucie pas vraiment que _i distribué par obj n'était pas si brillant, mais juste le obj lui-même.)

C'est pourquoi dans la plupart des exemples j'ai vu (et ce qui avait été confus moi 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'itérateur séparé de l'itératif, comme lorsque vous voulez avoir une rangée d'éléments, mais en plus "curseurs". Par exemple, lorsque vous voulez travailler avec des éléments "actuels" et "à venir", vous pouvez avoir des itérateurs distincts pour les deux. Ou plusieurs threads à partir d'une liste énorme: chacun peut avoir son propre itérateur pour parcourir tous les éléments. Voir de @Raymond et de @glglgl Réponses 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()

Notes:

• je le répète encore une fois: itérateur n'est pas itératif . Itérateur ne peut pas être utilisé comme une "source" dans for boucle. Ce que for besoins principaux de la boucle est __iter__() (qui renvoie quelque chose avec next() ).

• bien sûr, for n'est pas la seule boucle d'itération, donc ci-dessus s'applique à un autre construit aussi ( while ...).

• Itérateur next() peut jeter StopIteration pour arrêter l'itération. N'a pas à, cependant, il peut itérer pour toujours ou utiliser d'autres moyens.

• dans le "processus de pensée" ci-dessus, _i n'existe pas vraiment. J'ai composé ce nom.

• il y a un petit changement en Python 3.x: méthode next() (pas la méthode intégrée) maintenant doit s'appeler __next__() . Oui, ça aurait dû être comme ça depuis le début.

• vous pouvez aussi le penser comme ceci: iterable a les données, iterator tire la prochaine article

avis de non-responsabilité: Je ne suis pas un développeur D'interpréteur Python, donc je ne sais pas vraiment ce que l'interpréteur"pense". Les réflexions ci-dessus ne sont que la démonstration de la façon dont je comprends le sujet à partir d'autres explications, expériences et expérience de la vie réelle d'un débutant de Python.

un itérable est un objet qui a une méthode __iter__() . Il peut éventuellement itéré plusieurs fois, comme list() et de tuple() .

un itérateur est l'objet qui itère. Il est retourné par une méthode __iter__() , retourne lui-même par sa propre méthode __iter__() et a une méthode next() ( __next__() en 3.x).

itération est le processus d'appel de ce next() resp. __next__() jusqu'à ce qu'il soulève 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

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

supposons que nous soyons dans la chambre noire et que sur le sol nous ayons des briques pour mon fils. Briques de différentes tailles, couleur, n'a pas d'importance maintenant. Supposons qu'on ait 5 briques comme ça. Ces 5 briques peuvent être décrites comme un objet - disons briques "kit 151990920" . Nous pouvons faire beaucoup de choses avec ce kit de briques – peut prendre un et puis prendre deuxième et puis troisième, peut changer les places des briques, mettre première brique au-dessus de la deuxième. Nous pouvons faire beaucoup de sortes de choses avec ceux-ci. Par conséquent, ce kit de briques est un objet itérable ou séquence que nous pouvons passer à travers chaque brique et faire quelque chose avec elle. Nous ne pouvons le faire comme mon petit – fils, nous pouvons jouer avec un brique à l'heure . Je me suis donc imaginé que ce kit de briques serait un itérable .

 >>> 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

>>> 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
>>>