Map, Filter, and Reduce in Python

Python’s map(), filter(), and reduce() are powerful built-in functions that enable you to write concise and expressive code for processing lists and other iterables.

This article provides a detailed explanation of each function, complete with practical examples and clear output, to help you effectively use these tools in your data manipulation tasks. We’ll cover how to use map() to transform elements, filter() to select specific items, and reduce() to aggregate values within a list.

These functions, especially when combined with lambda expressions, can significantly improve the readability and efficiency of your Python code. We will explore the map() function, the filter() function, and also the reduce() function.

 # Sample list
 numbers = [1, 2, 3, 4, 5]
 

Map Function in Python

The map() function applies a given function to each item in an iterable (e.g., a list) and returns an iterator of the results. It’s a clean and efficient way to transform all the elements in a list without using explicit loops.

 def square(n):
     return n * n

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

 print(squared_numbers)
 

 [1, 4, 9, 16, 25]
 

In this example, the square() function is applied to each number in the numbers list, resulting in a new list containing the squares of the original numbers. The list() constructor converts the iterator returned by map() into a list for easy viewing.

Using Lambda with Map

Often, the function you want to apply is simple enough to define directly within the map() call using a lambda expression. This makes the code even more concise.

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

 print(squared_numbers)
 

 [1, 4, 9, 16, 25]
 

Here, a lambda expression lambda x: x * x is used to square each number. This lambda function takes one argument (x) and returns its square.

Mapping with Multiple Iterables

map() can also accept multiple iterables as arguments. The function you provide should then accept as many arguments as there are iterables.

 numbers1 = [1, 2, 3]
 numbers2 = [4, 5, 6]

 summed_numbers = list(map(lambda x, y: x + y, numbers1, numbers2))

 print(summed_numbers)
 

 [5, 7, 9]
 

In this case, the lambda function lambda x, y: x + y takes two arguments, one from each list, and returns their sum. The map() function iterates through both lists in parallel.

Filter Function in Python

The filter() function constructs an iterator from elements of an iterable for which a function returns true. It’s used to select certain items from a list based on a condition.

 def is_even(n):
     return n % 2 == 0

 numbers = [1, 2, 3, 4, 5, 6]
 even_numbers = list(filter(is_even, numbers))

 print(even_numbers)
 

 [2, 4, 6]
 

In this example, the is_even() function checks if a number is even. The filter() function applies this test to each number in the numbers list, and only the even numbers are included in the resulting even_numbers list.

Using Lambda with Filter

As with map(), you can use lambda expressions with filter() for more concise code.

 numbers = [1, 2, 3, 4, 5, 6]
 even_numbers = list(filter(lambda x: x % 2 == 0, numbers))

 print(even_numbers)
 

 [2, 4, 6]
 

The lambda expression lambda x: x % 2 == 0 directly defines the condition for filtering: whether a number is even.

Filtering Strings

filter() can also be used with strings or other iterables.

 words = ["apple", "banana", "kiwi", "orange"]
 short_words = list(filter(lambda word: len(word) <= 5, words))

 print(short_words)
 

 ['apple', 'kiwi']
 

This example filters a list of words to include only those with a length of 5 or less.

Reduce Function in Python

The reduce() function, found in the functools module, applies a function cumulatively to the items of an iterable, from left to right, to reduce the iterable to a single value. It is useful for tasks like calculating sums, products, or other aggregations.

 from functools import reduce

 def multiply(x, y):
     return x * y

 numbers = [1, 2, 3, 4, 5]
 product = reduce(multiply, numbers)

 print(product)
 

 120
 

In this example, the multiply() function multiplies two numbers. The reduce() function applies this multiplication cumulatively to the numbers list: 1*2*3*4*5, resulting in the product 120.

Using Lambda with Reduce

Again, lambda expressions provide a concise way to define the aggregation function.

 from functools import reduce

 numbers = [1, 2, 3, 4, 5]
 product = reduce(lambda x, y: x * y, numbers)

 print(product)
 

 120
 

The lambda expression lambda x, y: x * y directly defines the multiplication operation.

Reduce with an Initializer

reduce() can also take an optional third argument: an initializer. This value is placed before the items of the iterable in the calculation and serves as a default result if the iterable is empty.

 from functools import reduce

 numbers = [1, 2, 3, 4, 5]
 sum_of_numbers = reduce(lambda x, y: x + y, numbers, 10) # 10 + 1 + 2 + 3 + 4 + 5

 print(sum_of_numbers)
 

 25
 

In this example, the initializer 10 is added to the sum of the numbers, resulting in 25.