Skip to content

Using the Enumerate Function for Index and Value in Python For Loops

Updated: at 05:45 AM

The enumerate() function is an incredibly useful built-in function in Python that allows you to loop over an iterable object while tracking both the iteration index and the value of each item. In this comprehensive guide, we will explore how to use enumerate() for iterating through sequences like lists, tuples, strings, arrays, and other objects while having access to both the index and value in the loop.

Table of Contents

Open Table of Contents

Overview of Enumerate()

The enumerate() function returns an enumerate object that produces a sequence of tuples containing indices and values from the given iterable. This allows you to iterate through the iterable and get the index position and value during each iteration.

Here is the basic syntax for enumerate():

for index, value in enumerate(iterable):
    # code block

Enumerate accepts the iterable object as an argument and optionally a start index (default is 0). The value returned by enumerate is an enumerate object which is an iterator that returns tuples containing the index and value.

Some key qualities of enumerate objects:

Let’s look at some examples to understand how to use enumerate() in practice.

Iterating Through a List with Index

A common scenario is iterating through a list while having access to the index position of each item. Here is how we can do this with enumerate():

colors = ['red', 'green', 'blue']

for index, color in enumerate(colors):
    print(index, color)


0 red
1 green
2 blue

Instead of manually tracking indices, enumerate() provides them automatically with the value.

We can further customize the start index:

for index, color in enumerate(colors, start=1):
    print(index, color)


1 red
2 green
3 blue

This allows looping with a custom numbering scheme if needed.

Iterating Through String Characters and Indices

Strings can also be iterated over with enumerate() to access indices and characters:

word = 'Python'

for index, char in enumerate(word):
  print(index, char)


0 P
1 y
2 t
3 h
4 o
5 n

This makes it easy to process individual characters in a string in a loop along with their positions.

Iterating Over Lists of Tuples or Arrays

For lists of tuples or multi-dimensional arrays, enumerate() can be used to access the tuple indices along with the values:

points = [(1, 2), (3, 4), (5, 6), (7, 8)]

for index, point in enumerate(points):
    print(index, point)


0 (1, 2)
1 (3, 4)
2 (5, 6)
3 (7, 8)

This provides a clean way to iterate through tuple values from a list while having their indices.

Enumerating Dictionary Items

To loop over a dictionary while accessing key-value pairs, pass the .items() method to enumerate():

person = {'name': 'John', 'age': 20, 'job': 'software engineer'}

for index, (key, value) in enumerate(person.items()):
    print(index, key, value)


0 name John
1 age 20
2 job software engineer

This allows enumerating the key-value pairs from the dictionary along with indices.

Starting Enumeration at a Custom Index

We can specify a custom start index for the enumeration using the start parameter:

colors = ['red', 'green', 'blue']

for index, color in enumerate(colors, start=10):
    print(index, color)


10 red
11 green
12 blue

This is useful when you want the indices to start from a given number rather than the default 0.

Enumerating Specific Data Structures

The enumerate() function can work on any iterable object. Along with generic data types like lists, tuples and strings, it can also enumerate over other structures like:


colors = {'red', 'green', 'blue'}
for index, color in enumerate(colors):
    print(index, color)


import array
arr = array.array('i', [1, 2, 3])
for index, num in enumerate(arr):
    print(index, num)


with open('file.txt') as file:
    for index, line in enumerate(file):
        print(index, line)

This makes enumerate() widely applicable across built-in and custom data structures in Python.

Enumerate as Enumeration

The term “enumerate” refers to numbering or listing items one by one. The Python enumerate() function allows us to do exactly that by automatically assigning indices to iterable values during iteration.

Some examples of enumerating sequences in Python without enumerate():

index = 0
colors = ['red', 'green', 'blue']
for color in colors:
    print(index, color)
    index += 1
index = 0
for letter in 'Python':
    print(index, letter)
    index += 1
person = {'name': 'John', 'age': 20, 'job': 'software engineer'}
index = 0
for key in person:
    print(index, key, person[key])
    index += 1

This manual indexing shows how enumerate() makes this process simpler, cleaner and less error-prone by handling the indexing automatically.

Enumerate vs Range

The range() and enumerate() functions can often both be used for indexed looping. The main difference is that range() generates the index numbers directly, while enumerate() generates index-value pairs from an iterable.

Some key differences:

So in summary, use range() if you only require the indices, and enumerate() when you need both indices and values from an iterable.

Unpacking Enumerate Tuples

Since enumerate() returns tuples of (index, value), we can unpack them into separate variables:

colors = ['red', 'green', 'blue']

for index, color in enumerate(colors):
    print(index, '--->', color)

We can also unpack them inline:

points = [(1, 2), (3, 4), (5, 6), (7, 8)]

for index, (x, y) in enumerate(points):
    print(index, '->', x, y)

This allows directly accessing the tuple values in the loop without needing to reference the tuple object.

Enumerate in List Comprehensions

List comprehensions provide a concise way to generate lists using the enumerate object.

For example:

colors = ['red', 'green', 'blue']

indexed_colors = [(index, color) for index, color in enumerate(colors)]


[(0, 'red'), (1, 'green'), (2, 'blue')]

We can also get only indices or values using list comprehension:

indices = [index for index, color in enumerate(colors)]
values = [color for index, color in enumerate(colors)]

So enumerate works nicely with list comprehensions to extract specific data.

Enumerate for Multiple Iterators

A lesser known feature of enumerate() is that it can manage multiple iterators in parallel.

For example:

names = ['Peter', 'Susan', 'Alex']
ages = [25, 32, 19]

for index, (name, age) in enumerate(zip(names, ages)):
    print(index, name, age)


0 Peter 25
1 Susan 32
2 Alex 19

This allows enumerating over multiple iterables simultaneously.

Using Enumerate on Custom Objects

Any object that is iterable can work with enumerate() by passing it to the constructor. This includes custom classes, generators, and other iterables.

For example, if we have a custom range class:

class MyRange:
  def __init__(self, start, end):
    self.start = start
    self.end = end

  def __iter__(self):
    return self

  def __next__(self):
    if self.start >= self.end:
      raise StopIteration
    current = self.start
    self.start += 1
    return current

my_range = MyRange(1, 5)

for index, num in enumerate(my_range):
  print(index, num)

This will output:

0 1
1 2
2 3
3 4

So enumerate() provides an easy way to iterate over custom objects that are iterable.

Use Cases for Enumerate

There are many situations where using enumerate() can be handy:

Overall, enumerate() is very versatile and can simplify many iterations that require access to both indices and values.


The enumerate() function is an elegant way to iterate over any iterable object in Python while automatically getting the index with the values. It eliminates the need for manual indexing and tracking values separately. By returning enumerate objects that generate index-value pairs, enumerate() frees us from implementing the indexing logic ourselves.

Understanding enumerate() helps write cleaner and more Pythonic looping code. The various examples and use cases illustrate how this built-in function can be applied to simplify iterations in many scenarios.

Whether needing indices, values or both from a sequence, set, dictionary, file or custom iterable, enumerate() should be considered as the go-to solution for robust indexed iterations in Python. It encapsulates a very common programming need in a simple and easy to use interface.