What is the difference between Iterator and "Lazy Iterator" in Python?

In Python, an iterator is an object that enables you to iterate over a sequence of values, such as a list or tuple. It works by implementing two methods: __iter__() and __next__(). The __iter__() method returns the iterator object itself, while the __next__() method returns the next value in the sequence. When there are no more values ​​to return, it raises a StopIteration exception.

Standard custom iterator:

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)

In Python, iter() is a built-in function that returns an iterator for a given iterable object.

An iterable object is any object that can be iterated over, such as a list, tuple, set, dictionary, or a custom object that defines the __iter__() method.

When iter() is called on an iterable object, it returns an iterator object that uses the next() method to provide a sequence of values ​​from the iterable object one at a time.

The iter() function is often used with loops and other iterators to perform tasks such as filtering, mapping, and reducing the elements of a sequence.

Iterator created with the iter() function:

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

lazy iterator:

A "lazy iterator" is a special type of iterator that does not Generates all values ​​in the sequence. Instead, it generates them when needed. This is useful when dealing with very large or infinite sequences, as it avoids generating all the values ​​at once and consuming a lot of memory.

In Python, lazy iterators are often implemented using generator functions (Generators are functions that use the yield keyword ), returning one value at a time. Each time a value is requested, the generator picks up where it left off and produces the next value in the sequence.

# 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))

The above is the detailed content of What is the difference between Iterator and "Lazy Iterator" in Python?. For more information, please follow other related articles on the PHP Chinese website!