Iterators in Python

7 min read

In Python, an iterator is an object that allows us to traverse a container or sequence of elements, such as a list, tuple, or string. It provides a way to access the elements of a collection one by one without needing to know the underlying structure or implementation details.

Iterators in Python offer a simple and efficient approach to loop over elements in a collection, making them an essential concept in Python programming.

An iterable is any object that can return an iterator, while an iterator is an object that provides the __next__() method, which retrieves the next element in the sequence.

Note: When an iterator is exhausted and has no more elements to offer, it raises a StopIteration exception.

To create our own iterator, we define a class that implements the iterator protocol. The class should have the __iter__() method, which returns the iterator object itself, and the __next__() method, which retrieves the next element. Within the __next__() method, we can perform any necessary computations or logic to determine the next value in the sequence.

Iterating through an Iterator

Iterating through an iterator in Python is a fundamental process that allows us to access and process each element within a sequence or container. Whether we are working with a built-in iterable or a custom iterator, the process of iteration remains consistent.

Example of Python iterator:

my_list = [1, 2, 3, 4, 5]
my_iterator = iter(my_list)

for item in my_iterator:

The output of this code snippet will be:


The for loop takes care of retrieving elements from the iterator until it raises a StopIteration exception, indicating that there are no more elements to process. It automatically handles the iteration logic and simplifies our code, providing a clean and readable way to access each element.

It’s important to note that once we have iterated through an iterator, we cannot iterate over it again. Iterators are designed to be consumed once, and subsequent attempts to iterate over them will result in no output.

Working of For Loops for Iterators

When using the for loop with an iterator, the loop internally manages the iteration process.

It follows a predefined sequence of steps to retrieve elements from the iterator until it reaches the end.

Here’s a breakdown of how the for loop works with iterators:

  • Initialization: The for loop initializes the iterator by calling the iter() function on the iterable object. This function returns the iterator associated with the iterable.
  • Iteration: The loop proceeds to execute the block of code within its body for each element in the iterator. It retrieves the next element from the iterator by calling the iterator’s __next__() method. The retrieved element is temporarily assigned to the loop variable.
  • Execution of Loop Body: The code within the loop’s body is executed with the loop variable representing the current element from the iterator. We can perform any desired operations on the element at this stage.
  • Continuation or Termination: After executing the loop body, the for loop checks if the iterator has more elements. It does this by attempting to retrieve the next element using the __next__() method. If there are more elements, the loop continues with the next iteration. If the iterator is exhausted and raises a StopIteration exception, the loop terminates, and the iteration process ends.

Example of Iterator in Python:

my_list = [1, 2, 3, 4, 5]
my_iterator = iter(my_list)

for item in my_iterator:

Here, we create a list my_list and obtain an iterator my_iterator from it using the iter() function. The for loop then iterates through my_iterator, assigning each element to the item variable and printing it.

Building Custom Python Iterators

To build a Python custom iterator, we follow a set of guidelines and protocols defined by Python.

There are two essential components that need to be implemented: The iterable and iterator protocols.

  1. Iterable Protocol:
    • The iterable protocol requires defining the __iter__() method in our custom object or class. This method should return an iterator object that will be used for iteration.
    • The __iter__() method is responsible for creating and returning a new instance of the iterator object every time it is called. This allows multiple iterations over the same custom object.
  2. Iterator Protocol:
    • The iterator protocol requires defining the __iter__() and __next__() methods in our custom iterator class.
    • The __iter__() method in the iterator class should return itself, as it is both an iterator and iterable.
    • The __next__() method is responsible for retrieving the next element in the sequence and returning it. It should raise a StopIteration exception when there are no more elements to iterate over.

Example of creating your first custom Python iterator:

class CustomIterator:
    def __init__(self, data): = data
        self.index = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.index >= len(
            raise StopIteration
        item =[self.index]
        self.index += 1
        return item

class CustomObject:
    def __init__(self): = [1, 2, 3, 4, 5]

    def __iter__(self):
        return CustomIterator(

Here, we define a custom iterator class CustomIterator and a custom object class CustomObject. The CustomIterator class implements the iterator protocol by defining the __iter__() and __next__() methods. The CustomObject class implements the iterable protocol by defining the __iter__() method, which returns an instance of the CustomIterator.

By building custom iterators, we can define our own –

  1. Iteration logic
  2. Control the order and repetition of elements
  3. Handle complex data structures or dynamic data sources.

Custom iterators allow us to extend the functionality of Python’s iteration capabilities and tailor them to specific requirements within our programs.

Infinite Iterators in Python

In Python, infinite iterators are a fascinating concept that allows us to generate sequences of values that continue indefinitely. Unlike regular iterators, which are bounded by the number of elements in a collection.

Infinite iterators can generate an endless stream of values without reaching an endpoint. These iterators provide a powerful tool for working with infinite sequences and implementing certain algorithms and simulations.

Python provides several built-in functions and libraries that offer convenient ways to create and work with infinite iterators.

Here are a few examples how to create infinite iterators in Python:

  • itertools.count(start=0, step=1): This function from the itertools module generates an infinite iterator that starts from a specified value (start) and increments by a specified step value (step) with each iteration. If no arguments are provided, it starts from 0 and increments by 1.
import itertools

for num in itertools.count(1, 2):
  • itertools.cycle(iterable): This function creates an infinite iterator that continuously cycles through the elements of a given iterable. It starts from the beginning of the iterable and repeats the sequence indefinitely.
import itertools

colors = ['red', 'green', 'blue']
color_cycle = itertools.cycle(colors)

for color in color_cycle:
  • itertools.repeat(element, times=None): This function generates an iterator that repeats a specified element indefinitely or a specified number of times (times argument).
import itertools

for num in itertools.repeat(10):

Infinite iterators offer great flexibility and can be combined with other functions, conditionals, or terminating conditions to control the behavior of the iteration.

It’s important to handle infinite iterators with caution, as they can result in infinite loops if not used carefully. It’s generally a good practice to introduce terminating conditions or break statements to stop the iteration when necessary.


Python’s for loop simplifies the process of iterating through iterators, automatically managing the iteration logic and handling the retrieval of elements. This powerful feature allows us to focus on the code within the loop, making our programs more readable and concise.

In addition to working with built-in iterators, Python allows us to build our own custom iterators. By implementing the iterable and iterator protocols, we can define specialized iteration logic, control the sequence of elements, and work with unique data sources. Custom iterators enable us to tailor the iteration process to fit the requirements of our programs.

Sign up for our Newsletter

Join our newsletter and get tips, tricks and coding tutorials delivered straight to your inbox.