Skip to content

Using Python's map() Function to Apply a Function to Iterable Elements

Updated: at 04:23 AM

The map() function is a built-in Python function that allows you to apply a function to each element in an iterable object and return a new iterator with the transformed elements. Understanding how to use map() is an important skill for Python developers, data scientists, and anyone working with Python iterables like lists, tuples, dictionaries, and more.

In this comprehensive guide, you’ll learn:

Table of Contents

Open Table of Contents

What is Python’s map() Function?

The map() function is a built-in function that applies a specified function to each item in an iterable object (like a list, tuple, etc.) and returns a new iterator with the transformed elements.

In its simplest form, map() takes two required parameters:

map(function, iterable)

The function argument is the function that will be applied. It can be a built-in Python function, custom function, or lambda function.

The iterable argument is the iterable object (list, tuple, etc.) that contains the elements you want to apply the function to.

map() applies the function to each element in the iterable, one by one, and constructs a new iterator with the transformed values. This new iterator can then be converted to a new list, tuple, etc. if needed.

Here is a simple example applying the built-in len() function to a list of strings using map():

strings = ['foo', 'card', 'bar', 'abcb']
lengths = map(len, strings)

# Output: [3, 4, 3, 4]

This demonstrates how map() can easily transform each element in an iterable by applying a function without needing explicit loops.

map() Syntax and Parameters

The full syntax and parameters for map() are:

map(function, iterable, ...)

map(function, iter1, iter2, ...)

The key parameters are:

The function can be any valid Python callable, including:

The iterable can be any Python object that is iterable. Some common examples:

map() will apply the function to each element in iterable in order, tracking the iterations internally.

The return value from map() is a map object, which is an iterator that yields the transformed values on demand. You can convert it to a list, tuple, etc. if needed for further processing.

Using Lambda Functions with map()

The function argument for map() can accept lambda functions, which are small anonymous functions useful for data processing.

Here is an example using map() with a lambda function to transform a list of strings to uppercase:

strings = ['foo', 'card', 'bar', 'abcb']

upper_strings = map(lambda x: x.upper(), strings)


# Output: ['FOO', 'CARD', 'BAR', 'ABCB']

The lambda function lambda x: x.upper() is applied to each element x in the strings list, returning a new iterator with the uppercased strings.

Lambdas are very common with map() to do minor data transformations or filters without defining an entire function.

Examples - Using map() on Common Python Iterables

map() can be used on most Python iterables. Here are some examples of using it on common types:


Transforming list elements:

nums = [1, 2, 3, 4]
squared_nums = map(lambda x: x**2, nums)

# [1, 4, 9, 16]


Tuples work just like lists:

locations = [('UK', 'London'), ('Japan', 'Tokyo'), ('US', 'New York')]

city_names = map(lambda x: x[1], locations)

# ['London', 'Tokyo', 'New York']


On dicts, map() applies the function to each key by default:

cities = {
  'UK': 'London',
  'US': 'New York',
  'India': 'Mumbai'

country_codes = map(lambda x: x[0], cities.items())

# ['UK', 'US', 'India']

To apply to values instead, use cities.values()


For strings, map() iterates through each character:

letters = map(lambda x: x.upper(), 'hello')

# ['H', 'E', 'L', 'L', 'O']

Multiple Iterables

You can also pass multiple iterables to map() and it will apply the function to elements from all iterables in parallel:

names = ['Elise', 'Mary']
ages = [22, 28]

users = map(lambda n, a: f'{n} is {a} years old', names, ages)

# ['Elise is 22 years old', 'Mary is 28 years old']

This “zips” the iterables together based on index before map() applies the lambda.

Using map() with NumPy Arrays

map() works nicely with NumPy arrays to transform elements in bulk quickly.

For example, squaring each element in a NumPy array:

import numpy as np

arr = np.array([1, 2, 3, 4])

squared = map(lambda x: x**2, arr)

# [1, 4, 9, 16]

Just like lists, it transforms each value efficiently.

map() vs For Loops

A common question is when to use map() vs a for loop.

The key differences and factors:

So in summary:

Advantages and Limitations of map()

Some key advantages of using map():

Some limitations to keep in mind:

So in general, prefer using map() where it makes your code cleaner and more readable. But also know when a for loop or other technique may be more suitable.

Common Errors and How to Avoid Them

Here are some common mistakes and how to avoid them when using map():

Carefully reading the documentation and following Pythonic idioms can help avoid these common mistakes.

Practical Applications and Use Cases

There are many practical use cases where map() can help write cleaner and faster Python code:

Overall, any case where you need to “map” a transformation function over a large dataset is a great fit for Python’s map() function.

Best Practices and Tips

To use Python’s map() effectively, keep these best practices and tips in mind:

Following best practices and the Pythonic way will ensure you get the most out of this powerful function.


Python’s built-in map() function allows you to easily apply transformations and computations to iterables in a simple, efficient way.

Key takeaways:

Learning to effectively use map() is a key skill for Python programmers. This guide reviewed the fundamentals and best practices for working with this versatile function.

Now you have a solid grasp of how to harness the power of map() in your own Python code to write cleaner, faster and more Pythonic programs.