Python next() Function

Spread the love

The next() function retrieves the next item from an iterator. When used with a loop, it effectively allows the loop to traverse through the items of an iterable. It’s a cornerstone of Python’s iteration abstraction and is intricately linked to the protocol that Python’s loops use to navigate through sequences.


The next() function’s syntax is deceptively simple:

next(iterator[, default])


  • iterator: This is the iterator object which you want to pull the next item from.
  • default: This is an optional value that is returned if the iterator is exhausted (i.e., there is no next item).

Return Value

The next() function returns the next item from the iterator. If the iterator is exhausted and no default value is provided, it raises a StopIteration exception.

Understanding Iterators and Iterables

Before we dive deeper, it’s important to differentiate between iterables and iterators:

  • Iterable: An object that can return an iterator. Examples include lists, tuples, strings, and more.
  • Iterator: An object that is used to iterate over an iterable. It keeps the state and produces the next value when next() is called on it.

To get an iterator from an iterable, the iter() function is used.

Using next() with Built-in Iterators


my_list = [1, 2, 3]
my_list_iter = iter(my_list)
print(next(my_list_iter))  # Output: 1
print(next(my_list_iter))  # Output: 2


my_string = "hello"
my_string_iter = iter(my_string)
print(next(my_string_iter))  # Output: 'h'
print(next(my_string_iter))  # Output: 'e'


with open('example.txt', 'r') as file:
    file_iter = iter(file)
    print(next(file_iter))  # Output: First line of the file

Error Handling with next()

The StopIteration exception is critical in Python’s iteration protocol. It signals that an iterator has been fully consumed. However, you can manage what happens when iteration ends by providing a default value.

my_list = [1]
my_iter = iter(my_list)

print(next(my_iter, 'No more items'))  # Output: 1
print(next(my_iter, 'No more items'))  # Output: 'No more items'

Without the default value, the second call to next() would have raised a StopIteration exception.

Advanced Use Cases

Manually Controlling Iteration

You can use next() to manually control iteration for more fine-grained control over the program flow.

iterator = iter(range(10))
while True:
        item = next(iterator)
        # process the item
    except StopIteration:

Creating Custom Iterators

Python allows creating custom iterator objects by implementing the __iter__() and __next__() methods.

class Counter:
    def __init__(self, start, end):
        self.current = start
        self.end = end

    def __iter__(self):
        return self

    def __next__(self):
        if self.current > self.end:
            raise StopIteration
            self.current += 1
            return self.current - 1

counter = Counter(1, 3)
print(next(counter))  # Output: 1
print(next(counter))  # Output: 2
print(next(counter))  # Output: 3

Infinite Iterators

The next() function is also what makes infinite iterators possible.

import itertools

counter = itertools.count()
print(next(counter))  # Output: 0
print(next(counter))  # Output: 1
# and so on...

Real-World Applications

Parsing Files

When parsing files line by line, especially with complex logic that might not suit a for-loop, next() is invaluable.

Working with Streaming Data

In applications that stream data, like from a network connection or a large data processing pipeline, next() can be used to handle data as it becomes available.

Implementing Pagination

When dealing with APIs or databases, data often comes in pages. The next() function can help navigate through pages of data.


The next() function is a fundamental aspect of Python’s iteration capabilities. Although its direct use is uncommon in everyday scripts due to the convenience of for-loops, understanding next() is crucial for anyone looking to deeply comprehend Python’s iteration model or needing to implement custom iteration behavior.

Leave a Reply