Map, Filter and Reduce Functions in Python

Map is a function that works like list comprehensions and for loops. It is used when you need to map or implement functions on various elements at the same time.

The syntax of the map function looks as shown below:

map(function,iterable object)

• The function here can be a lambda function or a function object.

• The iterable object can be a string, list, tuple, set or dictionary.

Let’s look a few examples to understand a map function.

list_numbers = (1,2,3,4)
sample_map = map(lambda x: x*2, list_numbers)
print(list(sample_map))

In the code above, you are using a map function to create a list from a tuple with each of its elements doubled.

In the implementation of the map function, the lambda function lambda x: x*2 would return a lambda object, but the map handles the job of passing each element of the iterable to the lambda object and storing the value obtained in a map object. Using the list function on the map object, you finally obtain the output list. 

def multi(x):
    return x*2
list_numbers = [1,2,3,4]
sample_map = map(multi, list_numbers)
print(list(sample_map))

The difference between the previous code and this above-mentioned code is that instead of applying a lambda function, you can use the function object also. multi returns a function object just like the lambda function used earlier. 

'Filter' is a similar operation, but it requires the function to look for a condition and then returns only those elements from the collection that satisfy the condition. 'Reduce' is an operation that breaks down the entire process into pair-wise operations and uses the result from each operation, with the successive element. 

The syntax of the filter function looks as shown below:

filter(function,iterable object)

•  The function object passed to the filter function should always return a boolean value.

• The iterable object can be a string, list, tuple, set or dictionary.

Let's take a look at an example to understand filter function:

name = ['Harshit','Aman','Akash']
list(filter(lambda x:x.startswith("A"), name))

In the code above, you are using a filter function to return the names that start with the character "A".In the implementation of the filter function, the lambda function lambda x: x.startswith["A"] would return a lambda object, and the filter function would filter out the names that are starting with the character "A".

Now, let us take a look at the syntax of reduce function, as shown below:

reduce(function,iterable object)

• The function object passed to the reduce function decides what expression is passed to the iterable object.
• The iterable object can be a string, list, tuple, set or dictionary.
• Also, reduce function produces a single output.

NOTE: One important thing to note is that reduce function needs to imported from the functools library.

from functools import reduce

Let's take a look at an example to understand reduce  function:

from functools import reduce
list_1 = ['harshit','aman']
reduce(lambda x,y: x + y,list_1)

In the code snippet given above, you are importing functools library is being imported to access reduce function. In the implementation of the reduce function, the lambda function x,y : x+y, list_1 is appending two objects remember here if the objects are strings it appends them if the objects are numbers it adds them. Now, the reduce function will convert the list of string into a single list, the output is given below.

'harshitaman'

You can find more examples of map, filter and reduce functions in the video below: