Skip to main content

How to Access the Index with map() in Python

Python's map() function applies a function to each item in an iterable. While map() itself doesn't directly provide the index of the current item, you can access the index by combining map() with enumerate().

This guide explains how to do this, and also discusses when list comprehensions offer a clearer and more Pythonic solution.

Using enumerate() with map() (Less Common)​

The enumerate() function adds a counter to an iterable and returns it as an enumerate object. This object can be used directly in a for loop, or you can use it with map(). However, this approach is generally less readable and less Pythonic than using a list comprehension (Section 2). It is included here for completeness, but the next section is strongly preferred.

my_list = ['tutorial', 'reference', 'com']

def example_func(idx_and_item):
    index, item = idx_and_item  # Unpack the tuple
    return item + str(index)

result = list(map(example_func, enumerate(my_list))) # Apply the function

print(result)  # Output: ['tutorial0', 'reference1', 'com2']
  • enumerate(my_list): This creates an iterator that yields pairs: (0, 'tutorial'), (1, 'reference'), (2, 'com').
  • map(example_func, enumerate(my_list)): The map() function applies example_func to each of these pairs.
  • example_func(idx_and_item): This function receives a tuple (index, item) as its argument. It unpacks the tuple and then can use both the index and the item.
  • list(...): The result of map is a map object and we must convert it to a list using list().

This method works, but it's more complex than necessary.

A list comprehension with enumerate() is much cleaner and more readable for this task:

my_list = ['tutorial', 'reference', 'com']

result = [item + str(idx) for idx, item in enumerate(my_list)]
print(result)  # Output: ['tutorial0', 'reference1', 'com2']
  • for idx, item in enumerate(my_list): This iterates through the list, unpacking each (index, item) pair directly into the idx and item variables. This is much clearer than the tuple unpacking required with map().
  • [item + str(idx) ... ]: This is the list comprehension. It creates a new list, and for each item, it constructs the string item + str(idx).

This approach is the standard, Pythonic way to iterate with an index and is generally preferred over using map() in this situation.

When to Use map() vs. List Comprehension​

  • map(): map() is generally most useful when you have an existing function that you want to apply to each element of an iterable, and you don't need the index. If you need the index, or if you're writing the transformation logic inline, a list comprehension is almost always better.
  • List Comprehension: List comprehensions are generally preferred when you need to create a new list based on an existing iterable, especially when you need the index (using enumerate()) or when the transformation logic is short and easily expressed inline.

In the specific case of needing the index and applying a function, the list comprehension with enumerate() is almost always the clearest and most efficient solution.

Table of Contents