10.1 map(), filter(), and reduce() in Python

NicePython

— 4 min read

Python provides several powerful functional programming tools that allow you to work with sequences of data in a declarative and efficient way. Three of the most commonly used functions in functional programming are map(), filter(), and reduce(). These functions enable you to apply transformations and computations to iterable data structures like lists, tuples, and sets, making your code more concise and expressive.

In this section, we’ll explore how these functions work, how to use them effectively, and examples of when and why to use each one.

10.1.1 The map() Function

The map() function allows you to apply a given function to every item in an iterable (like a list or tuple) and return a new iterable with the transformed items. It’s commonly used for applying transformations to data, such as converting values, performing calculations, or applying operations on elements of a sequence.

Syntax of map():

map(function, iterable)
  • function: A function that defines how to transform each element of the iterable.
  • iterable: A sequence (e.g., list, tuple, set) to which the function will be applied.

Example: Using map() to Square Numbers:

# Define a function that squares a number
def square(x):
    return x ** 2

# List of numbers
numbers = [1, 2, 3, 4, 5]

# Apply map() to square each number in the list
squared_numbers = map(square, numbers)

# Convert the result to a list and print it
print(list(squared_numbers))  # Output: [1, 4, 9, 16, 25]

In this example:

  • The square() function is applied to each element in the list numbers using the map() function.
  • The result is an iterator that can be converted to a list, producing the squares of the numbers.

Using lambda with map():

You can also use lambda functions with map() to write more concise code.

# Use map() with a lambda function to cube numbers
cubed_numbers = map(lambda x: x ** 3, [1, 2, 3, 4, 5])
print(list(cubed_numbers))  # Output: [1, 8, 27, 64, 125]

In this example:

  • The lambda function lambda x: x ** 3 is used to cube each number in the list, providing a more concise alternative to defining a separate function.

10.1.2 The filter() Function

The filter() function is used to create a new iterable containing only the elements of the original iterable that meet a certain condition. It applies a filtering function to each item and includes the item in the output if the function returns True.

Syntax of filter():

filter(function, iterable)
  • function: A function that returns True or False based on a condition for each element.
  • iterable: The sequence to filter.

Example: Using filter() to Select Even Numbers:

# Define a function that checks if a number is even
def is_even(x):
    return x % 2 == 0

# List of numbers
numbers = [1, 2, 3, 4, 5, 6]

# Use filter() to keep only even numbers
even_numbers = filter(is_even, numbers)

# Convert the result to a list and print it
print(list(even_numbers))  # Output: [2, 4, 6]

In this example:

  • The is_even() function checks whether a number is divisible by 2.
  • The filter() function applies this condition to the list numbers and returns only the even numbers.

Using lambda with filter():

You can also use a lambda function to simplify the filtering logic.

# Use filter() with a lambda function to filter odd numbers
odd_numbers = filter(lambda x: x % 2 != 0, [1, 2, 3, 4, 5, 6])
print(list(odd_numbers))  # Output: [1, 3, 5]

In this example:

  • The lambda function lambda x: x % 2 != 0 is used to filter out odd numbers, providing a more compact way to write the condition.

10.1.3 The reduce() Function

The reduce() function is part of the functools module and is used to apply a function cumulatively to the items of an iterable, reducing the iterable to a single value. It repeatedly applies a reducing function (e.g., summing, multiplying) to pairs of elements until only one value remains.

Syntax of reduce():

from functools import reduce
reduce(function, iterable, initializer=None)
  • function: A function that takes two arguments and returns a single value.
  • iterable: The sequence of elements to reduce.
  • initializer: (Optional) An initial value to start the reduction.

Example: Using reduce() to Multiply All Numbers in a List:

from functools import reduce

# Define a function to multiply two numbers
def multiply(x, y):
    return x * y

# List of numbers
numbers = [1, 2, 3, 4, 5]

# Use reduce() to multiply all numbers in the list
product = reduce(multiply, numbers)

print(product)  # Output: 120

In this example:

  • The multiply() function is applied cumulatively to the list of numbers, multiplying them together to produce a single product.
  • The reduce() function reduces the entire list to the result 120.

Using lambda with reduce():

You can also use a lambda function with reduce() for more concise code.

# Use reduce() with a lambda function to sum all numbers in a list
total_sum = reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])
print(total_sum)  # Output: 15

In this example:

  • The lambda function lambda x, y: x + y is used to sum the numbers in the list.
  • The reduce() function reduces the list to the sum 15.

10.1.4 Combining map(), filter(), and reduce()

These functions can be combined to create powerful and efficient data processing pipelines. For example, you might use map() to transform data, filter() to remove unwanted elements, and reduce() to compute a final result from the filtered data.

Example: Combining map(), filter(), and reduce():

from functools import reduce

# List of numbers
numbers = [1, 2, 3, 4, 5, 6]

# Step 1: Use map() to square each number
squared_numbers = map(lambda x: x ** 2, numbers)

# Step 2: Use filter() to keep only numbers greater than 10
filtered_numbers = filter(lambda x: x > 10, squared_numbers)

# Step 3: Use reduce() to sum the remaining numbers
total_sum = reduce(lambda x, y: x + y, filtered_numbers)

print(total_sum)  # Output: 61

In this example:

  • map() squares each number in the list.
  • filter() keeps only the squared numbers greater than 10.
  • reduce() sums the remaining filtered numbers, producing a final result of 61.

10.1.5 Summary

  • map(): Applies a function to every element of an iterable and returns a new iterable with the transformed elements.
  • filter(): Filters an iterable by applying a function that returns True or False for each element, keeping only the elements that return True.
  • reduce(): Applies a function cumulatively to the elements of an iterable, reducing it to a single value.

By using map(), filter(), and reduce(), you can process sequences of data in a concise and functional way, often avoiding the need for manual loops and making your code more readable and efficient. These functions are particularly useful for data transformation, filtering, and aggregation tasks.

Read more