Un iterable est n'importe quoi sur lequel vous pouvez itérer (une liste, une chaîne, un dict) ; un iterator est l'objet qui effectue l'itération réelle, produisant des valeurs une par une et suivant sa position. Cette distinction sous-tend le fonctionnement des boucles for en Python.
Iterable → has __iter__() → returns an iterator
Iterator → has __next__() → returns the next value (and __iter__ returning itself)
# this for loop...
for x in [1, 2, 3]:
print(x)
# ...is roughly equivalent to:
it = iter([1, 2, 3]) # __iter__ → get an iterator from the iterable
while True:
try:
x = next(it) # __next__ → get the next value
print(x)
except StopIteration: # raised when exhausted → loop ends
break
Une boucle for appelle iter() pour obtenir un iterator, puis appelle next() répétitivement jusqu'à ce que StopIteration signale la fin. Ce protocole est ce qui rend tout iterable boucle.
nums = [1, 2, 3] # an ITERABLE (a list)
it = iter(nums) # an ITERATOR over it
next(it) # 1
next(it) # 2
next(it) # 3
next(it) # StopIteration
# the list is REUSABLE (get a fresh iterator each loop);
# an iterator is CONSUMED ONCE — exhausted after one pass
list(it) # [] — already used up
Différence clé : un iterable (liste) peut être bouclé plusieurs fois (chaque for obtient un nouvel iterator) ; un iterator est à usage unique — une fois épuisé, il est vide.
class Countdown:
def __init__(self, start): self.n = start
def __iter__(self): return self # the iterable returns itself as iterator
def __next__(self):
if self.n <= 0:
raise StopIteration # signal the end
self.n -= 1
return self.n + 1
for x in Countdown(3): # 3, 2, 1
print(x)
def gen(): yield 1; yield 2 # a generator function returns an iterator automatically
Les générateurs sont le moyen facile de créer des iterators — yield gère la machinerie __next__/StopIteration pour vous.
La distinction iterable/iterator explique comment les boucles for fonctionnent en Python et comment l'itération est unifiée sur toutes les collections (listes, dicts, fichiers, générateurs) via le protocole iterator.
Comprendre cela clarifie les comportements réels — pourquoi un iterator ne peut être consommé qu'une seule fois (un bogue courant : boucler sur un générateur/zip deux fois ne donne rien la deuxième fois), pourquoi les générateurs sont des iterators, et comment rendre vos propres objets iterable.
Ce protocole est la fondation du modèle d'itération élégant et cohérent de Python et est essentiel pour travailler avec les générateurs, l'évaluation paresseuse et les classes iterable personnalisées.