# #Day13 - Map, Filter, Sorted, and Reduce in Python

In this article, we will be discussing the following functions in Python

- map
- filter
- sorted
- reduce

In yesterday's article (Day 12), we discussed Lambda Functions in Python. Lambda functions can be used with the above-mentioned functions.

We will be using the following list

```
import random
pairs = [(random.randint(0,10),random.randint(0,10))
for _ in range(5)]
```

It is basically a list of pairs of random integers

### Map()

The map function takes in an iterable (list, tuple, etc) and a function as parameters. It calls the function on each element in the iterable.

```
map(function,iterable)
```

Consider the following code snippet

```
def map_func(elem):
return elem[0]*elem[1]
mapped_lst = map(map_func, pairs)
```

The function **map_func** takes in a tuple as a parameter and returns the product of the first two elements. Now, if we want to use the **map_func** on each element in our previously defined list **lst**, we would pass **lst** as the iterable and **map_func** as the function to the **map** function.

Notice, we are only passing the function's name. Each element in the list **lst** is passed as the parameter

map returns a map object which is also iterable. We could either use a for loop to iterate over the returned object or just convert it to a list using **list()**

```
print(list(mapped_lst))
```

```
Input: [(1, 8), (3, 9), (10, 10), (9, 4), (4, 7)]
Output: [8, 27, 100, 36, 28]
```

#### Using map with lambda functions

Instead of defining a function **map_func**, we could just use an anonymous/lambda function. You can check out my article on Day 12 to learn more about lambda functions

```
mapped_lst = map(lambda elem: elem[0]*elem[1], pairs)
```

Combining map() with lambda functions makes it look cleaner.

### Filter()

The **filter()** function essentially filters elements in a list. A function returning a boolean value along with an iterable are passed as parameters to the **filter()** function. Like the **map()** function, the **filter()** function also executes on all the elements in an iterable. It only returns the element if the function passed as a parameter returns True. If this is confusing, take a look at the example below

```
def filter_func(elem):
max_elem = max(elem[0] , elem[1])
return max_elem > 7
filter_lst = filter(filter_func, pairs)
```

The **filter_func()** returns true if the maximum element in the tuple is greater than 7. This function is executed on all the elements of the list **lst**. Only the elements with a number greater than 7 return True and are returned. The **filter()** function returns a filter object. Similar to the map object, the filter object is also iterable and can be converted to a list.

```
print(list(filter_lst))
```

```
Input: [(7, 10), (0, 0), (9, 2), (4, 5), (2, 8)]
Output: [(7, 10), (9, 2), (2, 8)]
```

#### Filter with lambda functions

```
filter_lst = filter(lambda elem: elem[0]*elem[1] > 7, pairs)
```

### Sorted()

The **Sorted()** is pretty self-explanatory, it is used to sort an iterable. It can directly be used on a list of numbers or strings.

```
strings = ["aa" , "cc" , "bb"]
sorted_lst = sorted(strings)
rev_sorted_lst = sorted(strings, reverse = True)
```

You can set the **reverse** parameter to True if you want to sort it in descending order

```
Input: ['aa', 'cc', 'bb']
Output: ['aa', 'bb', 'cc']
Output: ['cc', 'bb', 'aa']
```

#### Sorted with custom key

What if we want to sort our list of pairs?

We can specify the function on which we want to sort our iterable. Let's say we want to sort based on the product of both the numbers in the tuple.

```
def key_func(elem):
return elem[0]*elem[1]
sorted_pairs = sorted(pairs, key = key_func)
rev_sorted_pairs = sorted(pairs, key = key_func,reverse = True)
```

**key_func()** returns the product of the two numbers in the pair. The **key** parameter in the **sorted** function is set to the our **key_func**. Based on the integer returned by the **key_func**, the list is sorted. The function we use to sort has to return an integer.

```
Input: [(1, 6), (3, 0), (5, 7), (6, 10), (4, 7)]
Output: [(3, 0), (1, 6), (4, 7), (5, 7), (6, 10)]
Output: [(6, 10), (5, 7), (4, 7), (1, 6), (3, 0)]
```

#### Sorted with lambda function

Let's say we have a list of strings and we want to sort it in ascending order based on the length of the string.

```
lst = ['a' , 'aba' , 'asd' , 'sdsds' , 'asdasdasfasf', 'asasa']
sorted_lst = sorted(lst, key = lambda elem: len(elem))
rev_sorted_lst = sorted(lst, key = lambda elem: len(elem),reverse = True)
```

We create a lambda function that basically returns the length of the string, this is used to sort the list.

```
Input: ['a', 'aba', 'asd', 'sdsds', 'asdasdasfasf', 'asasa']
Output: ['a', 'aba', 'asd', 'sdsds', 'asasa', 'asdasdasfasf']
Output: ['asdasdasfasf', 'sdsds', 'asasa', 'aba', 'asd', 'a']
```

### Reduce()

The **reduce** functions works in the following way:

- The function passed is called on the first two elements and a value is returned
- The function is called on the value returned last time and the third element
- The function is called on the value returned previously and the fourth element
- and so on

In the final function call, the value is returned. Unlike **map()*, **filter()** and **sorted()**, **reduce()** returns a single value and not an iterable.

If it is confusing, look at the example below

```
from functools import reduce
lst = [7,10,2,6,1,5]
def reduced_func(x,y):
return x +y
reduced_value = reduce(reduced_func,lst)
```

**reduced_func** returns the sum of two numbers. To use the **reduce()** function, we need to import it from the **functools** library.

- First
**reduced_func (7,10)**is called. This returns 17 - Then **reduced_func(17,2) is called. This returns 19
- Then **reduced_func(19,6) is called.

After the first function call, the function is called on the value returned in the previous function call and the next element in the list.

```
Input: [7, 10, 2, 6, 1, 5]
Output: 31
```

Finally, the last function call's value is returned.

#### Reduce() function with lambda

```
reduced_value = reduce(lambda x,y: x+y,last)
```