Python Lambda Function: Syntax, Usage, and Examples

A Python lambda function is a small, anonymous function that you can define in a single line. It is useful when you need a short function for a quick operation without defining it using def.

How to Use a Lambda Function in Python

The syntax of a lambda function in Python follows this structure:

lambda arguments: expression

• lambda: The keyword for defining a lambda function.
• arguments: One or more inputs, just like a regular function.
• expression: The operation that gets evaluated and returned.

Example: Creating a Simple Lambda Function

square = lambda x: x * x
print(square(5))  # Output: 25

This lambda function takes x as an argument and returns its square.

When to Use a Lambda Function in Python

Lambda functions are useful when you need:

1. Short functions that you don’t need to reuse
   • Example: Squaring numbers inside a map() function.
2. To pass functions as arguments
   • Example: Sorting lists with custom rules.
3. To simplify code
   • Example: Replacing short def functions with one-liners.

Examples of Lambda Functions in Python

Using Lambda with map()

map() applies a function to each element of an iterable.

numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x * x, numbers))
print(squared)  # Output: [1, 4, 9, 16, 25]

Using Lambda with filter()

filter() selects elements that match a condition.

numbers = [1, 2, 3, 4, 5, 6]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # Output: [2, 4, 6]

Using Lambda with sorted()

You can sort lists with custom sorting rules using lambda functions.

words = ["apple", "banana", "cherry", "blueberry"]
sorted_words = sorted(words, key=lambda word: len(word))
print(sorted_words)  # Output: ['apple', 'banana', 'cherry', 'blueberry']

Learn More About Lambda Functions in Python

Using If-Else in a Lambda Function

Lambda functions can include conditional expressions.

max_value = lambda a, b: a if a > b else b
print(max_value(10, 20))  # Output: 20

Passing a Lambda Function as an Argument

You can pass a lambda function to another function for flexibility.

def apply_operation(func, value):
    return func(value)

result = apply_operation(lambda x: x * 3, 5)
print(result)  # Output: 15

Using Lambda in a Dictionary

You can use lambda functions inside dictionaries to store different operations.

operations = {
    "square": lambda x: x * x,
    "double": lambda x: x * 2,
    "negate": lambda x: -x
}

print(operations20

Using Lambda with List Comprehension

You can combine lambda functions with list comprehensions for quick transformations.

numbers = [1, 2, 3, 4]
doubled = [(lambda x: x * 2)(n) for n in numbers]
print(doubled)  # Output: [2, 4, 6, 8]

Sorting with Lambda and Multiple Criteria

When sorting dictionaries or tuples, lambda functions help specify multiple sorting criteria.

students = [("Alice", 90), ("Bob", 85), ("Charlie", 85)]
sorted_students = sorted(students, key=lambda student: (-student[1], student[0]))
print(sorted_students)  # Output: [('Alice', 90), ('Bob', 85), ('Charlie', 85)]

Using Multiline Lambda Functions

By default, lambda functions in Python are limited to a single expression. However, you can work around this by using tuples or other techniques.

multistep = lambda x: (x * 2, x + 3, x ** 2)
print(multistep(5))  # Output: (10, 8, 25)

Lambda Function vs. Regular Function

Regular functions are better when the function logic is complex, while lambda functions are ideal for simple operations.

Using a regular function:

def multiply(x, y):
    return x * y

print(multiply(3, 4))  # Output: 12

Using a lambda function:

multiply = lambda x, y: x * y
print(multiply(3, 4))  # Output: 12

Both functions do the same thing, but the lambda version is more compact.

Using Lambda to Pass a Function to a Decorator

Lambda functions can work with decorators when you need quick inline logic.

def decorator(func):
    return lambda x: func(x) + 1

@decorator
def square(x):
    return x * x

print(square(4))  # Output: 17 (4*4 + 1)

Formatting Strings with Lambda Functions

You can format strings using lambda functions for dynamic output.

format_string = lambda name, age: f"My name is {name} and I am {age} years old."
print(format_string("Alice", 30))
# Output: My name is Alice and I am 30 years old.

Best Practices for Lambda Functions

• Use lambda functions for simple, one-time operations.
• Prefer regular functions when logic requires multiple statements.
• Use lambda functions inside map, filter, sorted, and other built-in functions.
• Avoid writing long, complex lambda expressions that reduce readability.

Python lambda functions offer a quick way to define short, throwaway functions without writing a full function definition. Lambda functions make your code more concise, whether you're filtering data, transforming values, or passing functions as arguments.