Higher Order Functions in Python — map(), filter(), and reduce()

Original article was published on Artificial Intelligence on Medium

Reduce Elements

The third function that we’re going to discuss is the reduce() function. Unlike the map() and filter() functions which are built-in functions, the reduce() function is available in the functools module. The reduce() function takes a function and an iterable. The reduce() function will apply the function to the elements of the iterable using the rolling result cumulatively before it arrives at a final output value.

For example, if the iterable is [a, b, c, d], we’ll get the result of a certain operation between a and b, say the result is X, and the next step will be to get the result for X and c to produce Y, and Y and d will produce the final output value. Let’s see how reduce() works with the following example.

There are a few things to note.

  • We use a lambda function that adds two numbers. Importantly, the function that can be passed to the reduce() function needs to take exactly two elements.
  • The last argument in the reduce() function call is termed initial, which sets the initial value for the cumulative operation. In the example below, the sum(primes) is 41. With the initials of 1 and 5, the final results are 42 and 46, respectively.
>>> # Import the needed module
>>> from functools import reduce
>>> # Create a list for reducing
>>> primes = [2, 3, 5, 7, 11, 13]
>>> # Reduce the list
>>> total0 = reduce(lambda x, y: x + y, primes, 1)
>>> total0
>>> total1 = reduce(lambda x, y: x + y, primes, 5)
>>> total1

The above code is a very trivial example on reduce(), because as indicated above, we can simply use the sum() function to calculate the total. So the question is that what the reduce() function can be used in a more realistic scenario. Consider the following example that uses the reduce() function to calculate factorials (e.g., 3! = 6, 4! = 10). Pretty cool, right?

>>> # Define a function that uses the reduce() function
>>> def factorial(n):
... return 1 if n < 2 else reduce(lambda x, y: x*y, range(1, n+1))
>>> # Create a list consisting of factorials
>>> factorials = [factorial(x) for x in range(10)]
>>> factorials
[1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880]

As a side note, the two lambda functions are basic operations that are actually available in the operator module. See the pertinent examples below.

>>> # Import the operator functions
>>> from operator import add, mul
>>> # Comparisons
>>> reduce(lambda x, y: x+y, [2, 3, 4])
>>> reduce(add, [2, 3, 4])
>>> reduce(lambda x, y: x*y, [1, 2, 3])
>>> reduce(mul, [1, 2, 3])