A function without a name is called ‘anonymous function’ or lambda functions in Python Programming language.

Using Lambda functions the correct way

Consider a normal function to return the square of two numbers:

def sqaure(x):
    return x*x

The same function can be written as a lambda function as:\

lambda x: x*x

• Here , the keyword ‘lambda’ is used to define the anonymous function.
• After that , we have written an argument of the function, ie , ‘x’.
• Then , colon(:) represents the beginning of the function that contains an expression x*x.

Basic Syntax of lambda function

lambda argument_list : expression

lambda functions returns a function , so they can be assigned to a variable as:

f = lambda x: x*x

and the function can be used as:

result = f(5)

the value 5 is passed as an argument to the lambda function and the square of the value is returned and stored in result.

Lambda function to calculate the sum of two numbers :

f = lambda x,y : x+y
result = f(10,2)
print(result)

The Output of this code will be 12.

Lambda function to find the biggest of the two numbers:

big = lambda x,y : x if x>y else y
a = int(input('Enter the first number:'))
b = int(input('Enter the second number:'))

result = big(a,b)
print(result)

Lambda Functions are generally used with the following functions

• filter()
• reduce()
• map()

Using Lambdas with filter() Function

The filter() is useful to filter out the elements of a sequence depending on the result of a function.
The basic syntax of the function is:

filter(function,sequence)

Here , the ‘function’ represents a function which returns either True or False; and sequence represents a list,tuple or string.
The function is applied to every element of the sequence , and if the function returns True for that element , then that particular element is extracted , otherwise its ignored.

Lets consider the following function:

def is_Even(x):
    if x%2==0:
        return True
    else:
        return False

and consider the following list item:

lst = [10,20,13,12,5,7]

Now , the filter() can be used as:

lst1 = list(filter(is_even,lst))

This same function can also be applied on Lambda function as:

lst1 = list(filter(lambda x: (x%2==0),lst))

The filter() returns even numbers from the list ‘lst’.

Using Lambdas with map() Function

The map() is similar to filter() , but it acts on each element of the sequence and perhaps changes the element too.

The basic syntax of the function is:

map(function,sequence)

The function performs a specified operation on all the elements of the sequence and the modified elements are returned which can be stored in another sequence.

Lets consider the following function:

def square(x):
    return x*x

and consider the following list item:

lst = [1,2,3,4]

Now , the filter() can be used as:

lst1 = list(map(sqaure,lst))

This same function can also be applied on Lambda function as:

lst1 = list(map(lambda x: x*x,lst))

Now:

lst1 : [1,4,9,16]

Using Lambdas with reduce() Function

The reduce() reduces a sequence of elements to a single value by processing the elements according to a function supplied.

The basic syntax of the function is:

reduce(function,sequence)

consider the following code:

lst = [1,2,3,4,5]
res = list(reduce(lambda x,y:x*y , lst))

The final answer stored in res will be 120.

So how does the above code work:

The lambda function takes in 2 arguments and returns their sum. Therefore , starting from the 0th element of the list ‘lst’ , the first two elements are multiplied and their product is multiplied with the 3rd element and their product is multiplied with the fourth element and so on.

Program to calculate the sum of the elements of a list using lambda function:

from functools import *

lst = [1,2,3,4,5]

result = reduce(lambda x,y:x+y , lst)
print(result)

The output will be 15

Note: The function reduce() is present in the module functools. So we need to import it before using the function