Python Iterators

Spread the love

Iterators form the backbone of many operations in Python, providing a standardized way to traverse through different kinds of data structures. They enable developers to write efficient loops, handle streams of data, and work with a myriad of other objects that support iteration. This article offers a comprehensive exploration of iterators in Python.

What are Iterators?

In Python, an iterator is an object that adheres to the iterator protocol, which means it must implement two methods: __iter__() and next() (in Python 2) or __next__() (in Python 3).

The Iterator Protocol

The iterator protocol is a systematic way Python uses to make objects iterable. For an object to support iteration, it must follow the iterator protocol.

  1. __iter__( ) Method:
    • This method returns the iterator object itself.
    • It’s required for an object to be considered an iterable, even if it just returns self, which is the case for most iterators. The presence of this method signals to Python that an object can be iterated over.
  2. __next__( ) (or next( ) in Python 2) Method:
    • This method returns the next value from the iterator.
    • When you use a loop to iterate over an object, Python automatically calls this method to get the next item in the sequence.
    • Once the iterator has no more items to provide (i.e., it’s exhausted), this method should raise the StopIteration exception. This signals to Python that the iteration has concluded.


Let’s consider a simple iterator that produces numbers up to a given value:

class SimpleCounter:
    def __init__(self, max_value):
        self.max_value = max_value
        self.current_value = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.current_value <= self.max_value:
            value_to_return = self.current_value
            self.current_value += 1
            return value_to_return
            raise StopIteration

Here, SimpleCounter is an iterator that will produce numbers starting from 0 up to max_value.

How does the StopIteration exception work?

When the iterator has no more items to yield, it’s essential to signal to the calling context (like a for loop) that iteration should stop. This is done by raising the StopIteration exception in the __next__() method. When a for loop encounters this exception, it knows the iteration has finished and terminates the loop gracefully.

The Relationship Between Iterables and Iterators:

While every iterator is an iterable (because it implements the __iter__ method), not every iterable is an iterator. Some iterables, like lists and tuples, are not iterators by themselves but can produce iterators using their __iter__ method.

For example:

numbers = [1, 2, 3]
iterator = iter(numbers)  # This produces an iterator from the list.
print(next(iterator))     # Outputs: 1
print(next(iterator))     # Outputs: 2
print(next(iterator))     # Outputs: 3
print(next(iterator))     # Raises StopIteration exception

In the code above, the numbers list is an iterable, but not an iterator. The iter() function produces an iterator for the list.

Iterators play a fundamental role in Python, allowing for a uniform way to access elements in a sequence or collection one by one. By implementing the __iter__() and __next__() methods and using the StopIteration exception, Python provides a clear and consistent way to traverse through data structures and other iterable objects.

Why are Iterators Useful?

  1. Memory Efficiency: Iterators allow you to traverse through a collection without loading the entire collection into memory. This is especially useful when working with large datasets or when generating values on-the-fly.
  2. Flexibility: Iterators allow you to work with any object that supports iteration, regardless of its underlying implementation.
  3. Cleaner Code: They provide a clean and consistent way to loop through different data structures, improving the readability of the code.

What is an Iterable?

In simple terms, an iterable is any Python object capable of returning its members one at a time, permitting it to be iterated over in a for-loop. The primary requirement for an object to be considered an iterable is that it has an __iter__() method.

The __iter__( ) method

The __iter__() method should return an iterator object. An iterator is an object that adheres to the iterator protocol, meaning it implements two methods: __iter__() and __next__(). The iterator’s __iter__() method should return the iterator object itself, and the __next__() method should return the next value from the iterator.

While every iterator is an iterable (because it implements the __iter__ method), not every iterable is an iterator. This distinction is crucial. For example, while a list is iterable, it’s not an iterator by itself. You need to call the iter() function on a list to get its iterator.

Examples of Iterables:


Perhaps the most commonly used iterable. When you loop over a list, you’re using its iterable property.

for item in [1, 2, 3]:




Like lists, but immutable. They too can be looped over.

for item in (1, 2, 3):




Strings are sequences of characters and are also iterables. When you loop over a string, you iterate over its characters.

for char in "hello":




When you loop over a dictionary, you iterate over its keys. However, dictionaries also have methods (keys(), values(), and items()) that return iterable views of the dictionary’s keys, values, or key-value pairs respectively.

data = {"a": 1, "b": 2}
for key in data:
    print(key, data[key])


a 1
b 2


When you loop over a file object, you iterate over its lines. This allows for memory-efficient file processing since the entire file doesn’t need to be loaded into memory.

with open("filename.txt", "r") as file:
    for line in file:
        print(line, end='')

Iterables and the iter( ) function

To obtain an iterator from an iterable, you can use the built-in iter() function. This function calls the __iter__() method of the given object and returns the iterator.

numbers = [1, 2, 3]
my_iterator = iter(numbers)
print(next(my_iterator))  # Outputs: 1

In the example above, numbers is a list (an iterable). By calling iter(numbers), we retrieve its iterator.

Understanding the Iterable Protocol is foundational to grasping how Python handles loop constructs and data traversal. By defining the __iter__() method, Python provides a consistent interface for various objects to become iterable, allowing developers to use these objects seamlessly within loops and other iterative processes.

What is a Custom Iterator?

A custom iterator allows you to define your own rules for iteration over a sequence or a collection of data. By creating an iterator, you can decide how to traverse a data structure, what elements to yield, and when to stop iteration.

To build a custom iterator, an object must implement two methods as per the iterator protocol:

  1. __iter__(): This method should return the iterator object itself.
  2. __next__() (or next() in Python 2): This method should return the next value from the iterator. When there are no more items to return, it should raise the StopIteration exception.

Example: A Counter Iterator

Let’s design a simple iterator that generates numbers from a starting value to an ending value.

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
        value = self.current
        self.current += 1
        return value

Here’s how this works:

  • The Counter class is initialized with a start and an end value.
  • The __iter__ method returns the iterator object itself, which in this case is an instance of the Counter class.
  • The __next__ method increments the current value and returns it until the value exceeds the end value. When that happens, the method raises a StopIteration exception to signal the end of the iteration.

Using the Custom Iterator

counter = Counter(1, 3)

for number in counter:



After the for loop has consumed the iterator, attempting to extract more values using the next() function will result in a StopIteration exception.

Notes on the Design:

  1. Statefulness: An important thing to remember about iterators is that they are stateful. Once exhausted, you can’t iterate over them again without creating a new instance.
  2. Reusability: If you want the iterator to be reusable (i.e., be able to iterate multiple times over the same object), you might need to separate the iterator from the iterable. This means the __iter__() method of the iterable will return a fresh iterator instance every time.
  3. Enhancements: Custom iterators allow you to introduce advanced iteration patterns, conditional iterations, lazy evaluations, infinite sequences, and more.

Building custom iterators empowers developers to define specific and often complex iteration patterns, abstracting away the iteration logic from the consumer of the iterator. By understanding and implementing the __iter__() and __next__() methods, developers can craft iterators tailor-made for their data structures and use cases.

Built-in Functions and Iterators

Python provides several built-in functions to work with iterators:

1. iter( ) :

The iter() function is used to obtain an iterator from an iterable.


iter(object[, sentinel])
  • object: The object whose iterator needs to be fetched (must be an iterable).
  • sentinel (optional): If provided, the object should be a callable (like a function). The iterator is created such that it calls this callable until the sentinel is returned (more commonly used with I/O streams).


my_list = [1, 2, 3]
my_iterator = iter(my_list)
print(next(my_iterator))  # Outputs: 1

2. next( ) :

The next() function retrieves the next item from an iterator. If no more items are available, it raises a StopIteration exception, unless a default value is provided.


next(iterator, default)
  • iterator: The iterator from which the next item should be fetched.
  • default (optional): Value to be returned if the iterator is exhausted (i.e., no more items).


my_iterator = iter([4, 5, 6])
print(next(my_iterator))  # Outputs: 4
print(next(my_iterator, 'End'))  # Outputs: 5
print(next(my_iterator, 'End'))  # Outputs: 6
print(next(my_iterator, 'End'))  # Outputs: 'End' (because the iterator is exhausted)

3. enumerate( ) :

The enumerate() function returns an iterator that produces tuples. Each tuple contains an index (starting from 0 by default) and a value from the given iterable.


enumerate(iterable, start=0)
  • iterable: The iterable whose items need to be enumerated.
  • start (optional): The starting value of the counter.


for idx, value in enumerate(["a", "b", "c"], 1):
    print(idx, value)


1 a
2 b
3 c

4. zip( ) :

The zip() function is used to combine two or more iterables. It returns an iterator that generates tuples, where the i-th tuple contains the i-th element from each of the argument iterables. The iteration stops when the shortest input iterable is exhausted.


  • *iterables: Two or more iterable objects.


names = ["Alice", "Bob", "Charlie"]
scores = [85, 92, 88]
for name, score in zip(names, scores):
    print(name, score)


Alice 85
Bob 92
Charlie 88

These built-in functions are incredibly useful when working with iterators and iterables in Python. They abstract away common operations and patterns, enabling developers to write concise and readable code. Whether it’s fetching an iterator from an iterable, getting the next item, enumerating over values with their indices, or zipping multiple sequences together, these functions make the tasks straightforward and Pythonic.

Infinite Iterators in Python

Infinite iterators, as the name suggests, produce an endless sequence of values. They do not have a termination point, so when you iterate over them, they keep producing values indefinitely until you manually break out of the iteration.

Python’s itertools module provides several built-in infinite iterators. Let’s delve into some of them and understand the concept in more depth:

1. count( start=0, step=1 )

This function returns an iterator that produces consecutive numbers indefinitely, starting from start and incremented by step.


from itertools import count

for i in count(5, 2):
    if i > 20:  # We introduce a break condition to stop the loop



2. cycle( iterable )

This function returns an iterator that cycles through the given iterable indefinitely.


from itertools import cycle

counter = 0
for item in cycle(['a', 'b', 'c']):
    if counter > 7:  # We introduce a break condition to stop the loop
    counter += 1



3. repeat( object, times=None)

This function returns an iterator that produces the given object indefinitely or up to the specified number of times if provided.


from itertools import repeat

for item in repeat('Hello', 3):



If times is not provided, it will repeat “Hello” indefinitely.

Using Infinite Iterators:

Infinite iterators can be quite useful, but care must be taken when using them. Without an appropriate exit condition, any loop consuming these iterators will run forever, leading to potential system hang-ups or resource exhaustion. Hence, always ensure there’s a mechanism to break out of the loop, like a counter or a specific value check.

Why use Infinite Iterators?

While having an infinite loop might seem counterintuitive, there are practical scenarios for them:

  1. Stream Processing: When dealing with streams of data, you might not know when the data will end. An infinite iterator can keep processing data as it arrives.
  2. Game Loops: Many video games use an infinite loop to keep the game running until an event (like the player quitting) breaks the loop.
  3. Server Loops: Servers often run in an infinite loop, waiting for client connections.

Infinite iterators, when used judiciously, can lead to cleaner code in scenarios where the termination condition is external or not based on the data being iterated over.


Iterators in Python are a foundational concept that underpins a variety of operations. Whether you’re working with data structures, streaming large amounts of data, or just trying to write more efficient and readable code, understanding and utilizing iterators is essential. With a combination of built-in tools, and custom implementations, Python offers a flexible and powerful system for iterative processing.

Leave a Reply