Iteradores

Clase 12 de 21 • Curso Profesional de Python

César Alejandro Martínez Ortíz

student•

Qué mágico momento fue el de la explicación del funcionamiento interno del ciclo for! Probablemente ha sido de mis momentos favoritos de la trilogía de FacMartoni

Esteban Blanco Ortuno

student•

Es muy interesante, también me ha gustado.

Luis Alejandro Vera Hernandez

student•

Ah si, muy interesante lo del ciclo for y como funciona internamente

Juan Roberto González León

student•

EL CLICLO FOR NO EXISTE

Andrés Cardona

student•

jajajajajajajaja tal cual mi reacción!

Jesús Enrique Morocoima Marcano

student•

jajajajajaja

Miguel Angel Reyes Moreno

student•

Estructuras de datos avanzadas

Iteradores

Antes de entender qué son los iteradores, primero debemos entender a los iterables.

Son todos aquellos objetos que podemos recorrer en un ciclo. Son aquellas estructuras de datos divisibles en elementos únicos que yo puedo recorrer en un ciclo.

Pero en Python las cosas no son así. Los iterables se convierten en iteradores.

Ejemplo:

# Creando un iterador

my_list = [1,2,3,4,5]
my_iter = iter(my_list)

# Iterando un iterador

print(next(my_iter))

# Cuando no quedan datos, la excepción StopIteration es elevada

# Creando un iterador

my_list = [1,2,3,4,5]
my_iter = iter(my_list)

# Iterando un iterador

while True: #ciclo infinito
  try:
    element = next(my_iter)
    print(element)
  except StopIteration:
    break

Momento impactante: El ciclo "for" dentro de Python, no existe. Es un while con StopIteration. 🤯🤯🤯

my_list = [1,2,3,4,5]

for element in my_list:
  print(element)

evenNumbers.py:

class EvenNumbers:
  """Clase que implementa un iterador de todos los números pares,
  o los números pares hasta un máximo
  """

  #* Constructor de la clase
  def __init__(self, max = None): #self hace referencia al objeto futuro que voy a crear con esta clase
    self.max = max


  # Método para tener elementos o atributos que voy a necesitar para que el iterador funcione
  def __iter__(self):
    self.num = 0 #Primer número par
    #* Convertir un iterable en un iterador
    return self

  # Método para tener la función "next" de Python
  def __next__(self):
    if not self.max or self.num <= self.max:
      result = self.num
      self.num += 2
      return result
    else:
      raise StopIteration

Ventajas de usar iteradores:

Nos ahorra recursos.
Ocupan poca memoria.

Javier Suárez Meerhoff

student•

gracias!

Mauricio Gonzalez Falcon

student•

Gracias por el resumen!

Jesús Velázquez Jiménez

student•

Iterables aquellas estructuras de datos divisibles en elementos únicos que se pueden recorrer en un ciclo.

Todos los iterables pueden convertirse en iteradores para poder ser recorridos en un ciclo.

¡El ciclo for no existe!

Es un alias de un ciclo While infinito con un Try except que controla el Error StopIteration

Construir un iterador desde cero en Python.

Solo tenemos que implementar los métodos

__iter__() :
	"El método __iter__() devuelve el objeto iterador en sí. Si es necesario, se puede realizar alguna inicialización."

__next__():
	"El  método __next__() debe devolver el siguiente elemento de la secuencia.Al llegar al final, y  debe subir el error StopIteration."

Ventajas:

Es una expresión que explica con obtener el resultado. Por ello ahorra la memoria y aumenta la velocidad.

Javier Suárez Meerhoff

student•

gracias!

Carlos Esteban Lara Gil

student•

APUNTES de la clase :snake:

Los iteradores son estructuras de datos divisibles en elementos únicos que puedo recorrer en un ciclo.

Cuando hacemos un ciclo, python no está iterando(internamente). Lo que sucede es que ese iterable se convierte en un objeto especial el cual se llama iterador

my_list = [1,2,3]
my_iter= iter(my_list)
#iterando un iterador

print(next(my_iter))
#Cuándo no quedan datos la excepción StopIteration es elevada

iter convierte un iterable en un iterador
Una vez que se hace, se usa al next() para ir al siguiente elemento del iterador
Cuando ya no quede ningún elemento python imprimirá un error

# creando un iterador
my_list = [1,2,3,4,5,6]
my_iter = iter(my_list)

#iterando un iterador
while True:
    try:
        print(next(my_iter))
        print(element)
    except StopIteration:
        break

Resultado de aplicar iter sobre nuestra lista y el ciclo while infinito.

si usamos while true hará un ciclo infinito
Usamos el manejo de errores. Con try usamos el next() para que ejecute el siguiente elemento
except para cuando devuelva el error StopIteration el ciclo se corta con un break

Ciclo for (azúcar sintáctica)

El ciclo for hace lo mismo que el cico while true. en vez de escribir todo ese código se puede resumir en:

for element in my_list:
    print(element)

el ciclo for no existe en python, lo que hace python es convertir una iterable en un iterador y con un ciclo while recorrerlo hasta encontrar el StopIteration

¿Cómo construyo un iterador?

El protocolo de los iteradores: para construir un iterador, hay que construir una clase que contenga dos métodos importantes:

__iter__() y __next__()

class EventNumber:
    
    """
    Clase que implementa un iterador de todos los números pares, o los números pares hasta un máximo."""

def __init__(self,max=None):
    self.max = max
def __iter__(self):
    self.num = 0
    return self

def __next__(self):
    if not self.max or self.num <= self.max:
        result= self.num
        self.num += 2
        return result

    else:
        raise StopIteration

__ iter __(): retorna al objeto al en sí mismo. Convierte un iterable en un iterador.
_ next __(): Convierte a la función next. Nos permite extraer cada uno de los elementos del iterador

Con los iteradores trabajamos más rápido y ahorramos memoria

ventajas de usar iteradores

Es una expresi+on que exlica como obtener el resultado. También ahorra memoria y es más rápido

Elias Dudamel

student•

Excelente apuntes!!!

Juan Carlos Ortiz Romero

student•

⭐️⭐️⭐️⭐️⭐️ El ciclo “for” dentro de Python no existe. Es realmente un while con StopIteration. ⭐️⭐️⭐️⭐️⭐️

Rodrigo Torres

student•

Si lees esto, pasaste la mitad del curso !! Animo, falta poco!!

Ángel Yasmani Viñamagua Cuenca

student•

Iterables -> Todos los objetos que podemos recorrer en un ciclo, ejem: una lista, un string Iteradores -> Ahorra recursos, puedo almacenar secuencias y progreciones matematicas, ocupa poca memoria.

Gabriel Missael Barco

student•

Iteradores

Un iterator es una estructura de datos para guardar datos infinitos 🤯. Para entenderlo, primero debemos saber que un iterable es todo aquel objeto que puedo recorrer en un ciclo (lista, strings, etc). Un iterable es divisible.
Cuando hacemos un ciclo, Python internamente no está recorriendo a ese iterable, si no más bien ese iterable se convierte internamente en un iterador, que si puede ser recorrido. 🤔

Para crear un iterador:

# Creando un iterador
my_list = [1, 2, 3, 4, 5]
my_iter = iter(my_list)  # Se recibe un iterable

# Iterando un iterador
print(next(my_iter))
# Cuando no quedan datos, la excepción StopIteration es elevada

Para que no se rompa el código, hacemos manejo de errores: 🧠
```
# Creando un iterador
my_list = [1, 2, 3, 4, 5]
my_iter = iter(my_list)

# Iterando un iterador
while True: 
	try: 
		element = next(my_iter)
		print(element)
	except StopIteration:
		break
```
Esta es una manera eficiente de extraer todos los elementos de un iterable. De hecho, esta es la manera en la que funciona un ciclo for, es la azúcar sintaxis de este código anterior 😍. El ciclo for en si mismo no existe.

¿Cómo construyo un iterador?. Una opción es castear desde un iterable. Para hacerlo desde cero, debemos usar el protocolo de los iteradores que contiene dos clases importantes __iter__ y __next__:

class EvenNumbers:
	"""Calse que implementa un iterador de todos los
		 números pares, o los números pares hasta un máximo"""
	def __init__(self, max = None):
		self.max = max

	def __iter__(self):
		self.num = 0
		return self

	def __next__(self):
		if not self.max or self.num <= self.max:
			result = self.num
			self.num += 2
			return self
		else:
			raise StopIteration

Las ventajas de usar iteradores: Nos ahorra recursos computacionales y de memoria, ya que tenemos una función matemática de como obtener los siguientes elementos, sin necesidad de guardarlos todos 👀.

Carlos José Tun Pinzón

student•

Iteradores

Son una estructura de datos para guardar datos infinitos.

Los iterables son los objetos que podemos recorrer a través de un ciclo dicho de otra manera, son estructuras de datos divisibles en elementos que puedo recorrer en un ciclo.

Todos los iterables pueden convertirse en iteradores. De esta manera es que internamente Python los puede recorrer realmente, esto mediante parsing usando el comando iter.

# Creando un iterador
my_list = [1, 2, 3, 4, 5]
my_iter = iter(my_list)

# Iterando un iterador
print(next(my_iter)) # Next nos permite acceder al siguiente elemento del iterador por cada llamada 

# Cuando no quedan datos, la excepción StopIteration es elevada

Si queremos crear un código que nos permita recorrer todos los elementos de nuestra lista usando la función next para como aparece en el ejemplo anterior, tendríamos que realizar un bloque try-except:

# Creando un iterador
my_list = [1, 2, 3, 4, 5]
my_iter = iter(my_list)

# Iterando un iterador
while True:
	try:
		element = next(my_iter)
		print(next(my_iter)) # Next nos permite acceder al siguiente elemento del iterador por cada llamada 
	except StopIteration:
		break                # Salimos del ciclo una vez que obtenemos el último valor iterable

Lo anterior es posible hacerlo de una manera mucho más sencilla, mediante el ciclo for el cual es azúcar sintáctica pues facilita y realiza de una manera mas estética y sencilla una operación:

my_list = [1, 2, 3, 4, 5]

for element in my_list
	print ("element")

Es posible crear un iterador personalizado (directamente, sin castear/casting) el cual nos permita recorrer un infinito número de elementos de acuerdo a una función dada, utiliza dos métodos internos importantes: "iter" y "next".

El uso de una función que determina los valores a iterar nos permite ahorrar memoria y trabajar más rápido, pues no tenemos que almacenar cada uno de los valores, sino solo una función para extraer cada uno de los elementos.

El siguiente ejemplo crea un iterador que recorre todos los números pares:

class EvenNumbers:
  """Clase que implementa un iterador de todos los números pares,
  o los números pares hasta un máximo que definimos
  """

  # Constructor
  def __init__(self, max = None): # self = objeto futuro creado con esta clase
    self.max = max

  # Método para tener elementos o atributos que voy a necesitar para que el iterador funcione
  def __iter__(self):
    self.num = 0            # Primer número par
    return self             

  # Método para tener la función "next" del ciclo for, es decir, recorrer cada valor.
  def __next__(self):
    if not self.max or self.num <= self.max:
      result = self.num
      self.num += 2
      return result
    else:
      raise StopIteration

Hubert Ronald Mendoza Canales

student•

Gracias por el aporte, en la línea expuesta en clase:

class EvenNumbers:
# ....
def __next__(self):
    if not self.max or self.num <= self.max:
   # demas codigo

->not self.max es verdadero cuando self.max es None, es decir self.max is None dará verdadero (self.max=None).

De acuerdo a las recomendaciones de PEP 8 self.max is None es preferida cuando se quiere determinar si es cierto o no que una variable es None El código sugerido sería

class EvenNumbers:
# ....
def __next__(self):
    if self.max is None or self.num <= self.max:
   # demas codigo

Marcel Nahir Samur

student•

Por si alguno se pregunta como usar clases para construir iteradores, aquí va:

Primero se define la clase con sus 3 métodos fundamentales

class EvenNumbers:
  """Clase que implementa un iterador de todos los números pares,
  o los números pares hasta un máximo
  """

  #* Constructor de la clase
  def __init__(self, max = None): #self hace referencia al objeto futuro que voy a crear con esta clase
    self.max = max


  # Método para tener elementos o atributos que voy a necesitar para que el iterador funcione
  def __iter__(self):
    self.num = 0 #Primer número par
    #* Convertir un iterable en un iterador
    return self

  # Método para tener la función "next" de Python
  def __next__(self):
    if not self.max or self.num <= self.max:
      result = self.num
      self.num += 2
      return result
    else:
      raise StopIteration

Luego, en nuestro archivo principal, importamos la clase creada con el iterador

from EvenNumbers import EvenNumbers

n = EvenNumbers(18) #Instaciamos un objeto

myIter = n.__iter__()  #Aplicamos el método __iter__

while True: #ciclo infinito #Utilizamos nuestro for not for
  try:
    element = n.__next__()  #Llamamos al método __next__
    print(element)
  except StopIteration:
    break

Julio Cesar Rodíguez Cristancho

student•

Excelente..Gracias

Fernando Garcia de la Cruz

student•

Hola!!

Tengo una duda, no he podido encontrar documentación sobre la explicación del for como alias de la estructura con while, ¿este tipo de cosas se infieren por las definiciones de los controles de flujo? o dónde podría comprobarlo?

Aquí esta el apartado de la docuentación que consulté.

Tiene todo el sentido del mundo y ha sido muy buena la explicación de Facundo, pero no he podido comprobarlo con otra fuente.

Muchas gracias!!

Omar Daniel Centeno

student•

Hola

Es una excelente forma como lo explica facundo y es la explicación que da en la documentación, aunque sin poner que es un ciclo while. Fue una excelente forma para poder explicar la diferencia y funcionamiento de los ciclos. Entre más comienzas la búsqueda no todo es tan sencillo pues se involucran funciones cada vez de más bajo nivel.

Algunas otras formas de construir iteradores la puedes encontrar en este hilo de SO. Puedes aprender más sobre la librería de itertools para crear iteradores eficientes.

Esa curiosidad te llevará a dominar y entender realmente este fabuloso lenguaje.

Saludos

Fernando Garcia de la Cruz

student•

Muchas gracias por el comentario y las fuentes Omar @ODCCenteno Saludos!! :)

Diego Andrés Rojas González

student•

Plantee otra solución para iterar n elementos. Con la ayuda de una función recursiva y un decorador.

def iterador(func):
	def wrapper(lista):
		lista = iter(lista)
		func(lista)
	return wrapper

@iterador
def iterame(lista):
	try:
		print(next(lista))
		return iterame(lista)
	except StopIteration:
		pass

iterame('Platzi<3')

Jhordan Sax Cordova Poma

student•

Aprendimos geniales conceptos del lenguaje Python !!! Cada vez me agrada más.. y que buen profesor!! para hacer entender estos temas.. 🤠🤠

Luis Fernando Zarazua Aguilar

student•

Les comparto como aplicando el concepto de iteradores realice el calculo del número e a través de una suma infinita.

class NumESum():
    def __init__(self, iterations: int):
        self.iterations = iterations
    
    def __iter__(self):
        self.fact = 1
        self.sum = 0
        if self.iterations <= 0:
           self.iterations = -1 
        self.k = 1
        return self

    def __next__(self):
        self.sum+=self.k**2/(2*self.fact) # sum(k^2/(2*k!)) from k = 1 to ∞
        if self.k > self.iterations:
            raise StopIteration
        else:
            self.k += 1
            self.fact=self.fact*self.k
            return self.sum

if __name__ == "__main__":
    for element in NumESum(100): # Ejecutar el algoritmo con 100 interacciones.
        print(element)

Edgar

student•

Una forma de aplicar la función que el profesor explica con el while infinito es hacer una llamada recursiva a la misma función siempre que no tengamos un error al intentar next().

def loop_iterador(iterador):
    iterador = iter(iterador)
    try:
        print(next(iterador))
    except StopIteration:
        print('Fin de los elementos del iterador')
    else:
        return loop_iterador(iterador)

David Campos

student•

Los iteradores son todos aquellos elementos que podemos recorrer en un ciclo. Por ejemplo, una lista, un string o un diccionario.

Cuando se hace un ciclo, Python internamente no está recorriendo a ese iterable, es decir, el for no funciona directamente como lo vemos en la pantalla, sino que ese iterable se convierte a un objeto especial llamado Iterador. Y es este el que recorre el objeto.

Lo que hace Python internamente:

# Creando iterador
my_list = [1,2,3,4,5]
my_iter = iter(my_list)

# Iterando
print(next(my_iter))
# Cuando no quedan datos, lavanta la expeción StopIteration

Una forma de iterar en un conjunto muy grande:

Un ciclo for no es más que azúcar sintáctica de este proceso. El ciclo for realmente es solo un alias de una iteración.

my_list = [1,2,3,4,5]
my_iter = iter(my_list)

while True:
	try:
		element = next(my_iter)
		print(element)
	except StopIteration:
		break

Construir iterador

El protocolo de los iteradores nos dice que para construir un iterador se necesita una clase que contenga dos métodos: el método iter y el método next .

class EvenNumbers:
    """Clase que implementa un iterador
    de todos los números pares o los números
    pares hasta un máximo"""

    def __init__(self, max = None) -> None:
        self.max = max

    def __iter__(self):
        self.num = 0
        return self

    def __next__(self):
        if not self.max or self.num <= self.max:
            result = self.num
            self.num += 2
            return result
        else:
            raise StopIteration

El método iter sirve para tener elementos o atributos que se van a necesitar para que el iterador funcione. En este caso, el único atributo necesario son cada uno de los números de esa iteración. Se le asigna el valor inicial de 0 y se retorna al objeto en sí mismo.

El método next es el que se necesita para tener la función next en Python. Este método permite extraer cada uno de los elementos de iterador. En este caso se coloca la condición "si no se definió un self.max (limite) o el número que se está por recorrer es menor o igual a self.max, se le asigna a la variable result el número de la iteración (self.num). Después se le suma dos a self.num y se retorna. Si la condición se cumple se levanta la excepción Stop Iteration".

Ventajas de usar iteradores

Ahorra espacio al poder almacenar secuencias matemáticas infinitas de forma teórica.
Ocupan poca memoria.

Gary Torres Martínez

student•

Una duda, ¿Usar dunder en esos métodos es para evitar el llamado explícito del mismo y que ellos sean ejecutados con solo instanciar un objeto?

Yair Hernández

student•

Aunque en general no es buena práctica llamarlos explícitamente, Python no te impide llamar explícitamente un método con dunder.

En el ejemplo de la clase EvenNumbers, los tres métodos con dunder que se utilizan (__init__, __iter__, __next__) pertenecen a lo que en la documentación de Python llaman métodos especiales. Estos permiten personalizar métodos u operaciones al definir una clase.

Recuerda que si tienes un objeto, puedes convertirlo en iterador usando iter(mi_objeto); al inicio de esta clase se pone como ejemplo

my_list = [1,2,3,4,5]
my_iter = iter(my_list)

Sin embargo, no cualquier objeto se puede convertir en iterador:

>>> class MiClase:
...     pass
... 
>>> instancia = MiClase()
>>> iter(instancia)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'MiClase' object is not iterable

En el caso de la clase EvenNumbers, sí podemos hacerlo porque hemos definido un método __iter__:

>>> otra_instancia = EvenNumbers(4)
>>> iterador = iter(otra_instancia)

En la segunda línea, el intérprete de Python verifica si el objeto otra_instancia tiene un método exactamente con el nombre __iter__, y lo invoca. Del mismo modo, cuando utilizamos next, el intérprete verifica que se haya definido un método llamado (exactamente como) __next__ y lo invoca:

>>> next(iterador)
0
>>> next(iterador)
2

Retomando la parte que mencionaba anteriormente sobre que Python no impide invocar un método con dunder, podrás ver que hacerlo te da el mismo resultado:

>>> otra_instancia2 = EvenNumbers(6)
>>> iterador2 = otra_instancia2.__iter__()
>>> iterador2.__next__()
0
>>> iterador2.__next__()
2

Cesar Hernández Ramírez

student•

Increíble explicación @yhdz

Mateo Gonzales Navarrete

student•

Por lo que veo en los comentarios, hay un gran asombro por lo explicado respecto a que el ciclo for no es más que un alias para un while más complejo. Sin embargo, a pesar de ser una buena explicación como método pedagógico, se encuentra lejos de la realidad. De hecho, claro que existen los ciclos for en Python y no son azúcar sintáctica para un while del mismo lenguaje. En Python, los ciclos for son transpilados a lenguaje C (cosa que no ocurre con los ciclos while), por lo que son mucho más eficientes que un ciclo while. Una explicación simple puede ser encontrada en este video de Youtube. Y pueden probar el siguiente código en sus máquinas, viendo que el ciclo for es bastante más rápido que el while (implicando que no puede ser solo azúcar sintáctica).

# for.py
from timeit import default_timer as timer
from datetime import timedelta


def main():
    start = timer()
    for i in range(100000000):
        pass
    end = timer()
    print(timedelta(seconds=end - start))


if __name__ == "__main__":
    main()

# while_iter.py
from timeit import default_timer as timer
from datetime import timedelta

start = timer()


def main():
    my_list = range(100000000)
    my_iter = iter(my_list)

    start = timer()
    while True:
        try:
            element = next(my_iter)
        except StopIteration:
            break
    end = timer()
    print(timedelta(seconds=end - start))


if __name__ == "__main__":
    main()

# while.py
from timeit import default_timer as timer
from datetime import timedelta

start = timer()


def main():
    start = timer()
    i = 0
    while i < 100000000:
        i += 1
    end = timer()
    print(timedelta(seconds=end - start))


if __name__ == "__main__":
    main()

David Zhou Yang

student•

Muy interesante! Gracias por el aporte

David Pedroza Segoviano

student•

TSSSSSSSAAAAAAAAAAALAAAAAA que no existen los for jajajajaja 🤯🤯🤯

Gabriel Missael Barco

student•

JAJAJAJAJAJAJ hola panita, justo así me quedé 🤡🤡🤡🤡