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

Itération est un terme général pour chaque élément de quelque chose, l'un après l'autre. Chaque fois que vous utilisez une boucle, explicite ou implicite, d'aller sur un groupe d'éléments, c'est-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 un __getitem__ méthode qui peut prendre des séries d'indices en partant de zéro (et soulève une IndexError lorsque les index ne sont plus valides). Donc un itérable est un objet que vous pouvez obtenir une itérateur de.

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

Chaque fois que vous utilisez un for boucle, ou map, ou une compréhension de liste, etc. en Python, les next méthode est appelée automatiquement à chaque élément de la itérateur, donc passer par le processus de itération.

Un bon endroit pour commencer à apprendre à serait la les itérateurs de la section du tutoriel et la itérateur section des types des types standard de la page. Après vous comprenez les bases, essayez de le les itérateurs de la section de la Programmation Fonctionnelle HOWTO.

Les réponses ci-dessus sont grands, mais comme la plupart de ce que j'ai vu, ne pas le stress de la distinction assez pour que 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. De telles définitions sont correctes--ils sont basés sur le canard-la dactylographie de la philosophie, mais l'accent sur les méthodes qui tend à obtenir entre en essayant de comprendre le concept dans sa simplicité.

J'ajoute donc 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é dans l'itération, par exemple, avec un for boucle. Comment? En utilisant itérateur.
  Je vais vous expliquer ci-dessous.

• ... alors que itérateur est un objet qui définit comment faire l'
  itération, plus précisément quelle est la prochaine élément. C'est pourquoi il doit avoir
  next() méthode.

Les itérateurs sont eux aussi itératif, avec la distinction que leur __iter__() méthode renvoie le même objet (self), indépendamment de si oui ou non ses éléments ont été consommés par les précédents appels à next().

---

Donc, ce n'est interpréteur Python pense que quand il voit for x in obj: déclaration?

Regard, un for boucle. Ressemble à un travail pour un itérateur... nous allons faire une. ...
Il y a cette obj gars, nous allons donc lui demander.

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

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

Depuis que M. obj réussi dans ce test (par une certaine méthode retournant un valide itérateur), nous récompensez-le avec un adjectif: vous pouvez maintenant appeler "objet iterable M. obj".

Toutefois, dans les cas simples, vous n'avez pas l'habitude de bénéficier de la itérateur et itératif séparément. Si vous définissez un seul objet, qui est aussi son propre itérateur. (Python n'a pas vraiment de soins que _i remis par obj n'est pas brillant, mais juste le obj lui-même.)

C'est pourquoi dans la plupart des exemples que j'ai vu (et ce qui a été source de confusion sur moi et plus),
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 "en cours" et "venir" les éléments, vous pouvez séparer les itérateurs pour les deux. Ou plusieurs threads en tirant à partir d'une liste énorme: chacun peut avoir ses propres itérateur pour parcourir plus de tous les éléments. Voir @Raymond la et @glglgl de l' les 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 vais le répéter encore une fois: itérateur n'est pas itératif. Itérateur ne peut pas être utilisé comme
  une "source" dans for boucle. Ce for boucle principalement besoins est __iter__()
  (qui renvoie à quelque chose avec next()).

• Bien sûr, for n'est pas la seule itération de la boucle, donc au-dessus s'applique à certains autres
  construit ainsi (while...).

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

• Dans l'au-delà "processus de pensée", _i n'existe pas vraiment. J'ai composé ce nom.

• Il y a un petit changement dans Python 3.x: next() méthode (le) maintenant
  doit être appelée __next__(). Oui, il doit avoir été comme ça tout le long.

• Vous pouvez aussi penser de cette façon: itérable a les données, iterator tire la prochaine
  élément

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

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

Supposons que nous sommes dans la chambre noire et de l'étage, nous avons des briques pour mon fils. Des briques de différentes taille, la couleur n'a pas d'importance maintenant. Supposons que nous disposons de 5 briques comme ceux. Ces 5 briques peut être décrit comme un objet – disons briques kit. Nous pouvons faire beaucoup de choses avec ce kit de briques – peut prendre un et puis la deuxième, puis de troisième, il peut changer les lieux de briques, de mettre à la première place de la brique au-dessus de la seconde. Nous pouvons faire beaucoup de sortes de choses avec ceux-ci. Par conséquent, cette briques kit est un objet itérable ou séquence que nous pouvons aller à travers chaque brique et de faire quelque chose avec elle. Nous ne pouvons le faire comme mon petit – fils, nous pouvons jouer avec un brique à un moment. Encore une fois, je m'imaginer ce kit de briques à un itérable.

Maintenant, rappelez-vous que nous sommes dans la chambre noire. Ou presque sombre. Le truc, c'est que nous n'avons pas de voir clairement ces briques, de quelle couleur ils sont, ce que la forme etc. Donc, même si nous voulons faire quelque chose avec eux – aka itérer à travers eux – nous ne savons pas vraiment quoi et comment parce que c'est trop sombre.

Ce que nous pouvons faire est de près pour la première brique comme élément d'un kit de briques – on peut mettre un morceau de blanc fluorescent papier afin de nous permettre de voir où la première brique est l'élément. Et chaque fois que nous prenons une brique à partir d'un kit, on remplace la feuille de papier blanc pour une brique afin d'être en mesure de voir que dans la chambre noire. Ce morceau de papier blanc est rien de plus qu'un itérateur. C'est un objet ainsi. Mais un objet avec ce que l'on peut travailler et jouer avec les éléments de notre objet itérable – briques kit.

Que par la voie explique le début de mon erreur quand j'ai essayé ce qui suit, dans un RALENTI et a obtenu une exception 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

Liste X c'était notre kit de briques, mais PAS un morceau de papier blanc. J'ai besoin de trouver un itérateur d'abord:

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

Ne sais pas si ça aide, mais ça m'a aidé. Si quelqu'un pouvait confirmer/visualisation correcte de la notion, je vous serais reconnaissant. Il pourrait m'aider à en savoir plus.

Itérable:- quelque chose qui est itératif est itératif; comme les séquences comme des listes ,des chaînes, etc.
Il a aussi le __getitem__ méthode ou d'une __iter__ méthode. Maintenant, si nous utilisons iter() la fonction de cet objet, nous allons obtenir un itérateur.

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

De docs:-

L'utilisation des itérateurs envahit et unifie Python. En coulisses, le de l'état des appels iter() sur l'objet conteneur. La fonction retourne un itérateur objet que définit la méthode __next__() qui accède à des éléments dans le conteneur un à la fois. Quand il n'y a pas plus d'éléments, __next__() pose d'un StopIteration exception qui raconte l' pour boucle à la fin. Vous pouvez appeler le __next__() méthode utilisant le next() la 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

iterable = [1, 2] 

iterator = iter(iterable)

print(iterator.__next__())   

print(iterator.__next__())   

donc,

1. iterable est un objet qui peut être en boucle sur. par exemple, liste , string tuple etc.

2. à l'aide de la iter fonction sur notre iterable objet sera de retour une itérateur objet.

3. maintenant ce itérateur objet a méthode nommée __next__ (en Python 3, ou tout simplement next en Python 2) par lequel vous pouvez accéder à chaque élément de l'objet iterable.

donc,
SORTIE DE CODE CI-DESSUS SERA:

1

2

Iterables ont un __iter__ méthode qui instancie un nouvel itérateur à chaque fois.

Itérateurs mettre en œuvre un __next__ méthode qui renvoie à des éléments individuels, et un __iter__ méthode qui retourne self .

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

Luciano Ramalho, Couramment Python.