Python – Map, Reduce, Filter in 2 Minutes for Data Science Beginners

Now, let’s try the same example through the “map” approach.

Map approach syntax: map(operation_to_perform, list_of_inputs_for_the_operation)

Here “operation_to_perform” may be described as the operation that we want to perform to a list or other form of input. The second part of the map function takes in the input in the form of a list, tuple, etc. The earlier operation described by “operation_to_perform” is instantiated. Let’s look into an example to see this in practice.

But… wait for a second!

Python’s official docs define lambda as:

Lambda expressions (sometimes called lambda forms) are used to create anonymous functions. The expression lambda parameters: expression yields a function object.

I get it! This may feel a bit complex. But look at our previous example. We wanted to square all the items in our list, right? Well, if that’s the case, wouldn’t it make sense to define a function that tells the list to square themselves? This is where lambdas come in. We use lambda functions when we require a nameless (or an anonymous) function for a short period of time.

Think about this! We normally define functions by doing something like this:

def function_name():
    # body

But lambdas are a “one-time-use” function with no name. They perform a quick operation while using map() or filter() functions. And once the job’s done, that’s it! They don’t exist.

But, when to use def() and when should you use lambdas?

There are interesting Stackoverflow discussions/answers on the topic. You can check “Which is more preferable to use: lambda functions or nested functions (‘def’)?“.

Anyway, coming back to our map() operation, let’s try another example with a tuple.

a = (1,2,3,4)
out = map(lambda a: a**2, a)
out

def squared(x):
    return x**2
def cubed(x):
    return x**3
functions = [squared, cubed]
for i in range(5):
    li = list(map(lambda x: x(i), functions))
    print(li)

Reduce

The reduce operation takes a condition and applies that condition to input such that our output is “reduced” into a single value.

Let’s try the “normal” way first. We want to find the product of all the values in our list. In a normal case, we’d do something like this:

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

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

Filter

As the name suggests, a filter method literally filters out the elements as per the given condition. The working procedure of a filter method is fairly straightforward. The function checks for a certain condition and decides whether each of the elements in the input fulfils the given condition or not. After checking the condition, the function verifies true or false accordingly.

Syntax:

filter(function, input)
Parameters:
function: function that tests if each element of an
input true or not.
input: an input that needs to be filtered, it can
be sets, lists, tuples, or containers of any iterators.
Returns:
returns an iterator that is already filtered.

Suppose we have a list of numbers and we want to filter “small” numbers. In this case, small means numbers that are less than 5. How do you apply “filter” to get the result?

li = [1,2,3,4,5,6,7,8,9,10]
small = list(filter(lambda x: x < 5, li))
print(small)

Output:

[1,2,3,4]

Easy isn’t it? Let’s try another example where we filter only the negative numbers.