Skip to content

Lambda Functions in Python: A Comprehensive How-To Guide

Updated: at 04:45 AM

Lambda functions, also known as anonymous functions, are small, inline functions that have no name. They are powerful constructs in Python that allow developers to write simple, one-line functions to achieve functionality without declaring a full function.

Lambda functions promote code simplicity and readability by reducing unnecessary syntax. They are popularly used with Python’s functional programming features like map(), filter() and reduce(). Lambda functions have a variety of applications in data science, web development, GUI programming, and more.

This comprehensive guide will provide readers with a deep understanding of lambda functions in Python. It covers the following topics in detail:

Table of Contents

Open Table of Contents

What are Lambda Functions?

Lambda functions are small, anonymous functions that are defined without a name. The lambda keyword is used to define them in Python.

The syntax for lambda functions contains only a single lambda operator with input parameters, a colon, and an expression that returns a value:

lambda parameters: expression

For example:

lambda x: x**2

This lambda function accepts a parameter x and returns x squared.

Lambda functions work similarly to regular functions declared with def in Python. The key difference is that lambda functions are defined inline and are anonymous.

Contrast with Regular Functions

Let’s contrast lambda functions with regular functions declared with def:

# Regular function
def squared(x):
   return x**2

# Output: 25
# Lambda function
squared = lambda x: x**2

# Output: 25

As we can see, both examples yield the same output. However, there are some key differences:

So in summary, lambda functions allow developers to declare simple, nameless functions inline without defining a full function. This promotes concise, readable code when simple or disposable functions are needed.

Use Cases and Applications

Lambda functions have many diverse use cases:

1. Simple Single-Use Functions

For basic functions that are only needed once or in a limited context, lambda functions avoid cluttering the code with many def function declarations.

# Using def
def triple(x):
   return x*3


# Using lambda
triple = lambda x: x*3

2. Map and Filter

Two commonly used built-in functions in Python - map() and filter() - accept other functions as arguments. Lambda functions work great for this.

Map example:

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

squared_nums = map(lambda x: x**2, nums)

# [1, 4, 9, 16, 25]

Filter example:

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

even_nums = filter(lambda x: x%2 == 0, nums)

# [2, 4, 6, 8, 10]

3. Event Handlers and Callbacks

Lambda functions can be used as event handlers or callbacks that are executed when an event occurs, like a button click in GUI programming.

import tkinter as tk

root = tk.Tk()

button = tk.Button(root, text="Click me!",
                   command=lambda: print("Button clicked!"))


4. List, Dictionary and Set Comprehensions

Comprehensions provide a concise way to generate collections in Python. Lambda functions can be leveraged inside comprehensions.

doubles = [lambda x: x*2 for x in range(5)]
print(doubles[2](10)) # 40

keys = ["a", "b", "c"]
values = [lambda: x*2 for x in range(3)]
d = {key: func() for key, func in zip(keys, values)}
print(d) # {'a': 0, 'b': 2, 'c': 4}

5. Sorting and Comparison

The built-in sorted(), min(), and max() functions accept key functions that can be lambda functions.

points = [(1, 4), (2, 2), (3, 1)]

sorted_points = sorted(points, key=lambda x: x[1])
# Sorts by second element

# [(3, 1), (2, 2), (1, 4)]

6. Data Science and Machine Learning

In data science and machine learning, lambda functions are widely used as part of functional programming and lazy evaluation techniques like in Numpy, Pandas, TensorFlow, PyTorch etc.

Functional Programming with Lambda Functions

Lambda functions promote a functional programming style in Python. Some key aspects:

Let’s look at some examples of how lambda functions facilitate functional programming:

Passing Functions as Arguments

Functions like map(), filter() and sorted() accept other callable functions as arguments. Lambda functions passed in become first-class functions:

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

squared_nums = map(lambda x: x**2, nums)
odd_nums = filter(lambda x: x%2 != 0, nums)

Returning Functions from Other Functions

Lambda functions can be returned from other functions:

def get_multiplier(a):
   return lambda x: a * x

double = get_multiplier(2)
triple = get_multiplier(3)

print(double(5)) # 10
print(triple(5)) # 15

Assigning to Variables and Passing Around

Lambda functions can be assigned to variables and passed freely like any other object:

squarer = lambda x: x**2
cube = lambda x: x**3

funcs = [squarer, cube]
for f in funcs:

# 9
# 27

Lazy Evaluation

Consider this regular function:

def execute_func(num):
    print("Executing function...")
    return num**2


It will print the statement every time even if we don’t need the result.

Now consider a lambda function:

execute_func = lambda x: x**2

print(execute_func(5)) # No statement printed

The lambda function won’t execute until we call it - enabling lazy evaluation.

Best Practices for Lambda Functions

When using lambda functions effectively in Python, keep these best practices in mind:

Properly used, lambda functions promote simplicity, flexibility, and elegance in Python code.

Common Mistakes to Avoid

Some common mistakes to avoid when using lambda functions:

Being aware of these common pitfalls will help avoid issues when leveraging lambda functions.


Lambda functions are elegant constructs in Python that allow developers to create simple, anonymous functions inline without defining an entire function. This guide covered the syntax, use cases, functional programming applications, best practices, and common mistakes to avoid when using Python lambda functions.

Lambda functions promote code simplicity, brevity, and readability. They shine when used properly for small, non-reusable functions. Overusing lambdas can reduce code clarity, so balance them by also using descriptive def functions where applicable.

By leveraging lambda functions effectively, Python developers can write cleaner, more concise code following functional programming principles. They provide a powerful tool for any Python programmer’s toolbox.