Quelle est la différence entre Iterator et « Lazy Iterator » en Python ?

En Python, un itérateur est un objet qui vous permet de parcourir une séquence de valeurs, comme une liste ou un tuple. Il fonctionne en implémentant deux méthodes : __iter__() et __next__(). La méthode __iter__() renvoie l'objet itérateur lui-même, tandis que la méthode __next__() renvoie la valeur suivante dans la séquence. Lorsqu'il n'y a plus de valeurs à renvoyer, une exception StopIteration est déclenchée.

Itérateur personnalisé standard :

class Squares:
    def __init__(self, n):
        self.n = n
        self.current = 0
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.current >= self.n:
            raise StopIteration
        else:
            result = self.current ** 2
            self.current += 1
            return result
 
# Using the iterator
squares = Squares(5)
for square in squares:
    print(square)

En Python, iter() est une fonction intégrée qui renvoie un itérateur pour un objet itérable donné.

Un objet itérable est tout objet qui peut être bouclé, tel qu'une liste, un tuple, un ensemble, un dictionnaire ou un objet personnalisé qui définit la méthode __iter__().

Lorsque iter() est appelé sur un objet itérable, il renvoie un objet itérateur en utilisant la méthode next() pour fournir une séquence de valeurs de l'objet itérable une à la fois. La fonction

iter() est souvent utilisée avec des boucles et autres itérateurs pour effectuer des tâches telles que le filtrage, le mappage et la réduction des éléments d'une séquence.

Itérateurs créés avec la fonction iter() :

numbers = [1, 2, 3, 4, 5]
iterator = iter(numbers)
 
print(next(iterator))  # Output: 1
print(next(iterator))  # Output: 2
print(next(iterator))  # Output: 3

itérateur paresseux :

Un "itérateur paresseux" est un type spécial d'itérateur qui ne pré-génére pas toutes les valeurs de la séquence. Au lieu de cela, il les génère en cas de besoin. Ceci est utile lorsqu'il s'agit de séquences très volumineuses ou infinies, car cela évite de générer toutes les valeurs en même temps et de consommer beaucoup de mémoire.

En Python, les itérateurs paresseux sont souvent implémentés à l'aide de fonctions génératrices (Un générateur est une fonction qui utilise le mot-clé rendement ), renvoyant une valeur à la fois. Chaque fois qu'une valeur est demandée, le générateur reprend là où il s'est arrêté et produit la valeur suivante dans la séquence.

# Define a generator function that yields values lazily
def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b
 
# Use the lazy iterator to print the first 10 Fibonacci numbers
fib = fibonacci()
for i in range(10):
    print(next(fib))

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!