Iterables

ITERABLES
Un iterable se define como el objeto que contiene un número contable con valores y este al tener un valor puede recorrer uno a uno los elementos que la contienen como una estructura de datos y operar con ellos, pero a la vez se rigen bajo la instrucción que se le es dada, con lo cual son dependientes de la instrucción a recibir.

Los metodos de su uso son dos __iter__() y __next__() .

Veamos un ejemplo:

Tenemos una serie de frutas las cuales debemos recorrer una a una para saber cuales son las que están dentro de la lista.

fruit = ("manzana", 'pera', 'banano')
myit = iter(fruit)

print(next(myit))
print(next(myit))
print(next(myit))

Ahora vamos a imprimir el resultado una a una con print(next(myit)), con esto controlamos un iterador por print

print(next(myit))
_Producción:_
manzana

print(next(myit))
print(next(myit))
_Producción:_
manzana
pera

print(next(myit))
print(next(myit))
print(next(myit))
_Producción:_
manzana
pera
banano

También podemos utilizar los iterables como una cadena de texto que recorre un texto o una serie de números.

fruit = ("manzana")
myit = iter(fruit)

print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))

_Producción:_
m
a
n
z
a
n
a

Otra forma de realizar un iterador es atraves de for() o un bucle, para ello realizaremos el siguiente ejemplo:

cars = ('chevrolet', 'volvo', 'audi', 'mazda') 
for x in cars:
  print(x)

_Produccion:_
chevrolet
volvo
audi
mazda

Con el iterador también podemos crear una secuencia de números hasta cierto valor que le determinemos.

class MyNumbers:
   def __iter__(self):
     self.a = 1
     return self

   def __next__(self):
     x = self.a
     self.a += 1
     return x

myclass = MyNumbers()
myiter = iter(myclass)

print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))

_Producción:_
1
2
3
4
5

Ahora si queremos que la iteración se detenga en un valor determinador podemos utilizar la declaración StopIteration

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self

  def __next__(self):
    if self.a <= 10:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration

myclass = MyNumbers()
myiter = iter(myclass)

for x in myiter:
  print(x)

_Producción:_
1
2
3
4
5
6
7
8
9
10

iter() nos permite controlar la forma en que se ejecutar un iterador, esto nos ayuda a no ocupar tanta memoria

<aside>
⚠️ Si vamos mas alla del rango dado se va a generar un error con el StopIteration

</aside>

for i in range(1, 10):
  print(i)

my_iter = iter(range(1, 4))
print(my_iter)
print(next(my_iter))
print(next(my_iter))
print(next(my_iter))
print(next(my_iter))

Un ciclo for no es mas que azucar sintactica ya que internamente lo que hace es in ciclo while True hasta llegar a StopIteration

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

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

Resultado:

1
2
3
4
5

Ciclo for:

my_list = [1, 2 ,3 ,4, 5]
for item in my_list:
  print(item)

Resultado:

1
2
3
4
5

Iterables

• Crear un iterador es muy sencillo. Si por ejemplo lo queremos hacer sobre una lista de 4 números, instanciamos un objeto de tipo iter() que recibirá por parámetro la lista.

• Para recorrerlo utilizaremos next(). Esta función recibe por parámetro nuestro iterador y cada vez que se ejecuta, incrementa el número de la posición en la que la iteración se encuentra. Por ejemplo, si es la primera vez que se ejecuta, estará en la posición inicial, la segunda vez se habrá incrementado en 1 y así sucesivamente hasta llegar al final de la iteración:

my_iter = iter(range(0, 21))
print(next(my_iter))
print(next(my_iter))
print(next(my_iter))
print(next(my_iter))

Iterable vs Iterador
El iterable es el contenedor que podemos iterar, este puede ser una estructura de datos como lo son las tuplas, los diccionarios, sets, listas y hasta las cadenas de texto.
Mientra que el iterador es el objeto con el que se puede iterar, es decir recorrer todos los elementos. Por eso se define con ayuda de la funcion iter().

my_iter = iter(range(1, 11))
print(my_iter)
print(next(my_iter))
print(next(my_iter))
print(next(my_iter))

<range_iterator object at 0x7f67c3aa0e10>
1
2
3

Iterables

#----- iteraciones ------

# iterador range
for i in range(1,11):
  print(i)
--> 1
		2
		3
		4
		5
		6
		7
		8
		9
		10

# iterador que aun no ha sido detectado como tal
my_iter = range(1, 11)
print(my_iter)
--> range(1, 11)

# iterador detectado como tal
my_iter2 = iter(range(1,11))
print(my_iter2)
--> <range_iterator object at 0x7fe27d22f900>

# controlar al iterador de forma manual con next
print(next(my_iter2))
print(next(my_iter2))
print(next(my_iter2))
--> 1
		2
		3

# iteracion manual que alcanza el limite del iterador
my_iter3 = iter(range(1,4))
print(next(my_iter3))
print(next(my_iter3))
print(next(my_iter3))
print(next(my_iter3))
--> 1
		2
		3
		Traceback (most recent call last):
		  File "20_iter.py", line 25, in <module>
		    print(next(my_iter3))
		StopIteration

Después de indagar en este tema de iterables en la documentación de Python, siguen los generadores, que sería genial que lo explicasen en algún otro curso, ya que son muy útiles al momento de programar en Python. Acá pueden checar más a detalle Generadores!

ITERADOR

Un iterador es un un objeto que contiene un numero contable de valores. Se refiere a un objeto que se puede iterar, lo que significa que puede recorrer todos los valores.
Técnicamente, en Python, un iterador es un objeto que implementa el protocolo iterador, que consta de los métodos __iter__() y __next__()

ITERABLE
Las listas, las tuplas, los diccionarios y los conjuntos son todos objetos iterables. Son contenedores iterables de los que puede obtener un iterador.

Todos estos objetos tienen un método iter() que se usa para obtener un iterador

muchas gracias por explicar el motivo de porque estamos viendo como iterar manualmente! de por si uno le puede ver usos, pero queda la pregunta de “porque haria esto manual?” y con su explicacion ya uno le pone aun mas atención 😃

Un iterable en Python es un objeto que se puede recorrer o iterar. En otras palabras, es un objeto que se puede pasar al método iter() para obtener un iterador1. Un iterador es un objeto que se utiliza para recorrer un iterable utilizando el método next()1. Los iteradores tienen un método next(), que devuelve el siguiente elemento del objeto1. Es importante tener en cuenta que todos los iteradores también son iterables, pero no todos los iterables son iteradores1.

Por ejemplo, una lista es un iterable, pero no es un iterador. Sin embargo, se puede crear un iterador a partir de una lista utilizando la función iter()1. Para que esto sea posible, la clase de un objeto necesita tener un método iter(), que devuelve un iterador, o un método getitem() con índices secuenciales que comienzan en 01.

Aquí tienes un ejemplo de código que muestra cómo determinar si un objeto es iterable en Python:

def es_iterable(obj):
try:
iter(obj)
return True
except TypeError:
return False

elementos = [34, [4, 5], (4, 5), {“a”: 4}, “dfsdf”, 4.5]

for elemento in elementos:
print(elemento, “es iterable:”, es_iterable(elemento))
Copiar
Salida:

34 es iterable: False
[4, 5] es iterable: True
(4, 5) es iterable: True
{“a”: 4} es iterable: True
dfsdf es iterable: True
4.5 es iterable: False
Copiar
Espero que esta explicación te ayude a comprender qué son los iterables y los iteradores en Python

entonces todo son iteradores!

¿Qué es un iterable?
Un iterable en Python es un objeto que implementa el método iter() o el getitem(). Esto métodos permiten al objeto ser recogido o iterado, lo que significa que puedes obtener sus elementos uno por uno en una secuencia.

Tipos de iterables
En Python, muchos tipos de datos son iterables por naturaleza. Algunos ejemplos comunes de iterables son:

• Listas (list)

• Tupas (tuple)

• Conjuntos(set)

• Diccionarios (dict)

• Cadenas de texto(str)

• Rangos(range)

• Archivos abiertos(open())

• iteradores (iter())

El uso de la función iter() y la implementación de iteradores en Python tiene varias ventajas:

Eficiencia de memoria: Los iteradores permiten la generación perezosa (lazy evaluation) de elementos. Esto significa que los elementos se generan solo cuando se solicitan, lo que puede ser más eficiente en términos de memoria, especialmente cuando se trabaja con grandes conjuntos de datos.

Eficiencia de tiempo: Al generar elementos solo cuando se necesitan, los iteradores pueden ser más eficientes en términos de tiempo de ejecución, especialmente en situaciones en las que no es necesario procesar todos los elementos a la vez.

Compatibilidad con bucles for: Los iteradores son compatibles con la sintaxis de los bucles for en Python, lo que facilita la iteración sobre elementos de manera clara y concisa.

Manejo de secuencias infinitas: Los iteradores permiten representar y trabajar con secuencias infinitas de manera efectiva. Puedes generar elementos bajo demanda sin la necesidad de almacenar toda la secuencia en memoria.

Interoperabilidad: Muchas funciones y construcciones en Python están diseñadas para trabajar con iteradores. El uso de iteradores facilita la interoperabilidad con diversas bibliotecas y módulos que siguen el paradigma de iteración.

Encapsulamiento: Los iteradores permiten encapsular la lógica de generación de elementos dentro de una clase, lo que facilita la creación de interfaces más limpias y modularización del código.

En general, el uso de iteradores en Python promueve un código más limpio, eficiente y fácil de mantener, especialmente en situaciones en las que se trabaja con grandes conjuntos de datos o secuencias infinitas.

Me gusto la forma de usar el iterador. No pense que tuviera ese uso al momento de ejecutarlo.

Objeto de la iteración :

my_iter1 = iter(range(1,11)) 
print(my_iter1) # object at 0x7f8eae65b600>

Listar la iteración :

my_iter2 = list(iter(range(1,11)))
print(my_iter2) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Listar el rango :

my_iter3 = list(range(1,11))
print(my_iter3) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

iteración manual :

my_iter4 = iter(range(1,4)) 
print(next(my_iter4)) # 1
print(next(my_iter4)) # 2
print(next(my_iter4)) # 3
print(next(my_iter4)) # print(next(my_iter4)) StopIterationpython

Bucle for convencional:

pythonCopy code
# Usando un bucle for para imprimir números del 1 al 9
for i in range(1, 10):
    print(i)

Este código crea una lista de números del 1 al 9 en la memoria y luego los imprime uno por uno.

Iterador:

pythonCopy code
# Creando un iterador para los números del 1 al 3
my_iter = iter(range(1, 4))

# Utilizando el iterador para obtener y imprimir números uno por uno
print(next(my_iter))  # Imprime 1
print(next(my_iter))  # Imprime 2
print(next(my_iter))  # Imprime 3

En este ejemplo, creamos un iterador llamado my_iter para los números del 1 al 3. Luego, utilizamos next(my_iter) para obtener y imprimir cada número uno por uno.

La diferencia clave es que el bucle for convencional crea una lista completa de números en la memoria, mientras que el iterador solo recuerda el número actual, lo que ahorra memoria cuando trabajamos con secuencias largas. Esto es útil cuando necesitas iterar sobre una secuencia grande de números sin consumir una gran cantidad de memoria.

Genial!! No conocía esto

📌ITERALES

“En resumen, en Python, un objeto iterable es aquel que se puede recorrer en una secuencia. Para ser iterable, el objeto debe implementar el método especial iter(), el cual devuelve un iterador. Un iterador es un objeto que mantiene el estado actual de la iteración y proporciona el siguiente elemento cuando se le solicita a través del método especial next(). Cada llamada a next() devuelve el siguiente elemento en la secuencia hasta que se llega al final, momento en el que se genera una excepción StopIteration. En pocas palabras, los iterables permiten recorrer una secuencia de elementos de manera ordenada.”

**EJEMPLO BÁSICO**👇🏻👇🏻

my_list = [1, 2, 3, 4, 5]  # Una lista como iterable

# Iterando sobre la lista utilizando un bucle for
for item in my_list:
    print(item)

# Creando un iterador manualmente
my_iterator = iter(my_list)
print(next(my_iterator))  # Imprime 1
print(next(my_iterator))  # Imprime 2
print(next(my_iterator))  # Imprime 3

Ejemplo utilizandolo para iterar en el contenido de una lista seteando el limite del rango con el metodo len()

monedas = ['btc', 'eth', 'sol', 'xrp']
length = len(monedas)
token_iteration = iter(range(length))

count = 0
while count <= length-1:
  print(monedas[next(token_iteration)])
  count += 1

OUTPUT:
btc
eth
sol
xrp

Revisando documentación algo interesante del StopItetion también podemos usarlo para parar una condición

  def __next__(self):
    if self.a <= 10:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration

for i in range(1,10):
  print(i)

my_iter = iter(range(1,4))
print(my_iter)
print(next(my_iter))
print(next(my_iter))
print(next(my_iter))
print(next(my_iter))

Hace iunas clases encontré try/except

for i in range(1, 10):
  print(i)

my_iter = iter(range(1, 4))

try:
    print(my_iter)
    print(next(my_iter))
    print(next(my_iter))
    print(next(my_iter))
    print(next(my_iter))
except:
   print('la iteración alcanzó su límite')

Las iteraciones en Python se refieren al proceso de repetir un conjunto de instrucciones un determinado número de veces o hasta que se cumpla una condición específica. En Python, esto se logra utilizando estructuras de control de flujo como los bucles “for” y “while”.

Diferencia entre un iterable y lista

• Una lista es un tipo de objeto que puede contener una colección ordenada de elementos.
• Un iterable es un objeto que se puede recorrer y del cual se pueden obtener sus elementos uno a uno en un orden definido.

La diferencia principal entre una lista y un iterable es que una lista es un tipo específico de objeto que contiene elementos, mientras que un iterable es una interfaz genérica que puede aplicarse a diferentes tipos de objetos.
En resumen, una lista es un tipo específico de iterable que se utiliza para almacenar una colección de elementos en un orden determinado.

interesante lo de los iterables

Hola

Les comparto el código de la clase.

# Iterables
# https://www.w3schools.com/python/python_iterators.asp

for i in range(1, 11):
  print(i)

my_iterable = iter(range(1, 4))
print(my_iterable)
# Iterando manualmente
# De esta manera optimizamos el rendimiento, porque el rango completo no se genera directamente, sino que lo genera progresivamente, lo que hace que el recurso en memoria no sea tan alto.
print(next(my_iterable))
print(next(my_iterable))
print(next(my_iterable))
# Cuando genero una iteracion que sobrepase el rango me genera la excepcion StopIteration
print(next(my_iterable))

Estoy teniendo problemas con Replit, alguien mas? No me esta dejando ejecutar ningun programa: “/home/runner//venv/bin/python: line 3: exec: : not found replit”

for i in range(1,10):
    print(i)
    
my_iterador=range(1,11)
#Aun no se puede iterar el for lo hace 
print(my_iterador)

my_iterador1=iter(range(1,11))
#Le hacemos casting a lista y nos saldra en lista
print(my_iterador1)
#Este iter, lo podemos contralar de manera manual
#Como es un iterador, puedo iterar manualmente con
#la palabra next

#Manualmente lo itera, genera progresivamente
#Para ahorrar la memoria
print(next(my_iterador1))
print(next(my_iterador1))
print(next(my_iterador1))
print(next(my_iterador1))

fruit = ("manzana", 'pera', 'banano')
myit = iter(fruit)

print(next(myit))
print(next(myit))
print(next(myit))

fruit = ("manzana")
myit = iter(fruit)

print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))

my_iter = iter(range(1,4))

print(next(my_iter)) #1
print(next(my_iter)) #2
print(next(my_iter)) #3
print(next(my_iter)) # StopIteration
#En archivos, podemos leer de esta manera
#leyendo por lineas y no completamente un archivo

#Si vas a mas del rango, saldra una excepcion

my_iter = iter(range(1,4))

print(next(my_iter)) #1
print(next(my_iter)) #2
print(next(my_iter)) #3
print(next(my_iter)) # StopIteration

for i in range(1, 10):
  print(i)

my_iter = iter(range(1,4))
print(my_iter)
print(next(my_iter))
print(next(my_iter))
print(next(my_iter))