Introducci贸n a los iteradores de Python

    驴Qu茅 son los iteradores?

    Un iterador en Python se refiere a un objeto sobre el que podemos iterar. El iterador consta de valores contables y es posible recorrer estos valores, uno por uno.

    El iterador simplemente implementa el protocolo de iterador de Python. El protocolo iterador es una clase Python que viene con dos m茅todos especiales, a saber __iter__() y __next__(). Con estos dos m茅todos, el iterador puede calcular el siguiente valor en la iteraci贸n.

    Con los iteradores, es f谩cil para nosotros trabajar con secuencias de elementos en Python. No tenemos que asignar recursos inform谩ticos a todos los elementos de la secuencia, sino que iteramos sobre un solo elemento a la vez, lo que nos ayuda a ahorrar espacio en la memoria.

    En este art铆culo, estudiaremos c贸mo trabajar con iteradores en Python.

    Objetos iterables en Python

    Un iterable es un objeto capaz de devolver un iterador. Un iterable puede representar fuentes de datos tanto finitas como infinitas. El iterable implementa directa o indirectamente los dos m茅todos: __iter__() y __next__(). los __iter__() El m茅todo devuelve el objeto iterador mientras que el __next__() El m茅todo nos ayuda a atravesar los elementos del objeto iterable.

    Los ejemplos de objetos iterables en Python incluyen listas, diccionarios, tuplas y conjuntos.

    Creando un iterador

    En Python, creamos un iterador implementando el __iter__() y __next__() m茅todos en el objeto. Considere el siguiente ejemplo:

    class IterationExample:
        def __iter__(self):
            self.x = 0
            return self
    
        def __next__(self):
            y = self.x
            self.x += 1
            return y
    
    classinstance = IterationExample()
    element = iter(classinstance)
    

    Hemos creado un iterador llamado element que imprime n煤meros del 0 al N. Primero creamos una instancia de la clase y le dimos el nombre classinstance. Luego llamamos al iter() m茅todo incorporado y pas贸 el nombre de la instancia de clase como par谩metro. Esto crea el objeto iterador.

    Analicemos ahora c贸mo usar un iterador para iterar realmente a trav茅s de los elementos.

    Iterando a trav茅s de un iterador

    los next() El m茅todo nos ayuda a recorrer los elementos de un iterador. Demostremos esto con el ejemplo anterior:

    class IterationExample:
        def __iter__(self):
            self.x = 0
            return self
    
        def __next__(self):
            y = self.x
            self.x += 1
            return y
    
    classinstance = IterationExample()
    element = iter(classinstance)
    
    print(next(element))
    print(next(element))
    print(next(element))
    print(next(element))
    print(next(element))
    print(next(element))
    print(next(element))
    print(next(element))
    print(next(element))
    print(next(element))
    

    Salida

    0
    1
    2
    3
    4
    5
    6
    7
    8
    9
    

    En el gui贸n anterior, llamamos al next() y pas贸 el nombre del elemento iterador al m茅todo como par谩metro. Cada vez que hacemos esto, el iterador pasa al siguiente elemento de la secuencia. Aqu铆 hay otro ejemplo:

    # create a list
    list1 = [0, 5, 10, 15]
    
    # create an iterator
    element = iter(list1)
    
    ## use next() to traverse/iterate through the list elements
    
    # prints first element, 0
    print(next(element))
    
    # prints second element, 5
    print(next(element))
    
    ## next(element) is similar to element.__next__()
    
    # prints third element, 10
    print(element.__next__())
    
    # prints fourth element, 15
    print(element.__next__())
    

    Salida

    0
    5
    10
    15
    

    En el script anterior, creamos una lista llamada list1, que tiene 4 enteros. Un iterador llamado element Ha sido creado. los next() El m茅todo nos ha ayudado a recorrer los elementos de la lista.

    Iteraci贸n con el bucle “for”

    los for loop nos ayuda a recorrer cualquier objeto capaz de devolver un iterador. Por ejemplo:

    # create a list
    list1 = [0, 5, 10, 15]
    
    # create an iterator
    element = iter(list1)
    
    # iterate with a for loop
    for x in element:
        print(x)
    

    Salida

    0
    5
    10
    15
    

    En el c贸digo anterior, creamos una variable llamada x, que se usa para iterar a trav茅s del iterador element a trav茅s de for lazo.

    Iteradores infinitos

    Un iterador infinito es un iterador con un n煤mero infinito de iteraciones. Debemos tener mucho cuidado al tratar con iteradores infinitos. Considere el siguiente ejemplo:

    class IterationExample:
        def __iter__(self):
            self.x = 0
            return self
    
        def __next__(self):
            y = self.x
            self.x += 1
            return y
    
    classinstance = IterationExample()
    element = iter(classinstance)
    
    for x in element:
        print(x)
    

    El c贸digo anterior se ejecutar谩 para siempre. Para detenerlo, tendr谩 que intervenir manualmente. Aqu铆 hay otro ejemplo que demuestra c贸mo crear un iterador infinito en Python:

    class Infinite:
        # Print all even numbers
    
        def __iter__(self):
            self.x = 0
            return self
    
        def __next__(self):
            x = self.x
            self.x += 2
            return x
    

    El c贸digo debe devolver todos los n煤meros pares, comenzando desde 0. Podemos ejecutar el c贸digo como se muestra a continuaci贸n:

    >>> y = iter(Infinite())
    >>> next(y)
    0
    >>> next(y)
    2
    >>> next(y)
    4
    >>> next(y)
    6
    >>> next(y)
    8
    >>> next(y)
    10
    >>>
    

    Y la cadena anterior puede continuar para siempre. Esto muestra que con un iterador infinito, podemos tener un n煤mero infinito de elementos sin tener que almacenarlos todos en la memoria.

    En la siguiente secci贸n, veremos c贸mo podemos implementar un mecanismo para salir de esos iteradores infinitos.

    Detener una iteraci贸n

    En la secci贸n anterior, vimos c贸mo crear un iterador infinito en Python. Sin embargo, los iteradores no suelen estar dise帽ados para iteraciones infinitas en Python. Siempre es conveniente implementar una condici贸n de terminaci贸n.

    Podemos evitar que un iterador se ejecute para siempre usando el StopIteration declaraci贸n. Solo necesitamos agregar una condici贸n de terminaci贸n en el __next__() m茅todo que generar谩 un error una vez que se haya alcanzado el n煤mero especificado de iteraciones. Aqu铆 hay un ejemplo:

    class StoppingIteration:
        def __iter__(self):
            self.x = 1
            return self
    
        def __next__(self):
            if self.x <= 5:
                y = self.x
                self.x += 1
                return y
            else:
                raise StopIteration
    
    classinstance = StoppingIteration()
    element = iter(classinstance)
    
    for a in element:
        print(a)
    

    Salida

    1
    2
    3
    4
    5
    

    La ejecuci贸n se detiene despu茅s de 5 iteraciones. Esto se debe a la self.x <= 5: condici贸n agregada dentro del __next__() m茅todo. Si se llama al iterador despu茅s de llegar a 5, aumentar谩 StopIteration evento. Considere el ejemplo que se da a continuaci贸n:

    class StoppingIteration:
        def __init__(self, max = 0):
            self.max = max
    
        def __iter__(self):
            self.x = 1
            return self
    
        def __next__(self):
            if self.x <= self.max:
                val = 3 ** self.x
                self.x += 1
                return val
            else:
                raise StopIteration
    

    Creemos un iterador y luego iteremos a trav茅s de 茅l:

    >>> y = StoppingIteration(3)
    >>> z = iter(y)
    >>> next(z)
    3
    >>> next(z)
    9
    >>> next(z)
    27
    >>> next(z)
    Traceback (most recent call last):
      File "<pyshell#5>", line 1, in <module>
        next(z)
      File "C:Usersadminiteration.py", line 17, in __next__
        raise StopIteration
    StopIteration
    >>>
    

    La condici贸n de terminaci贸n se ha implementado en la siguiente secci贸n de nuestro c贸digo:

    if self.x <= self.max:
        val = 3 ** self.x
    

    Pasamos un valor de 3 al iterador, lo que significa que el iterador no debe iterar m谩s all谩 de 27, es decir, 3 ^ 3.

    Conclusi贸n

    Los iteradores son extremadamente 煤tiles, especialmente si necesita iterar a trav茅s de una gran secuencia de elementos. Los iteradores le permiten recorrer una secuencia de elementos de uno en uno sin tener que cargar todos los elementos en la memoria a la vez.

    En este art铆culo, vimos c贸mo crear iteradores en Python y c贸mo recorrer elementos en un iterador. Tambi茅n vimos c贸mo crear un iterador infinito y c贸mo agregar una condici贸n de terminaci贸n a un iterador infinito.

     

    Etiquetas:

    Deja una respuesta

    Tu direcci贸n de correo electr贸nico no ser谩 publicada. Los campos obligatorios est谩n marcados con *