Python StopIteration – Tutorial with Examples

In Python, StopIteration is an exception that is raised to signal the end of an iterator. When a generator or similar iterator has no more values to yield, it raises this exception to indicate that it’s done iterating.

In this tutorial, we’ll go over what StopIteration is, when it is raised, and how to handle it. We’ll also take a look at some examples to help illustrate what we’re talking about.

Stopping an Iterator in Python

Iterator is an abstraction that is used to iterate over a sequence of values without exposing the underlying data structure. An iterator in Python is an object that produces a sequence of values. It has two standard methods:

• __iter__(): returns the iterator object itself.
• __next__(): returns the next value from the iterator.

The StopIteration exception is raised when the __next__() method is called but there are no more items to yield. It is a signal that the iteration has completed.

Handling StopIteration Exceptions

Because StopIteration is an exception, it can be caught and handled using a try-except block:

iterator = iter([1, 2, 3])

try:
    while True:
        print(next(iterator))
except StopIteration:
    pass

In this example, we’re iterating over a list of integers using the built-in iter() function to create an iterator. We then enter a while loop and attempt to print the next value from the iterator using the built-in next() function. If there are no more values to return, next() will raise a StopIteration exception.

We catch this exception using a try-except block, and simply pass when we receive one. This ensures that our loop exits cleanly when all of the values have been consumed.

Using Generators to Stop Iteration

In Python, iterators are often implemented using generators. Generators are a type of iterator that are defined using a special syntax. They are functions that use the yield keyword instead of a return statement to produce a sequence of values.

Here’s how we can define a generator function that returns a sequence of integers:

def integer_sequence():
    i = 0
    while True:
        yield i
        i += 1

Notice that we’ve used the yield keyword instead of a return statement. This tells Python that this function is a generator. The yield keyword generates a value and suspends the function’s execution state, allowing the function to be resumed later if necessary.

We can use this generator to produce a sequence of integers:

gen = integer_sequence()

print(next(gen)) #prints 0
print(next(gen)) #prints 1
print(next(gen)) #prints 2

When we call next(gen), it invokes the generator function integer_sequence() and runs it until it hits the first yield statement. It then returns the value produced by the yield statement and suspends the function’s execution state.

When we call next(gen) again, it picks up where it left off and runs until it hits the next yield statement. This process continues until there are no more yield statements to run, at which point a StopIteration exception is raised.

Here’s an example that uses a generator to produce a sequence of Fibonacci numbers:

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

We can use this generator to produce a sequence of Fibonacci numbers:

gen = fibonacci_sequence()

print(next(gen)) #prints 0
print(next(gen)) #prints 1
print(next(gen)) #prints 1
print(next(gen)) #prints 2
print(next(gen)) #prints 3
print(next(gen)) #prints 5

As you can see, the generator produces a sequence of Fibonacci numbers each time we call next(gen).

Using a for Loop with StopIteration

One of the easiest ways to iterate over an iterator in Python is to use a for loop. A for loop will automatically catch the StopIteration exception and exit the loop cleanly without raising an exception.

Here’s an example that uses a for loop to iterate over a list of integers:

numbers = [1, 2, 3]

for number in numbers:
    print(number)

We don’t have to worry about explicitly catching the StopIteration exception in this case, since the for loop will handle it for us automatically.

We can also use a for loop to iterate over a generator:

def generate_numbers(start, end):
    for number in range(start, end):
        yield number

for number in generate_numbers(1, 4):
    print(number)

This code defines a generator function that produces a sequence of numbers between a start and end value. We can then use a for loop to iterate over this generator function and print each number using the print() function.

Conclusion

The StopIteration exception is used to signal that an iterator has reached the end of the sequence of values it is producing. This exception is raised automatically by the built-in next() function when it has no more values to return.

When working with iterators in Python, it’s important to remember to catch the StopIteration exception and exit cleanly when there are no more values to return. This can be done using a try-except block or a for loop, depending on your use case.