Varun Dey

23 || Jr. Software Engineer, Symantec Corp || Loves everything about web || Backend web developer || Puntastic
Chennai, India

Functional Programming in Python - II
0 Comments

In my last blog, we saw how higher order functions work in Python using lambda and filter. The filter method takes a list object and another function and another function and it uses this function to filter out the elements from a list. In this post, we learn about a new(read awesome) higher order function called map and reduce

map

Just like filter, the map function takes in two arguments; a function and a list. Similar to filter, it goes through the list but unlike filter, it doesn’t throw the objects away, rather it transforms them into a new list.

Let us see a simple function

li = list(range(0,5))
new_li = []
def squared(x):
    for i in x:
        new_li.append(i**2)
    return new_li

print sqared(li)
# Output
[0, 1, 4, 9, 16]

Boo boring!! code base wants the functional way..

Now let’s see how we can do it in functional way

li = list(range(0,5))
def squared(x):
    return x**2

print map(squared, li)
# Output
[0, 1, 4, 9, 16]

Now let’s see how if can make it one-liner using lambda

li = list(range(0,5))
print map(lambda x: x**2, li)
# Output
[0, 1, 4, 9, 16]

Just gorgeous right?! With the help of map, we have just compressed the whole function in a single line. It is, however, important to note that the map function always returns a list type just like the filter.

reduce

Now we will talk about another higher order function called reduce. The reduce function is a little less obvious in its intent. This function reduces a list to a single value by combining elements via a supplied function. Similar to map and filter, it takes two arguments; a function and a list. It is, however, notable that the return type of reduce is not always list. Let us see what we mean by that. But first let’s write a normal function in all its glory:

li = list(range(1,5))
prod = 1
def product(x):
    for i in x:
        prod = prod * i
    return prod
print product(li)
#Output
24

Now the functional way

print reduce(lambda x,y: x*y, list(range(1,5)))
# Output
24

BAM! Now let us see another example of reduce:

fox = ['What ', 'does ', 'the ', 'fox ', 'say', '?']
print reduce(lambda x,y: x+y, fox)
# Output
# What does the fox say?

Over here, lambda function takes two arguments x and y. The x is what it iterates from the list and y is what is returned from lambda. Like so:

Iteration x y x+y Current List
I “What “ “does “ “What does “ [‘What does ‘, ‘the ‘, ‘fox ‘, ‘say’, ‘?’]
II “What does “ “the “ “What does the “ [‘What does the ‘, ‘fox ‘, ‘say’, ‘?’]
III “What does the “ “fox “ “What does the fox “ [‘What does the fox ‘, ‘say’, ‘?’]
IV “What does the fox “ “say “ “What does the fox say” [‘What does the fox say’, ‘?’]
V “What does the fox say” ”?” “What does the fox say?” [‘What does the fox say?’]

If you don’t see the beauty in this, I really am tending to believe that you are an alien and you have devised a super neat and better trick on your planet.

That concludes the Functional Programming with Python. FPs take a bit to master on but once you start using it, you will see its application practically everywhere in your codebase.

Happy hacking!