      Learn

In this exercise, we will review the map(), filter(), and reduce(), higher-order functions provided by Python. These functions accept an iterable and a processing function as arguments and return another iterable. Similar to the exercise on lambdas, this section should serve as a refresher. You may recognize these functions from intermediate Python content. If you need more than a quick refresher and feel stuck at all during this exercise, we recommend you review this article as an aid.

The first function we will look at is filter(), which converts the following imperative code:

nums = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

# filter_values is not a higher-order function
def filter_values(predicate, lst):

# Mutable list required because this example is imperative, not declarative
ret = []
for i in lst:
if predicate(i):
ret.append(i)
return ret

filtered_numbers = filter_values(lambda x: x % 2 == 0, nums)

print(filtered_numbers)

# This will output the list: [2, 4, 6, 8, 10]

into the following declarative code:

nums = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

filtered_numbers = filter(lambda x: x % 2 == 0, nums)

print(tuple(filtered_numbers))

# This will output the tuple: (2, 4, 6, 8, 10)

map() converts the following imperative code:

nums = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

def mapper(function, lst):
ret = []
for i in lst:
ret.append(function(i))
return ret

mapped_numbers  = mapper(lambda x: x*x, nums)

print(tuple(mapped_numbers))

# This will output: (1, 4, 9, 16, 25, 36, 49, 64, 81, 100)

Into the following declarative code:

numbers = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

mapped_numbers = map(lambda x: x*x, numbers)

print(tuple(mapped_numbers))

# This will also output: (1, 4, 9, 16, 25, 36, 49, 64, 81, 100)

The reduce() function accepts an iterable and a two-parameter function (no more than two) known as an *”accumulator”*. It uses the accumulator to recursively process the contents of the iterable and “reduce” them to one value. An example application of reduce() would be to compute the sum of all numbers in a list.

The sum of all elements in a tuple written imperatively:

nums = (2, 6, 7, 9, 1, 4, 8)

sum = 0

for i in nums:
sum += i

print(sum) # Output: 37

Using reduce() to find the sum declaratively:

"""
In Python 3, the reduce() function has been moved to the functools library, so we need to import it before we can use it.
"""
from functools import reduce

nums = (2, 6, 7, 9, 1, 4, 8)

reduced_nums = reduce(lambda x, y: x + y, nums) # reduced_nums is a number

print(reduced_nums) # Output: 37

The lambda in reduce() requires exactly two parameters.

Higher-order functions are powerful tools that you can use to significantly shorten code, thereby leading to cleaner and more concise solutions. In later exercises, we will explore how to combine these functions.

### Instructions

1.

Use filter() to remove odd numbers from tuple nums. Print your result using the following line of code:

print(tuple(filtered_numbers))
2.

Using map() multiply all of the elements of nums by 3. Print your result with the following line of code:

print(tuple(mapped_numbers))
3.

Find the sum of all the elements in the tuple nums using the reduce() function. Print your result with the following line of code:

print(sum)