Python iter() Function

Spread the love

The iter() function returns an iterator object for the given iterable object. The iterable can be any Python object that supports iteration, which typically includes data structures like lists, tuples, dictionaries, and strings.


The syntax for iter() is simple.

iter(iterable, sentinel=None)


The iter() function takes two parameters:

  • iterable – any Python object which has an __iter__() method or supports the sequence protocol (has a __getitem__() method with integer arguments starting at 0).
  • sentinel – a special value that, if provided, causes the iterator to stop when this value is returned.

The returned iterator object can then be used to access the elements of the iterable one by one, using the next() function until a StopIteration exception is raised, indicating that there are no more items to retrieve.

Understanding Iterators and Iterables

Before using iter(), one must understand the distinction between ‘iterators’ and ‘iterables’:

  • Iterable: An object capable of returning its members one at a time. Examples include all sequence types (such as list, str, tuple) and some non-sequence types like dict.
  • Iterator: An object representing a stream of data; it returns the next item of the stream when next() is called on it. Once an iterator’s data is exhausted, further calls to next() raise a StopIteration exception.

Using iter( ) with Iterables

Let’s explore how to use the iter() function with different types of iterables in Python:

Using iter( ) with Lists:

Lists are one of the most commonly used iterables in Python. They are ordered collections and can be iterated over directly, but you can also create an iterator using iter():

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

print(next(my_list_iterator))  # Outputs: 1
print(next(my_list_iterator))  # Outputs: 2

Using iter( ) with Tuples

Tuples are similar to lists in that they are ordered collections of items, but they are immutable. You can still use iter() to create an iterator:

my_tuple = (1, 2, 3, 4)
my_tuple_iterator = iter(my_tuple)

print(next(my_tuple_iterator))  # Outputs: 1
print(next(my_tuple_iterator))  # Outputs: 2

Using iter( ) with Strings

Strings can be iterated over by character. Using iter(), you can explicitly create an iterator that goes through each character in the string:

my_string = "hello"
my_string_iterator = iter(my_string)

print(next(my_string_iterator))  # Outputs: 'h'
print(next(my_string_iterator))  # Outputs: 'e'

Using iter( ) with Dictionaries

Dictionaries can be iterated over in different ways: you can iterate over keys, values, or items (key-value pairs). By default, iterating over a dictionary will give you the keys:

my_dict = {'a': 1, 'b': 2, 'c': 3}
my_dict_iterator = iter(my_dict)

print(next(my_dict_iterator))  # Outputs: 'a'
print(next(my_dict_iterator))  # Outputs: 'b'

If you want to iterate over values or items, you can use the .values() or .items() methods respectively:

# Values iterator
my_dict_values_iterator = iter(my_dict.values())

print(next(my_dict_values_iterator))  # Outputs: 1
print(next(my_dict_values_iterator))  # Outputs: 2

# Items iterator
my_dict_items_iterator = iter(my_dict.items())

print(next(my_dict_items_iterator))  # Outputs: ('a', 1)
print(next(my_dict_items_iterator))  # Outputs: ('b', 2)

Using iter( ) with Files

Files in Python are also iterables and can be iterated over line by line:

# Assuming 'my_file.txt' contains multiple lines of text
with open('my_file.txt', 'r') as file:
    file_iterator = iter(file)

    print(next(file_iterator))  # Outputs: the first line in the file
    print(next(file_iterator))  # Outputs: the second line in the file

Each call to next() returns the next line in the file until the end of the file is reached.

Using iter( ) with Custom Iterables

You can also define your own iterable classes by defining an __iter__() method which returns an iterator. This iterator must implement a __next__() method:

class MyIterable:
    def __init__(self, limit):
        self.limit = limit
        self.value = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.value < self.limit:
            self.value += 1
            return self.value
            raise StopIteration

my_iterable = MyIterable(3)
my_iterable_iterator = iter(my_iterable)

print(next(my_iterable_iterator))  # Outputs: 1
print(next(my_iterable_iterator))  # Outputs: 2
print(next(my_iterable_iterator))  # Outputs: 3

Using iter( ) with Generators

Generators are a simple way to create iterators using functions and the yield statement:

def my_generator():
    yield 1
    yield 2
    yield 3

my_generator_iterator = iter(my_generator())

print(next(my_generator_iterator))  # Outputs: 1
print(next(my_generator_iterator))  # Outputs: 2
print(next(my_generator_iterator))  # Outputs: 3

Generators abstract away much of the boilerplate code involved in creating an iterable, making them a convenient alternative to defining a class with __iter__() and __next__() methods.

In Python, the iter() function is versatile and can work with a wide range of iterable objects. Whether you are using built-in data types like lists, strings, and files or creating your own custom iterables, iter() provides a standardized way to traverse through elements one at a time. Understanding how to use it with different kinds of iterables is crucial for taking full advantage of Python’s iteration capabilities.

Infinite Iterators and the sentinel Parameter

A less commonly used feature of iter() is the sentinel parameter. When the sentinel parameter is used, the first argument is not an iterable, but a callable object (a function or any other object that implements __call__()). The iterator calls this callable on each iteration; if the value returned is equal to the sentinel, StopIteration is raised.

Here is an example using iter() with a callable and a sentinel:

import random

# A simple generator that simulates a dice throw
def throw_dice():
    return random.randint(1, 6)

# Create an iterator that will end iteration if the dice throw returns 1
dice_iterator = iter(throw_dice, 1)

# Iterate until a 1 is rolled
for throw in dice_iterator:
    print(f"Dice throw: {throw}")

In this example, the iteration continues until throw_dice() returns 1, at which point StopIteration is implicitly raised, and the for loop terminates.

Advanced Uses of Iterators

Iterators are not just for simple loops. They can be used in a variety of advanced scenarios, such as:

  • Building complex iterables: You can use iterators to lazily generate values as needed, which can be more memory-efficient than generating all the items at once.
  • Connecting to external resources: Iterators can represent streams of data from external resources like files, network sources, or sensors, fetching data on-demand.
  • Cooperative multitasking: Python’s generators (which are a kind of iterator) can be used to implement coroutines for cooperative multitasking.


The iter() function is a fundamental part of Python that aligns with the language’s overall design philosophy: simple, readable, and powerful. By providing a standard way of iterating over different Python data types, iter() serves as a bridge between Python’s abstract iteration protocols and concrete data structures.

Leave a Reply