DEV Community

loading...
Cover image for #Day13 - Map, Filter, Sorted, and Reduce in Python

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

rahulbanerjee99 profile image Rahul Banerjee Originally published at realpythonproject.com ・4 min read

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)]
Enter fullscreen mode Exit fullscreen mode

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)
Enter fullscreen mode Exit fullscreen mode

Consider the following code snippet

def map_func(elem):
    return elem[0]*elem[1]

mapped_lst = map(map_func, pairs)
Enter fullscreen mode Exit fullscreen mode

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))
Enter fullscreen mode Exit fullscreen mode
Input: [(1, 8), (3, 9), (10, 10), (9, 4), (4, 7)]
Output: [8, 27, 100, 36, 28]
Enter fullscreen mode Exit fullscreen mode

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)
Enter fullscreen mode Exit fullscreen mode

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)
Enter fullscreen mode Exit fullscreen mode

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))
Enter fullscreen mode Exit fullscreen mode
Input: [(7, 10), (0, 0), (9, 2), (4, 5), (2, 8)]
Output: [(7, 10), (9, 2), (2, 8)]
Enter fullscreen mode Exit fullscreen mode

Filter with lambda functions

filter_lst = filter(lambda elem: elem[0]*elem[1] > 7, pairs)
Enter fullscreen mode Exit fullscreen mode

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)
Enter fullscreen mode Exit fullscreen mode

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']
Enter fullscreen mode Exit fullscreen mode

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)
Enter fullscreen mode Exit fullscreen mode

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)]
Enter fullscreen mode Exit fullscreen mode

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)
Enter fullscreen mode Exit fullscreen mode

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']
Enter fullscreen mode Exit fullscreen mode

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)
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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

Reduce() function with lambda

reduced_value = reduce(lambda x,y: x+y,last)
Enter fullscreen mode Exit fullscreen mode

Discussion (2)

pic
Editor guide
Collapse
aminnairi profile image
Amin

Hi Rahul and thanks for your article!

I guess you made a mistake here.

map(iterable, function)
Enter fullscreen mode Exit fullscreen mode

Isn't it the function first, and then the iterable?

map(function, iterable)
Enter fullscreen mode Exit fullscreen mode
Collapse
rahulbanerjee99 profile image
Rahul Banerjee Author

Hi Amin! Thanks for pointing it out! I will update it