Python Iterators

About Python Iterators

In Python, an iterator is an object that allows you to traverse through all the elements of a container (like a list, tuple, dictionary, or set) without needing to access the underlying structure directly.

Iterators are a fundamental concept in Python and are used extensively in loops and comprehensions.

An iterator implements the iterator protocol, which consists of two special methods: __iter__() and __next__().

__iter__(): This method returns the iterator object itself. It is called once at the beginning of the iteration.
__next__(): This method returns the next item from the iterator. When there are no more items to return, it raises a StopIteration exception.

Getting an Iterator From an Iterable Object

An iterator can be created from an iterable object (like a list or a string) using the built-in iter() function.

Once you have an iterator, you can use the built-in next() function to retrieve the next item from the iterator.

Example of Creating an Iterator from a List

# Creating a list
color_list = ["red", "green", "blue"]

# Getting an iterator from the list
color_iterator = iter(color_list)

# Using next() function to get elements from iterator
print(next(color_iterator))  # Output: red
print(next(color_iterator))  # Output: green
print(next(color_iterator))  # Output: blue
print(next(color_iterator))  # Raises StopIteration exception

Explanation of the Code Above

color_list = ["red", "green", "blue"]: We create a list called color_list containing three color names.
color_iterator = iter(color_list): We use the iter() function to get an iterator object from the color_list.
next(color_iterator): We call the next() function on the iterator to get the next item in the sequence. Each call to next() returns the next color in the list until there are no more items (color) left, at that point a StopIteration exception is raised.

Iterators and for Loops

In Python, for loops are used to iterate over iterable objects like lists, tuples, and strings. Under the hood, a for loop automatically creates an iterator from the iterable object and uses it to traverse through the elements.

The for loop is the most common way to use iterators, and it handles all the details for you:

It calls iter() on the iterable to get an iterator.
In each loop, it calls next() to get the next item.
The for loop automatically catches the StopIteration exception and ends the loop gracefully.

# Using a for loop to iterate over a tuple
color_tuple = ("red", "green", "blue")
for color in color_tuple:
    print(color)
# Output: 
    # red
    # green 
    # blue

Creating Your Own Iterator (Custom Iterator)

You can create your own iterator by defining a class that implements the __iter__() and __next__() methods.

The steps to create a custom iterator are as follows:

Define a class for your iterator.
Implement the __iter__() method to return the iterator object itself.
Implement the __next__() method to return the next value and raise StopIteration error when there are no more values to return.

Let's create an iterator that counts up to a specified number.

Example of Creating a Custom Iterator

# Defining a custom iterator class

class CountUpTo:

    # Initialize the iterator with a maximum value
    def __init__(self, max):
        self.max = max
        self.current = 0

    # Return the iterator object itself
    def __iter__(self):
        return self

    # Return the next value
    def __next__(self):
        if self.current < self.max:
           self.current += 1
           return self.current
        else:
           raise StopIteration
                
# Using the custom iterator
counter = CountUpTo(5)

# Iterating through the custom iterator using for loop
for number in counter:
    print(number)

Generator Functions

Python offers a much simpler way to create iterators using generator functions.

A generator function is a function which contains the keyword yield. When called, it doesn't execute the function immediately; instead, it returns a special type of iterator called a generator.

Each time the generator's __next__() method is called, the function runs until it hits a yield statement, which provides a value and pauses the function's state. The next time __next__() is called, the function resumes right after the yield statement.

Let's create a generator function that counts up to a specified number.

Example of Creating a Generator Function

# Defining a generator function
def counter(low, high):
    while low <= high:
        yield low
        low += 1

# Using the generator function with a for loop
for num in counter(1, 5):
    print(num)

# Output:
# 1
# 2
# 3
# 4
# 5

# Using the generator with next() function
gen = counter(1, 3)
print(next(gen))  # Output: 1
print(next(gen))  # Output: 2

Python Tutorial