Functional Programming in Python

Domains: Python

Functional Programming — is the process of building software by composing pure functions, avoiding shared state, mutable data, and side-effects.


In Python, anonymous function means that a function is without a name. As we already know that def keyword is used to define the normal functions and the lambda keyword is used to create anonymous functions. It has the following syntax:

lambda arguments: expression

This function can have any number of arguments but only one expression, which is evaluated and returned. One is free to use lambda functions wherever function objects are required. You need to keep in your knowledge that lambda functions are syntactically restricted to a single expression. It has various uses in particular fields of programming besides other types of expressions in functions. Let’s look at this example and try to understand the difference between a normal def defined function and lambda function. This is a program that returns the cube of a given value:

# Python code to illustrate cube of a number  
# showing difference between def() and lambda(). 
def cube(y): 
    return y*y*y; 
g = lambda x: x*x*x 


  • Without using Lambda : Here, both of them returns the cube of a given number. But, while using def, we needed to define a function with a name cube and needed to pass a value to it. After execution, we also needed to return the result from where the function was called using the return keyword.
  • Using Lambda : Lambda definition does not include a “return” statement, it always contains an expression which is returned. We can also put a lambda definition anywhere a function is expected, and we don’t have to assign it to a variable at all. This is the simplicity of lambda functions.


The filter() method filters the given sequence with the help of a function that tests each element in the sequence to be true or not. It has the following syntax:

filter(function, sequence)
function: function that tests if each element of a 
sequence true or not.
sequence: sequence which needs to be filtered, it can 
be sets, lists, tuples, or containers of any iterators.
returns an iterator that is already filtered.
# function that filters vowels 
def fun(variable): 
    letters = ['a', 'e', 'i', 'o', 'u'] 
    if (variable in letters): 
        return True
        return False
# sequence 
sequence = ['g', 'e', 'e', 'j', 'k', 's', 'p', 'r'] 
# using filter function 
filtered = filter(fun, sequence) 
print('The filtered letters are:') 
for s in filtered: 


The filtered letters are:

It is normally used with Lambda functions to separate list, tuple, or sets.

# a list contains both even and odd numbers.  
seq = [0, 1, 2, 3, 5, 8, 13] 
# result contains odd numbers of the list 
result = filter(lambda x: x % 2 != 0, seq) 
# result contains even numbers of the list 
result = filter(lambda x: x % 2 == 0, seq) 


[1, 3, 5, 13]
[0, 2, 8]


map() function returns a map object(which is an iterator) of the results after applying the given function to each item of a given iterable (list, tuple etc.)

Syntax :

map(fun, iter)

Parameters :

fun : It is a function to which map passes each element of given iterable.
iter : It is a iterable which is to be mapped.

You can pass one or more iterable to the map() function.

Returns :

Returns a list of the results after applying the given function  
to each item of a given iterable (list, tuple etc.) 

The returned value from map() (map object) then can be passed to functions like list() (to create a list), set() (to create a set).

# Python program to demonstrate working 
# of map. 
# Return double of n 
def addition(n): 
    return n + n 
# We double all numbers using map() 
numbers = (1, 2, 3, 4) 
result = map(addition, numbers) 

Output :

[2, 4, 6, 8]

We can also use lambda expressions with map to achieve above result.

# Double all numbers using map and lambda 
numbers = (1, 2, 3, 4) 
result = map(lambda x: x + x, numbers) 

Output :

[2, 4, 6, 8]


The reduce(fun,seq) function is used to apply a particular function passed in its argument to all of the list elements mentioned in the sequence passed along.This function is defined in “functools” module.

  • At first step, first two elements of sequence are picked and the result is obtained.
  • Next step is to apply the same function to the previously attained result and the number just succeeding the second element and the result is again stored.
  • This process continues till no more elements are left in the container.
  • The final returned result is returned and printed on console.
# python code to demonstrate working of reduce() 
# importing functools for reduce() 
import functools 
# initializing list 
lis = [ 1 , 3, 5, 6, 2, ] 

# using reduce to compute sum of list 
print ("The sum of the list elements is : ",end="") 
print (functools.reduce(lambda a,b : a+b,lis)) 
# using reduce to compute maximum element from list 
print ("The maximum element of the list is : ",end="") 
print (functools.reduce(lambda a,b : a if a > b else b,lis)) 


The sum of the list elements is : 17
The maximum element of the list is : 6

Similar pages

Page structure






with Statements




Functional Programming


pass Statements