# Python Map, Filter and Reduce functions

These are three functions which facilitate a functional approach to programming. We will discuss them one by one and understand their use cases.

## 1. Python Map function

The map() function applies a given function to each item of an iterable (list, tuple etc.) and returns a list of the results. If additional iterable arguments are passed, function must take that many arguments and is applied to the items from all iterables in parallel. With multiple iterables, the iterator stops when the shortest iterable is exhausted.

``````map(function, iterable, ...)
``````
• function - map() passes each item of the `iterable` to this function.
• iterable - iterable which is to be mapped

##### Map Function
You can pass more than one `iterable` to the map() function.

Here is example:

``````map(function_to_apply, list_of_inputs)
``````

Most of the times we want to pass all the list elements to a function one-by-one and then collect the output. For instance:

``````items = [1, 2, 3, 4, 5]
squared = []
for i in items:
squared.append(i**2)
print(squared)

# output: [1, 4, 9, 16, 25]
``````

`Map` allows us to implement this in a much simpler and nicer way. Here you go:

``````items = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, items))
print(squared)

# output: [1, 4, 9, 16, 25]
``````

Most of the times we use lambdas with `map` so I did the same. Instead of a list of inputs we can even have a list of functions!

``````def multiply(x):
return (x*x)
return (x+x)

for i in range(5):
value = list(map(lambda x: x(i), funcs))
print(value)

# Output:
# [0, 0]
# [1, 2]
# [4, 4]
# [9, 6]
# [16, 8]
``````

Another example:

``````list('sat')
# Output: ['s', 'a', 't']

words = ['sat', 'bat', 'cat', 'mat']
list(map(list, words))

# Output: [['s', 'a', 't'], ['b', 'a', 't'], ['c', 'a', 't'], ['m', 'a', 't']]
``````

### Passing more than one iterable to map() function

If additional `iterable` arguments are passed, function must take that many arguments and is applied to the items from all iterables in parallel. With multiple iterables, the iterator stops when the shortest iterable is exhausted.

``````list1 = [4, 5, 6]
list2 = [5, 6, 7]
list(map(lambda n1, n2: n1+n2, list1, list2))

# Output: [9, 11, 13]
``````

##### Map Function
With multiple iterables, the iterator stops when the shortest iterable is exhausted.

``````list1 = [4, 5, 6, 7, 8, 9]
list2 = [5, 6, 7]
list(map(lambda n1, n2: n1+n2, list1, list2))

# Output: [9, 11, 13]
``````

## 2. Python Filter function

The `filter()` function takes a function and a sequence as arguments and returns an iterable, only yielding the items in sequence for which function returns True. If None is passed instead of a function, all the items of the sequence which evaluates to False are removed. The syntax of the `filter()` is as follows:

syntax: filter(function or None, iterable) --> filter object

Here is an example:

Python3

``````>>>
>>> def is_even(x):
...     if x % 2 == 0:
...         return True
...     else:
...         return False
...
>>>
>>> f = filter(is_even, [1, 3, 10, 45, 6, 50])
>>>
>>> f
<filter object at 0x7fcd88d54eb8>
>>>
>>>
>>> for i in f:
...     print(i)
...
10
6
50
>>>
``````

To produce the result at once we can use the `list()` function.

Python3

``````>>> list(filter(is_even, [1, 3, 10, 45, 6, 50]))
[10, 6, 50]
>>>
>>> list(filter(None, [1, 45, "", 6, 50, 0, {}, False])) # function argument is None
[1, 45, 6, 50]
>>>
``````

In Python 2, `filter()` returns an actual list (which is not the efficient way to handle large data), so you don’t need to wrap `filter()` in a `list()` call.

Python2

``````>>>
>>> filter(is_even, [1, 3, 10, 45, 6, 50])
[10, 6, 50]
>>>
``````

Here are some other examples.

Python3

``````>>>
>>> filter(lambda x: x % 2 != 0, [1, 3, 10, 45, 6, 50]) # lambda is used in place of a function
[1, 3, 45]
>>>
>>>
>>> list(filter(bool, [10, "", "py"]))
[10, 'py']
>>>
>>>
>>> import os
>>>
>>> list(filter(lambda x: x.startswith(".") != True, os.listdir(".") )) # display all files in the current directory (except the hidden ones)
>>>
``````

##### Filter Function
As the name suggests, `filter` function creates a list of elements for which a function returns true.

Here is a short and concise example:

``````number_list = range(-5, 5)
less_than_zero = list(filter(lambda x: x < 0, number_list))
print(less_than_zero)

# Output: [-5, -4, -3, -2, -1]
``````

The filter resembles a for loop but it is a builtin function and faster.

Note: If map & filter do not appear beautiful to you then you can read about `list/dict/tuple comprehensions`.

## 3. Python Reduce function

The `reduce()` function accepts a function and a sequence and returns a single value calculated as follows:

• Initially, the function is called with the first two items from the sequence and the result is returned.

• The function is then called again with the result obtained in step 1 and the next value in the sequence. This process keeps repeating until there are items in the sequence. e.g in step 2 it will be 3th item in the sequence, in step 3 it will be 4th item in sequence.

The syntax of the `reduce()` function is as follows:

syntax: reduce(function, sequence[, initial]) -> value

When the `initial` value is provided, the function is called with the initial value and the first item from the sequence.

In Python 2, `reduce()` was a built-in function. However, in Python 3, it is moved to functools module. Therefore to use it, you have to first import it as follows:

``````from functools import reduce # only in Python 3
``````

##### Reduce Function
`Reduce` is a really useful function for performing some computation on a list and returning the result. It applies a rolling computation to sequential pairs of values in a list.

Here is an example which adds all the items in the list:

``````from functools import reduce

def do_sum(x1, x2): return x1 + x2

reduce(do_sum, [1, 2, 3, 4])
# output: 10
``````

This `reduce()` call perform the following operation:

``````(((1 + 2) + 3) + 4) => 10
``````

For example, if you wanted to compute the product of a list of integers. So the normal way you might go about doing this task in python is using a basic for loop:

``````product = 1
list = [1, 2, 3, 4]
for num in list:
product = product * num

# product = 24
``````

Now let’s try it with `reduce`:

``````from functools import reduce
product = reduce((lambda x, y: x * y), [1, 2, 3, 4])
print(product)

# Output: 24
``````

source:

http://book.pythontips.com/en/latest/map_filter.html

https://thepythonguru.com/python-builtin-functions/reduce/