Python Academy · Lección

El protocolo de iteradores

Comprenda __iter__ y __next__

El protocolo de iteradores es una lección gratuita de Python Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Python Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Python Academy incluye 4 lecciones en total.

¿Qué es la iteración?

Siempre que escribe un bucle for sobre una lista, una cadena o un diccionario, Python utiliza el protocolo de iteradores internamente.

Un objeto que se puede recorrer se denomina iterable. El objeto que realmente produce valores de uno en uno se denomina iterador.

for ch in 'abc':
    print(ch)

iter() y next()

Dos funciones integradas controlan la iteración:

iter(obj) solicita su iterador a un iterable.
next(it) solicita el siguiente valor al iterador.

Cuando no quedan más valores, next() genera StopIteration.

it = iter([10, 20, 30])
print(next(it))
print(next(it))
print(next(it))

StopIteration

Llamar a next() una vez de más genera StopIteration. Un bucle for lo captura automáticamente y se detiene correctamente.

it = iter([1])
print(next(it))
try:
    next(it)
except StopIteration:
    print('No more items')

Los dos métodos dunder

Para crear su propio iterador, implemente dos métodos:

__iter__ devuelve el propio objeto iterador.
__next__ devuelve el siguiente valor o genera StopIteration.

class Count:
    def __init__(self, n):
        self.i = 0
        self.n = n
    def __iter__(self):
        return self
    def __next__(self):
        if self.i >= self.n:
            raise StopIteration
        self.i += 1
        return self.i

for x in Count(3):
    print(x)

Iterable frente a iterador

Un iterable solo necesita __iter__. Un iterador necesita tanto __iter__ como __next__.

Las listas son iterables, pero no iteradores: cada llamada a iter() proporciona un iterador nuevo.

nums = [1, 2, 3]
print(iter(nums) is iter(nums))
it = iter(nums)
print(it is iter(it))

Los iteradores se agotan una sola vez

Un iterador solo se puede consumir una vez. Después de llegar al final, permanece vacío. Para volver a recorrerlo, cree un iterador nuevo.

it = iter([1, 2])
print(list(it))
print(list(it))

Un iterador similar a range

Construyamos un iterador personalizado que se comporte como un contador sencillo. Observe cómo el estado reside en la instancia.

class EvenUpTo:
    def __init__(self, limit):
        self.cur = 0
        self.limit = limit
    def __iter__(self):
        return self
    def __next__(self):
        if self.cur > self.limit:
            raise StopIteration
        value = self.cur
        self.cur += 2
        return value

print(list(EvenUpTo(8)))

Separar el iterable del iterador

Un diseño más limpio mantiene separados el contenedor y el iterador, de modo que el contenedor se pueda recorrer muchas veces.

class Bag:
    def __init__(self, items):
        self.items = items
    def __iter__(self):
        return BagIterator(self.items)

class BagIterator:
    def __init__(self, items):
        self.items = items
        self.i = 0
    def __iter__(self):
        return self
    def __next__(self):
        if self.i >= len(self.items):
            raise StopIteration
        v = self.items[self.i]
        self.i += 1
        return v

b = Bag(['x', 'y'])
print(list(b))
print(list(b))

Usar next() con un valor predeterminado

next(it, default) devuelve el valor predeterminado en lugar de generar StopIteration cuando el iterador está vacío. Resulta práctico para consultar el siguiente elemento de forma segura.

it = iter([42])
print(next(it, 'done'))
print(next(it, 'done'))

Los iteradores ahorran memoria

Los iteradores producen un elemento cada vez, por lo que no necesitan mantener toda la secuencia en memoria. Por eso pueden trabajar con secuencias enormes o incluso con flujos infinitos.

class Naturals:
    def __init__(self):
        self.n = 0
    def __iter__(self):
        return self
    def __next__(self):
        self.n += 1
        return self.n

it = iter(Naturals())
print(next(it), next(it), next(it))

Funciones integradas que consumen iteradores

Muchas funciones integradas aceptan cualquier iterador: sum, max, min, sorted, list y tuple. Extraen valores hasta encontrar StopIteration.

class Count:
    def __init__(self, n):
        self.i = 0
        self.n = n
    def __iter__(self):
        return self
    def __next__(self):
        if self.i >= self.n:
            raise StopIteration
        self.i += 1
        return self.i

print(sum(Count(5)))
print(max(Count(5)))

Comprobación rápida

Compruebe su comprensión del protocolo de iteradores.

Resumen

Ha aprendido el protocolo de iteradores:

iter() obtiene un iterador y next() extrae valores.
StopIteration señala el final y for se encarga de gestionarlo.
Los iteradores personalizados implementan __iter__ y __next__.
Los iteradores son de un solo uso y eficientes en cuanto al uso de memoria.

A continuación, dejará que Python escriba los iteradores por usted con yield.

Preguntas frecuentes

¿La lección «El protocolo de iteradores» es gratis?

Sí — el texto completo de «El protocolo de iteradores» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Python Academy, actualiza a CoddyKit PRO. El curso de Python Academy incluye 4 lecciones en total.

¿Qué aprenderé en «El protocolo de iteradores»?

Comprenda __iter__ y __next__ Practicas Python Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Python Academy?

No se requiere experiencia previa. Python Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «El protocolo de iteradores»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Python Academy?

Sí. Cada lección de Python Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Python Academy