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.
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
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
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
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
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.