Saltearse al contenido

Iterables e iteradores

for x in algo funciona con listas, cadenas, archivos, diccionarios y bases de datos. Detrás de esa uniformidad hay dos conceptos distintos que la sintaxis esconde: el iterable (algo que puede producir un iterador) y el iterador (el que lleva la cuenta). Confundirlos produce el bug más común de la iteración: un objeto que se agota y no se puede volver a recorrer.

El iterable es la fuente; el iterador es el dedo que la recorre, y una vez llegado al final no vuelve solo.

for x in objeto:
...

equivale a:

it = iter(objeto) # llama a objeto.__iter__()
while True:
try:
x = next(it) # llama a it.__next__()
except StopIteration:
break

Dos métodos, dos responsabilidades:

Método En quién Qué hace
__iter__ iterable devuelve un iterador
__next__ iterador devuelve el siguiente o lanza StopIteration

Todo iterador es iterable (su __iter__ devuelve self), pero no todo iterable es iterador. Una lista es iterable y no iteradora: cada iter(lista) crea un contador nuevo.

Recorrer 100 000 elementos
Forma Tiempo Frente a lista
list plana 2.69 ms 1.0×
Generador (yield) 3.30 ms 1.2×
Clase con __next__ 9.86 ms 3.7×

python mediciones/03-05-08-iteracion.py

Un generador cuesta un 20 % más que una lista por elemento: paga la máquina de estados de yield en cada vuelta. Una clase con __next__ cuesta casi cuatro veces más, porque cada elemento atraviesa una llamada a método Python. La conclusión no es «evita los iteradores»: es que la lista es la más rápida por elemento y la que más memoria ocupa, y el capítulo 07 mide ese intercambio.

Un iterable no tiene por qué tener los elementos: puede calcularlos.

class Cuadrados:
def __init__(self, n):
self.n = n
def __iter__(self):
for i in range(self.n):
yield i * i

Ese objeto no guarda nada más que n. Recorrerlo un millón de veces no crece la memoria: cada pasada crea un iterador nuevo y lo consume.

next(it) lanza StopIteration al final, y ese es el error que obliga a envolver todo en try. La forma corta evita el try:

it = iter([1, 2, 3])
next(it, None) # 1
next(it, None) # 2
next(it, None) # 3
next(it, None) # None — sin excepción

Es el idioma de los lectores por bloques y de los while True con centinela: el None (o cualquier centinela propio) indica «no hay más» sin mezclar control de flujo con excepciones.

La advertencia: si el iterable puede contener None como valor legítimo, el centinela tiene que ser otro objeto. centinela = object() es la forma de garantizar que no colisiona con ningún dato.

  • Si basta un generador. yield hace lo mismo con menos código y sin la trampa de return self.
  • Si necesitas indexar. Un iterador no tiene [i]; si el acceso aleatorio es parte del contrato, es una secuencia.
  • Si vas a recorrer varias veces. Materializa en una lista o devuelve un iterable nuevo cada vez.
  • Si el consumo debe ser concurrente. Los iteradores no son seguros entre hilos; la Parte VI lo cubre.

Escribe un iterable Pares(limite) que produzca los números pares hasta un límite. Debe poder recorrerse dos veces. Después explica qué cambiaría si en vez de un iterable fuera un iterador.

Solución
class Pares:
def __init__(self, limite):
self.limite = limite
def __iter__(self):
for i in range(0, self.limite, 2):
yield i
p = Pares(10)
list(p) # [0, 2, 4, 6, 8]
list(p) # [0, 2, 4, 6, 8] ← funciona otra vez

__iter__ es un generador: cada llamada crea un iterador nuevo con su propio estado, así que el objeto no se agota.

Si fuera un iterador (__iter__ devolviendo self y un __next__ con contador), la segunda llamada devolvería []. Ese sería el comportamiento correcto sólo si Pares representara un flujo que se consume, como un cursor de base de datos.

Comprobación con datos de ejemplo:

print(list(p))
print(list(p))
print(sum(Pares(100)))
class ParesIterador:
def __init__(self, limite):
self.actual, self.limite = 0, limite
def __iter__(self):
return self
def __next__(self):
if self.actual >= self.limite:
raise StopIteration
valor = self.actual
self.actual += 2
return valor
q = ParesIterador(10)
print(list(q), list(q))
assert list(p) == [0, 2, 4, 6, 8], "el iterable no se agota"
  • Ramalho, L. Fluent Python, 2ª ed. Capítulo 17: iteradores y generadores.
  • CPython 3.13: Objects/iterobject.c, Python/ceval.c (FOR_ITER).
  • Mediciones: mediciones/03-05-08-iteracion.py.
  • 02 · El modelo de datos (Parte I): el fallback a __getitem__ cuando no hay __iter__.
  • 06 · Generadores: la forma corta de escribir un iterador.
  • 07 · Pereza: cuándo no materializar.