Un iterable es cualquier cosa sobre la que puedes iterar (una lista, una cadena, un dict); un iterador es el objeto que realiza la iteración propiamente dicha, produciendo valores uno a uno y rastreando su posición. Esta distinción sustenta el funcionamiento de los bucles 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
Un bucle for llama a iter() para obtener un iterador y luego llama repetidamente a next() hasta que StopIteration señala el final. Este protocolo es lo que hace que cualquier iterable sea recorrible.
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
Diferencia clave: un iterable (lista) puede recorrerse muchas veces (cada for obtiene un iterador nuevo); un iterador es de un solo uso: una vez agotado, queda vacío.
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
Los generadores son la forma fácil de crear iteradores: yield se encarga por ti de la maquinaria de __next__/StopIteration.
La distinción iterable/iterador explica cómo funcionan los bucles for en Python y cómo se unifica la iteración entre todas las colecciones (listas, dicts, archivos, generadores) mediante el protocolo de iteradores.
Comprenderla aclara comportamientos reales: por qué un iterador solo puede consumirse una vez (un error común: recorrer un generador/zip dos veces no da nada la segunda vez), por qué los generadores son iteradores y cómo hacer iterables tus propios objetos.
Este protocolo es la base del modelo de iteración elegante y coherente de Python, y es esencial para trabajar con generadores, evaluación perezosa y clases iterables personalizadas.