Python next() Function: Learn to Retrieve Elements One by One

By / February 5, 2026

Overview

When working with Python iterators, there are times when you need to retrieve one element at a time instead of processing every element automatically. This gives you more control over when each element is retrieved.

The next() function makes this possible by returning the next available element from an iterator.

In this tutorial, you’ll learn how the next() function works, its syntax, parameters, return value, the optional default value, and practical examples of using it in Python programs.

💡 Tip: If you’d like to see how this topic fits into the overall iteration process, check out our Python Iteration Tutorial.

Introduction: What Is the Python next() Function?

The next() function is a built-in Python function that retrieves the next available element from an iterator. Each call returns one element and moves the iterator to the next position.

In simple terms, it lets you access the elements of an iterator one at a time instead of processing them all at once.

The next() function works together with the iter() function in the following way:

  1. iter() creates an iterator from an iterable object.
  2. next() retrieves the next available element from that iterator.
  3. A for loop automatically performs these steps behind the scenes.

Want to see it in action? Jump to the Quick Example.

Before exploring practical examples, let’s first understand the syntax, parameters, return value, and how the next() function works.

Python next() Function Syntax, Parameters, Return Value & Example

Python next() Function Syntax

The next() function supports two forms of syntax. The first retrieves the next available element from an iterator, while the second returns a default value if the iterator has no remaining elements.

Syntax 1: Without a Default Value

next(iterator)

This is the most commonly used form of the next() function. It returns the next available element from the
specified iterator.

Syntax 2: With a Default Value

next(iterator, default)

This form returns the next element if one is available. Otherwise, it returns the specified default value instead of raising a StopIteration exception.

Python next() Function Parameters

The parameters accepted by the next() function depend on whether you want to provide a default value when the iterator is exhausted.

ParameterDescription
iteratorThe iterator from which the next element is retrieved.
defaultAn optional value returned when the iterator is exhausted instead of raising a StopIteration exception.

Note: The iterator parameter is required, while the default parameter is optional.

Python next() Function Return Value

The next() function returns the next available value from the specified iterator. If a default value is provided and no more elements remain, the default value is returned instead.

Return ValueDescription
Next ElementReturns the next available element from the specified iterator.
Default Value (Optional)Returns the specified default value if the iterator is exhausted.

Note: If no default value is provided and no more elements are available, the next() function raises a StopIteration exception.

Quick Example

The following example retrieves the first element from an iterator using the next() function.

numbers = iter([10, 20])

print(next(numbers))


# Output
10

In this example, iter() creates an iterator from the list, and next() returns its first element.

How the Python next() Function Works

The next() function retrieves one element at a time from an iterator. Each call returns the next available element and moves the iterator forward.

The process works as follows:

  1. An iterable, such as a list, tuple, string, dictionary, set, or range(), is converted into an iterator using the iter() function.
  2. The iterator keeps track of its current position.
  3. Each call to next() returns the next element and advances the iterator.
  4. When no elements remain, Python raises a StopIteration exception unless a default value is provided.

Element Retrieval Flow

Iterable
      │
      ▼
iter()
      │
      ▼
Iterator
      │
      ▼
next()
      │
      ▼
Next Element
      │
      ▼
Repeat until no elements remain
      │
      ▼
StopIteration
(or Default Value)

Note: When a for loop iterates over an iterator, Python automatically calls next() repeatedly and handles the StopIteration exception behind the scenes.

Examples: next() Function

The following examples demonstrate different ways to use the next() function. Each example introduces a new concept, helping you understand how the function works with different iterators and real-world situations.

Example 1: Retrieve Elements from a List Iterator

This example shows how repeated calls to the next() function retrieve elements one by one from the same iterator.

fruits = ["Apple", "Banana", "Mango"]

iterator = iter(fruits)

print(next(iterator))
print(next(iterator))
print(next(iterator))


# Output
Apple
Banana
Mango

Explanation: The iter() function creates an iterator from the list. Each call to next() returns the next element, and the iterator keeps track of where it left off.

Example 2: Using next() with a Tuple

The next() function works with tuple iterators in the same way as list iterators.

colors = ("Red", "Green", "Blue")

iterator = iter(colors)

print(next(iterator))
print(next(iterator))
print(next(iterator))


# Output
Red
Green
Blue

Explanation: Although tuples are immutable, their elements can still be accessed one at a time through an iterator.

Example 3: Using next() with a String

Strings are iterable objects, allowing next() to retrieve one character at a time.

language = "Python"

iterator = iter(language)

print(next(iterator))
print(next(iterator))
print(next(iterator))


# Output
P
y
t

Explanation: Each call advances the iterator to the next character until the string has been completely processed.

Example 4: Using next() with range()

The next() function can also retrieve values from an iterator created using range().

numbers = iter(range(1, 6))

print(next(numbers))
print(next(numbers))
print(next(numbers))


# Output
1
2
3

Explanation: Only the requested values are returned, making iteration efficient even when working with larger ranges.

Example 5: Using a Default Value

Providing a default value prevents the StopIteration exception after all elements have been retrieved. 

numbers = iter([10, 20])

print(next(numbers))
print(next(numbers))
print(next(numbers, "No More Items"))


# Output
10
20
No More Items

Explanation: Since the iterator has no remaining elements, Python returns the specified default value instead of raising an exception.

Example 6: Manually Controlling Iteration

One advantage of the next() function is that it lets you decide exactly when each element should be retrieved. 

tasks = ["Download", "Process", "Save"]

iterator = iter(tasks)

print(next(iterator))

print("Performing another operation...")

print(next(iterator))


# Output
Download
Performing another operation...
Process

Explanation: Unlike a for loop, manual iteration allows you to pause the process, perform other operations, and continue retrieving elements whenever required.

Example 7: [Advanced] Handling the StopIteration Exception

If no default value is provided, you can handle the StopIteration exception using a try...except block. 

numbers = iter([1, 2])

try:
    while True:
        print(next(numbers))
except StopIteration:
    print("Iteration completed.")


# Output
1
2
Iteration completed.

Explanation: When the iterator reaches the end, Python raises the exception, which is caught by the except block.

Understanding the StopIteration Exception

The previous example showed that after all the elements have been retrieved, another call to next() raises a StopIteration exception. This exception simply tells Python that the iterator has reached the end and there are no more elements to return.

How StopIteration Happens

Iterator Created
       │
       ▼
next()
       │
       ▼
First Element Returned
       │
       ▼
next()
       │
       ▼
Second Element Returned
       │
       ▼
...
       │
       ▼
Last Element Returned
       │
       ▼
next()
       │
       ▼
StopIteration Exception

Each time you call the next() function, Python returns the next element from the iterator. After the last element has been returned, the iterator becomes exhausted. If next() is called again, Python raises a StopIteration exception because there are no more elements left to retrieve.

If you know an iterator may become exhausted, you can avoid this exception by providing a default value as the second argument to the next() function. Instead of raising a StopIteration exception, Python returns the default value.

When using a for loop, you normally never see the StopIteration exception. Python automatically catches the exception behind the scenes and ends the loop gracefully after the last element has been processed.

Remember: The StopIteration exception is a normal part of the iteration process. It is not an error in your program—it simply tells Python that the iterator has no more elements to return.

Common Beginner Mistakes: next() Function

Here are some common mistakes to avoid when using the next() function:

  1. Calling next() on an iterable. Use iter() to create an iterator first.
  2. Forgetting to create an iterator. next() works only with iterator objects.
  3. Ignoring the StopIteration exception. It occurs when no more elements are available.
  4. Not using a default value. A default value can avoid a StopIteration exception.

Common Use Cases of the Python next() Function

Some common use cases of the next() function include:

  • Retrieving elements manually from an iterator.
  • Pausing and resuming the iteration process.
  • Processing data one item at a time.
  • Avoiding StopIteration by using a default value.

Key Takeaways: Python next() Function

Let’s summarize the key points covered in this tutorial:

  • The next() function retrieves the next available element from an iterator.
  • It works together with the iter() function, which creates the iterator.
  • You can provide an optional default value to avoid a StopIteration exception.
  • Python automatically calls next() behind the scenes when executing a for loop.
  • Understanding the next() function builds a strong foundation for learning iterators, generators, and Python’s iteration system.

Leave a Comment

Your email address will not be published. Required fields are marked *

Scroll to Top