Python Lambda Expressions (Anonymous Functions) Tutorial

In this tutorial we learn how to create and use lambda expressions in Python, also known as anonymous functions.

We cover how to declare and pass values to lambdas, as well as using lambdas inside regular functions.

What is a lambda expression

A Lambda expression is an anonymous function. That means, it’s a function that has no name, no return statement and only one expression.

With Lambda expressions we can write less code, and the code will be more readable.

How to declare a lambda expression

To create a lambda expression we use the keyword lambda followed by any number of arguments, and then a colon. Finally, we write the expression.

 lambda arguments : expression

The statement above reads: arguments goes to expression

The easiest way to understand a lambda expression is if we convert a normal function into a lambda.

def square(num):
    return num * num

The example above takes a number and multiplies it by itself, then returns the result.

To convert this into a lambda is easy.

 lambda num : num * num

Here is another way to look at it.

 argument num : return num * num

Let’s do another example just to make it clear.

# normal function
def add(num_1, num_2):
    return num_1 + num_2

# lambda version
lambda num_1, num_2 : num_1 + num_2

Lambdas can take any number of arguments (before the colon), but only one expression (after the colon).

How to pass values to lambda arguments

At the moment our lambdas are set up, but we can’t use them until we can pass values to the arguments.

To pass a value to an argument we assign the lambda to a data container such as a variable. Then we pass the arguments between parentheses when calling the variable.

# declaration
variable_name = lambda argument : expression

# call

The variable name essentially becomes the lambda’s name like a function would have a name.

# square a num
square = lambda num : num * num

print("Square:", square(5))

# add two numbers
add = lambda num_1, num_2 : num_1 + num_2

print("Add:", add(5, 2))

In the example above we can see that a lambda call looks the same as a function call.

Lambda expression inside a regular function

We can use a lambda inside a normal function. To do this, we declare the lambda inside the normal function’s code block.

def multi(n):
    return lambda a : a * n

We declare the lambda as a return statement. The argument passed into the function will be placed into the lambda and the lambda is then returned.

Essentially, if we call the function with the argument 5, the function will return the following:


# returns:
lambda a : a * 5

We now have a lambda returned, but we can’t pass arguments to it so we need to give it a name.

Because the lambda is returned from the function, we can assign the function call to a variable. The variable will then become the lambda name and allow us to pass arguments to it.

def multi(n):
    return lambda a : a * n

multiplier = multi(5)

# multiplier variable would now
# technically look like this:
multiplier = lambda a : a * 5

In the example above, we only demonstrate what the multiplier variable would look like after the function’s result is assigned to it. Normally we wouldn’t write the lambda function again into the multiplier variable.

def multi(n):
    return lambda a : a * n

multiplier = multi(5)


The example above seems silly and more typing than needed. But, lambdas inside functions can be very powerful in many situations.

When to use lambda expressions

Lambdas make working with certain interfaces simpler and keep code readable and concise.

Lambdas are usually used to:

  • pass arguments to higher-order functions.
  • construct the result of a higher-order function that needs to return a function, as we have done above.

A general rule of thumb is to use lambdas in Python for simple functionality and returning lambdas from other functions. If you don’t want to use them or if you find yourself doing something fairly complex, define a normal function.

Summary: Points to remember

  • A lambda expression is a function that doesn’t have a name or return statement, and only one expression.
  • A lambda is written as argument(s) : return statement .
  • When passing values to a lambda expression, we use a function call syntax.
  • Lambda expressions can be used inside regular functions.