Lambda function is a special one-liner function defined to perform a particular task. Since, lambda functions are not provided with any function name, hence are also as Anonymous Function.

Unlike normal functions, lambda functions are not defined using def keyword rather they are defined with lambda keyword in Python.

Syntax

lambda parameter_list : expression

In the above syntax, keyword lambda denotes that above function is a lambda function.

To see the difference between normal function and lambda function, let’s use one problem statement.

Program : To print cube of a number using normal function

def findcube(a):
    return a**3 
print(findcube(3))

O/P : 27

Here, we have defined a lambda function to evaluate the cube of a number ‘n’, ‘f’ is basically a function name to which this lambda expression has been assigned.

Lambda function can contain only one expression and upon evaluating the expression they implicitly return the result. This is the reason why lambda functions in Python does not use return statement.

Let’s check out a program to print the product of two integers.

Program : To print the sum of two integers.

f = lambda num1, num2: num1 + num2 # our lambda function
print(f(10,20)) # calling our lambda function with num1 = 10, num2 = 20

O/P : 30

Extra Gyan !

We can use lambda function inside a normal function as well.

Using lambda function with built-in functions

Using lambda with filter() function

As the name itself suggests that, filter() function is used to filter out some elements of a given sequence depending on the result. Though, we can pass normal functions to filter function as well, passing a lambda function to filter() is considered more elegant.

Syntax

filter(function, sequence)

Here, sequence may denote any of list, tuple, dictionary, or set.

Program : To filter out the odd numbers from a given list using lambda function.

list_of_integers = [23, 42, 12, 14, 15, 25, 20]
result = list(filter(lambda n: (n%2==1), list_of_integers))
print(result)

O/P : [23, 15, 25]

In line-2, we have used filter() function to keep note of all the odd integers in the list. We have passed two parameters to filter() function – first one is the lambda itself, that evaluates odd-checker logic for each element of the sequence, and second one is the list itself.

Extra Gyan !

Results obtained from filter() function needs to be explicitly type-casted.

Using lambda with map() function

Working of map() function is same as that of filter() function, however it acts on each element of the given sequence and modifies it.

Syntax

map(function, sequence)

Here, sequence may denote any of list, tuple, dictionary, or set, function is used to modify the existing elements of a sequence which can be stored to other sequence as well.

Program : To square each elements of the given list using lambda function

lst = [2, 4, 8, 10, 20]
res = list(map(lambda x: x**2, lst))
print(res)

O/P : [4, 16, 64, 100, 400]

In the above code, we have lst as our list(sequence) served to lambda function to do the operation. If result is not type-casted, then map object will be returned by default. One thing to note is that we can use map() function on two or more lists(or any other) if they are of same size.

Using lambda with reduce() function

reduce() function provides a single value result after processing elements (one by one) of the sequence according to the function specified.

Syntax

reduce(function, sequence)

Here, sequence may denote any of list, tuple, dictionary, or set, function is used to modify the existing elements of a sequence which can be stored to other sequence as well.

reduce() function belongs to functools module in Python, hence needs to be imported.

from functools import *

Program : To find the sum of elements of the given list using lambda function

from functools import *
lst = [2, 4, 8, 10, 20]
res = reduce(lambda x, y: x + y, lst)
print(res)

O/P : 44

In the above code, we have lst as our list(sequence) served to lambda function to do the operation.

Here’s, how it computes :

-> 2 + 4 = 6
-> 6 + 8 = 14
-> 14 + 10 = 24
-> 24 + 20 = 44

So, that’s all about Lambda Function in Python.