Lambda Function, also referred to as ‘Anonymous function’ is same as a regular python function but can be defined without a name.
1. What is Lambda Function in Python?
Lambda Function, also referred to as ‘Anonymous function’ is same as a regular python function but can be defined without a name. While normal functions are defined using the def
keyword, anonymous functions are defined using the lambda
keyword. However,they are restricted to single line of expression. They can take in mutliple parameters as in regular functions.
2. Lambda Function Syntax
The syntax for lambda
function is given by : lambda arguments: expression
Notice, there can be any number of arguments but can contain only a single expression. There is no return
statement which is usually present in the def
function syntax. The function will simply return the expression value even when there is no return
statement.
Contents
 What is Lambda Function in Python?
 Lambda Function Syntax
 Need for Lambda Functions
 How to use lambda functions: Simple Example
 Internally, both lambda and def functions works exactly the same
 Lambda functions can have 0 or 1 expression, not more.
 Lambda functions can be Immediately Invoked
 It is possible to write higher order functions using lambda
 Lambda functions accept all kinds of arguments, just like normal def function
 You can use
lambda
function infilter()
 You can use
lambda
function inmap()
 You can use
lambda
function inreduce()
as well  How to use lambda function to manipulate a Dataframe
 Conclusion
3. Need for Lambda Functions
There are at least 3 reasons:

 Lambda functions reduce the number of lines of code when compared to normal python function defined using
def
keyword. But this is not exactly true because, even functions defined withdef
can be defined in one single line. But generally,def
functions are written in more than 1 line.  They are generally used when a function is needed temporarily for a short period of time, often to be used inside another function such as
filter
,map
andreduce
.  Using lambda function, you can define a function and call it immediately at the end of definition. This can’t be done with
def
functions.
 Lambda functions reduce the number of lines of code when compared to normal python function defined using
Let’s see more about implementation of them in python.
4. How to use lambda functions: Simple Example
You don’t need to specify a name for the function as discussed above about the syntax of lambda
function. Let’s try to define a function for calculating the squares of given values.
# calculate squares using lambda
squares = lambda x: x*x
print('Using lambda: ', squares(5))
Using lambda: 25
Let’s also look at how to do the same function using def
keyword, and compare them.
# calculate squares using def
def squares_def(x):
return x*x
print('Using def: ', squares_def(5))
Output:
Using def: 25
Do the same in a single line.
# calculate squares using def in one line
def squares_def(x): return x*x
print('Using def: ', squares_def(5))
Using def: 25
See that while using the def
keyword, we are returning a certain value x*x
. In the case of lambda
function, the expression x*x
will be returned without writing an explicit return statement. Generally in normal use, there is not much of a difference in using def
and lambda
keyword. Both of them are in fact functions. Let’s see their types.
# Types
print(type(squares))
print(type(squares_def))
<class 'function'>
<class 'function'>
Both of them belong to the class function
.
5. Internally, both lambda and def functions works exactly the same
To check how they work internally, use the dis
keyword. dis
keyword will expose a readable version of python bytecode allowing inspection of instructions.
# Bytecode instructions of lambda function
import dis
dis.dis(squares)
2 0 LOAD_FAST 0 (x)
2 LOAD_FAST 0 (x)
4 BINARY_MULTIPLY
6 RETURN_VALUE
Bytecode for regular `def` function.
# Bytecode instructions of def function
import dis
dis.dis(squares_def)
2 0 LOAD_FAST 0 (x)
2 LOAD_FAST 0 (x)
4 BINARY_MULTIPLY
6 RETURN_VALUE
See that the process undertaken by both the functions are exactly the same. So, there is no real difference in the way they execute.
6. Lambda functions can have 0 or 1 expression, not more.
 No expression : contains no expression, will give the same output for all arguments.
x = lambda : "hello world"
print(x())
Output:
Want to become awesome in ML?
Hi! I am Selva, and I am excited you are reading this!
You can now go from a complete beginner to a Data Science expert, with my endtoend free Data Science training.
No shifting between multiple books and courses. Hop on to the most effective way to becoming the expert. (Includes downloadable notebooks, portfolio projects and exercises)
Start free with the first course 'Foundations of Machine Learning'  a well rounded orientation of what the field of ML is all about.
Enroll to the Foundations of ML Course (FREE)
Sold already? Start with the Complete ML Mastery Path
hello world
 Single expression: They can contain either one expression or no expression. We cannot put more than one expression in a lambda function.
new_single = lambda x : (x%2)
print(new_single(10))
0
7. Lambda functions can be Immediately Invoked
You can implement a lambda function without using a variable name. You can also directly pass the argument values into the lambda
function right after defining it using paranthesis. This cannot be done using def
functions.
(lambda x,y : x*y)(5,7)
#> 7
This doesn’t work with def
function.
# Doesn't work with def
def multiply(x, y): return x*y (5,7)
8. It is possible to write higher order functions using lambda
A lambda function can take another function as an argument. Let’s look at an example of a nested lambda functions, a lambda function inside another lambda function.
# Define a lambda function that can take another lambda function (func1).
high_order = lambda x, lmbfunc: x*lmbfunc(x)
# The inner lambda function is defined when calling the high_order.
high_order(10, lambda x : x*x)
#> 1000
See that I have passed another lambda function to calculate the square as argument to the variable high_order
func.
9. Lambda functions accept all kinds of arguments, just like normal def function
lambda
function supports all kinds of arguments just like the normal def
function. 1. Keyword Arguments: keyword argument
is an argument preceded by an identifier (e.g. name=) in a function call. Named Arguments: Example
(lambda x, y=3, z=5: x*y*z)(7)
#> 105
Variable list of Arguments: Example
(lambda x, y=3, z=5: x*y*z)(x=7)
#> 105
Variable list of keyword arguments: Example
(lambda *args : sum(args))(3,5,7)
#> 15
2. Positional arguments: positional argument
is an argument that is not a keyword argument.
(lambda x,y,z : x*y*z)(3,5,7)
#> 105
10. You can use lambda
function in filter()
filter()
function is used to filter a given iterable (list like object) using another function that defines the filtering logic. A lambda function is typically used to define the filtering logic and is passed as the first argument of filter()
. An iterable like a list object is passed as the second argument to the filter
function.
# Using lambda inside filter function
mylist = [2,3,4,5,6,7,8,9,10]
list_new = list(filter(lambda x : (x%2==0), mylist))
print(list_new)
#> [2, 4, 6, 8, 10]
11. You can use lambda
function in map()
map()
function applies a given function to all the itmes in a list and returns the result. Similar to filter()
, simply pass the lambda function and the list (or any iterable, like tuple) as arguments.
# using lambda inside map function
mylist = [2,3,4,5,6,7,8,9,10]
list_new = list(map(lambda x : x%2, mylist))
print(list_new)
#> [0, 1, 0, 1, 0, 1, 0, 1, 0]
12. You can use lambda
function in reduce()
as well
reduce()
function performs a repetitive operation over the pairs of the elements in the list. Pass the lambda
function and the list as arguments to the reduce()
function. For using the reduce()
function, you need to import reduce
from functools
librray.
# Using lambda inside reduce
from functools import reduce
list1 = [1,2,3,4,5,6,7,8,9]
sum = reduce((lambda x,y: x+y), list1)
print(sum)
#> 45
See that the reduce()
function iteratively multiplies over the elements in the list . i.e 1+2, 1+2+3 , 1+2+3+4
and so on.
13. How to use lambda function to manipulate a Dataframe
You can also manipulate the columns of the dataframe using the lambda
function. It’s a great candidate to use inside the apply
method of a dataframe. I will be trying to add a new row in the dataframe in this section as example.
import pandas as pd
df = pd.DataFrame([[1,2,3],[4,5,6]],columns = ['First','Second','Third'])
df['Forth']= df.apply(lambda row: row['First']*row['Second']* row['Third'], axis=1)
df
First  Second  Third  Forth  

0  1  2  3  6 
1  4  5  6  120 
When used with df.appplymap()
it applies the lambda function to every element of the dataframe.
df = df.applymap(lambda x: x*x)
df
First  Second  Third  Forth  

0  1  4  9  36 
1  16  25  36  14400 
Conclusion
Hope you are clear with what lambda functions are and how you can use it in various situations. Try out the following exercises to test your understanding:
 Compute factorial of 10 using lambda function. Hint: Use
reduce
.  Write a function to filter all multiples of 2 and 3 from the list: [1,2,3,4,5,6,7,8,9,10,11,12]