Iterators and generators

Iterators and generators are two essential concepts in Python that are used heavily in various programming tasks. These concepts provide powerful functionalities that can simplify complex tasks, and make the code more efficient and readable. In this article, we will discuss iterators and generators, their differences, and how to use them in Python.

Iterators
Iterators are objects that allow a loop to fetch the next value in a sequence. They are used in Python to iterate over a sequence, be it a list, tuple, or any other iterable. An iterator works by implementing two methods: iter() and next(). The iter() method returns the iterator object itself, while the next() method returns the next value from the sequence. If there are no more values, it raises the StopIteration exception.

Here's an example of using an iterator to loop over a list of names:

names = ["Adam", "Bob", "Charlie", "David"]
it = iter(names)
while True:
    try:
        name = next(it)
        print(name)
    except StopIteration:
        break

In this example, we create an iterator object from the list of names using the iter() function. We then use the next() function to fetch the next name from the sequence until there are no more names left.

Generators
Generators, on the other hand, are functions that return an iterator. Unlike regular functions that return all the values at once, generators yield one value at a time. This makes them much more efficient when working with large datasets. Generators are created using the yield keyword instead of the return keyword. When a yield statement is encountered, the function's state is saved, and the value is returned to the caller. The next time the function is called, it resumes from where it left off.

Here's an example of using a generator to generate Fibonacci numbers:

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

fib = fibonacci()
for i in range(10):
    print(next(fib))

In this example, we define a generator function that generates Fibonacci numbers indefinitely. We create a generator object from the function using the fibonacci() function, and then use the next() function to fetch the next value from the sequence. We loop over the first ten Fibonacci numbers and print them out.

Differences between Iterators and Generators
While both iterators and generators are used for iterating over sequences, there are some key differences between them. Here are some of the differences:

• Iterators are defined as objects that implement the iter() and next() methods, while generators are defined as functions that use the yield keyword to return values one at a time.
• Iterators can be created from any iterable, while generators are specific to functions that use the yield keyword.
• Iterators must be manually iterated over using a loop and the next() function, while generators can be iterated over automatically using a for loop.

Conclusion
Iterators and generators are powerful concepts in Python that are used extensively in various programming tasks. While they are both used for iterating over sequences, they differ in their implementation and usage. Knowing the differences between iterators and generators can help you choose the best approach for your specific use case.

Links

イテレータとジェネレータ[JA]