3.2.2. Iterator Protocol

An iterator is an object that represents a stream of data; it returns one element at a time when asked. Python’s iterator protocol is a standard interface for these objects.

An iterator in Python is a special kind of object that lets you traverse through a collection of items and access one item at a time. Instead of providing all items at once, an iterator gives each item only when you specifically ask for it, making it efficient in terms of memory usage. The iterator protocol is simply a way of implementing this functionality in Python using a set of defined methods.

Imagine a library where you can only read one book at a time. Instead of carrying all the books out, you ask the librarian for the next book, and they give it to you one by one. This is similar to how an iterator works, providing one piece of data at a time.

An object is an iterator if it implements two methods: ● iter() — Returns the iterator object itself. ● next() — Returns the next item in the sequence. Raises StopIteration when no more items exist.

To qualify as an iterator, an object must implement two specific methods. The __iter__() method returns the iterator object itself, which is a requirement for iterating over the object. The __next__() method is crucial because it retrieves the next item in the sequence each time it is called. If there are no more items to return, it raises a StopIteration exception to signal that the iteration is complete.

Think of an iterator like a vending machine. When you press a button (call __next__()), it gives you the next snack (item) available. If you keep pressing the buttons after the last snack has been dispensed, it alerts you that there are no more snacks left (raises StopIteration).

Example: Custom Iterator

class CountDown:
    def __init__(self, start):
        self.current = start
    def __iter__(self):
        return self
    def __next__(self):
        if self.current <= 0:
            raise StopIteration
        else:
            self.current -= 1
            return self.current + 1

cd = CountDown(3)
for number in cd:
    print(number)

Output: 3 2 1

The custom iterator CountDown demonstrates how you can create your own iterator in Python. It starts counting down from a specified number. When you create an instance of CountDown, you initialize it with a starting number. The __iter__() method returns the iterator object itself, while the __next__() method decreases the current number and returns it. Once the countdown reaches zero, it raises StopIteration to indicate that the sequence has ended.

Consider a countdown timer for a race. Each second, the timer ticks down (the number decreases), and when it reaches zero, the race is over (no more numbers to show). This countdown timer is like our custom iterator, providing each second (item) until it hits zero.

Key Points: ● for loops internally call iter() to get an iterator. ● The loop repeatedly calls next() until StopIteration is raised. ● Iterators maintain internal state to produce the next element.

When you use a for loop in Python, it automatically calls the iter() function on the iterable object to get an iterator. The loop continues to call the next() function to retrieve each element until it reaches the end. At that point, the StopIteration exception is raised to stop the loop. Moreover, iterators have an internal state that keeps track of the current position in the sequence, allowing them to return the next element correctly each time.

Think of a person reading a book. They start at the first page (initial state) and turn one page at a time (calling next()). Once they reach the end of the book, they can’t turn any more pages (StopIteration). Their knowledge of where they are in the book is like an iterator maintaining its internal state.

--