Lambda Functions in Python with Examples



Lambda functions are an essential concept in the world of functional programming, and they have become increasingly popular in recent years. In Python, lambda expressions allow you to create anonymous, single-expression functions that can be used as arguments for other higher-order functions or as callbacks. This article will provide a detailed explanation of lambda functions, their syntax, and various examples to help you understand how to use them effectively.

Table of Contents

What are Lambda Functions?

Lambda functions are short, anonymous functions defined using the lambda keyword in Python. They can have only one expression (without any newline characters) that returns a value. Python lambda functions are useful when you need to create temporary functions for specific tasks or pass them as arguments to other higher-order functions like map(), filter(), and reduce().

Lambda Function Syntax

The syntax of lambda functions in Python is:

lambda [parameter1, parameter2, ...]: expression

In this syntax, you can have multiple parameters separated by commas within the square brackets. The expression should be a single statement that returns a value when executed. Let’s look at some examples to understand how lambda functions work:

Examples of Lambda Functions in Python

Example 1: Creating an Addition Function

add = lambda x, y: x + y
print(add(12, 6)) # Output: 18

In this example, we create a simple addition function using the lambda keyword. The two parameters x and y are used to represent the two numbers that will be added together. The expression x + y returns the sum of these two values when called with arguments.

Example 2: Using Lambda Functions as Arguments for Higher-Order Functions

numbers = [2, 4, 6, 8]
squared_list = list(map(lambda x: x * x, numbers))
print(squared_list) # Output: [4, 16, 36, 64]

In this example, we use the map() function to apply a lambda function to each element in our list of numbers. The lambda expression lambda x: x * x takes one parameter (x) and returns its square value. This is applied to every number in the numbers list, resulting in a new list containing the squared values.

Example 3: Filtering Elements Using Lambda Functions

words = ["time", "apple", "cherry", "date"]
filtered_list = list(filter(lambda x: len(x) > 5, words))
print(filtered_list) # Output: ['cherry']

In this example, we use the filter() function to filter out elements from a list based on a condition specified by our lambda expression. The lambda function lambda x: len(x) > 5 takes one parameter (x) and checks if its length is greater than five. This lambda function is then used as an argument for the filter() function, which returns a new list containing only those elements that satisfy the condition.

Example 4: Using Lambda Functions as Callbacks

def sort_by_length(a, b):
    return cmp(len(b), len(a))

words = ["new york", "london", "berlin", "new castle"]
sorted_list = sorted(words, key=lambda x: len(x), reverse=True)
print(sorted_list) # Output: ['new castle', 'new york', 'london', 'berlin']

In this example, we use a lambda function as a callback for the key parameter in the sorted() function. The lambda expression lambda x: len(x) returns the length of each word in our list. By passing it to the sorted() function’s key parameter, we sort the list based on the lengths of its elements.


Lambda functions are a powerful tool for Python developers, allowing them to create temporary functions and pass them as arguments to higher-order functions or use them as callbacks. By understanding their syntax and various applications, you can effectively utilize lambda expressions in your code to improve readability and maintainability.

To top