Python map() Function

Spread the love

The map() function applies a given function to each element of an iterable (list, tuple etc.) and returns an iterator containing the results.


The basic syntax of the map() function is as follows:

map(function, iterable, ...)


The map() function takes two arguments:

  • function: The function that you want to apply to the items of the iterable. It takes as many arguments as there are iterables.
  • iterable: The iterable whose items are to be passed to the function. You can pass one or more iterables.

Return Value:

The map() function applies the function to all elements of the iterable. It returns an iterator, which is an iterable object (specifically, a map object).

How map( ) Works

When the map() function is called, Python executes the function provided as the first argument on each item of the iterable. The items don’t have to be processed immediately; instead, they are processed on-the-fly as you iterate through the map object, making map() memory efficient.

A Basic Example

Here’s an example of using map() to square each number in a list:

def square(number):
    return number ** 2

numbers = [1, 2, 3, 4, 5]
squared = map(square, numbers)

# Output: [1, 4, 9, 16, 25]

In this case, map() takes the square function and the numbers list and returns a new map object. Converting the map object to a list with list(squared) provides a list of squared numbers.

Working with Multiple Iterables

The map() function can accept more than one iterable. The iterables are parsed in parallel, and the function is applied to their items in order, which means that the function must accept as many arguments as there are iterables.

def add(a, b):
    return a + b

nums1 = [1, 2, 3]
nums2 = [4, 5, 6]

result = map(add, nums1, nums2)

# Output: [5, 7, 9]

Here, map() takes two lists and passes their items to the add() function pairwise.

Using map( ) with Lambda Functions

In conjunction with lambda functions, map() allows for inline anonymous function definitions:

numbers = [1, 2, 3, 4, 5]
squared = map(lambda x: x ** 2, numbers)

# Output: [1, 4, 9, 16, 25]

Using map( ) With Built-in Functions

map() can be used with built-in functions, such as len() to get the length of each word in a sequence:

words = ['hello', 'world']
lengths = map(len, words)

# Output: [5, 5]

Using map() with strings

The map() function in Python can be used with strings to perform various operations that require each character or substring to be processed individually or in conjunction with others. Here’s a detailed look into using map() with strings.

Converting Characters

One common use case is to convert each character in a string into a different form, such as changing the case of characters or converting them into their corresponding ASCII values.

Example: Changing Case of Characters

string = "hello world"
capitalized_chars = map(str.upper, string)

# Output: "HELLO WORLD"

Here, str.upper is the function that is applied to each character in the string. The map() function applies str.upper to each character, resulting in each lowercase letter being converted to uppercase.

Example: Getting ASCII Values

string = "hello"
ascii_values = map(ord, string)

# Output: [104, 101, 108, 108, 111]

In this example, ord is a built-in function that takes a character and returns its ASCII value. map() applies this function to each character in the string.

Splitting Strings and Processing Parts

map() can also be used on a list of substrings, such as those obtained by using the str.split() method on a string. This can be useful for processing each word or delimited section of a string.

Example: Converting String Numbers to Integers

string_numbers = "1 2 3 4 5"
numbers = map(int, string_numbers.split())

# Output: [1, 2, 3, 4, 5]

In this case, we first split the string into a list of numeric strings using split(), and then map() applies the int function to each substring to convert it to an integer.

Combined with Lambda for More Complex Operations

When the operation is more complex than what’s provided by a simple built-in function, lambda can be used to define an inline function to be applied to each character or substring.

Example: Shifting Characters by One in the Alphabet

import string

def shift_char(c):
    if c.islower() and c in string.ascii_lowercase:
        return string.ascii_lowercase[(ord(c) - ord('a') + 1) % 26]
    elif c.isupper() and c in string.ascii_uppercase:
        return string.ascii_uppercase[(ord(c) - ord('A') + 1) % 26]
    return c

shifted_string = ''.join(map(shift_char, "Hello World!"))
# Output: "Ifmmp Xpsme!"

Here, the shift_char function defines how each character should be shifted. It’s important to note the use of the modulo operator % to handle the wrap-around from ‘z’ to ‘a’.

Example: String Transformation Using Lambda

string = "hello world"
alternating_case = ''.join(map(lambda x: x.upper() if x in "aeiou" else x.lower(), string))

# Output: "hEllO wOrld"

This example uses a lambda function that applies a condition to uppercase vowels and lowercase other characters.

Processing Multiple Strings in Parallel

map() can take multiple iterables, which allows it to process multiple strings in parallel. This can be useful, for instance, when you want to concatenate corresponding characters from multiple strings.

Example: Pairwise Concatenation of Two Strings

string1 = "12345"
string2 = "abcde"
pairwise_concatenated = map(lambda x, y: x + y, string1, string2)

# Output: ['1a', '2b', '3c', '4d', '5e']

In this example, map() takes two strings and a lambda function, combining each pair of characters into a single string.

map( ) vs List Comprehensions

A common alternative to map() in Python is list comprehension, which provides a more Pythonic way to create lists based on existing lists. Here’s how the first example could be rewritten using a list comprehension:

numbers = [1, 2, 3, 4, 5]
squared = [x ** 2 for x in numbers]

# Output: [1, 4, 9, 16, 25]

Limitations and Pitfalls

Readability for Complex Functions

For more complex operations, map() can become less readable than list comprehensions or for loops, particularly if the function you’re applying requires a multi-line lambda or is otherwise complicated.

Error Handling

Error handling with map() can be tricky. Since map() is lazy, exceptions won’t be raised until the result is consumed. This can make debugging more difficult.

Return Type

The fact that map() returns an iterator can be overlooked. To get a list, you need to explicitly convert the map object to a list with list().


Python’s map() function is a powerful tool that allows for clean and efficient iteration over sequences. It encapsulates functional programming principles, offering an elegant approach to applying functions over iterables. While map() shines with simple function applications and benefits from being lazy, it may not always be the most readable or intuitive solution for complex transformations.

Leave a Reply