In Python, lambda functions are small, anonymous functions defined in a single line. They are commonly used for short, simple operations where defining a full function using def would be unnecessary.

Lambda functions make your code more concise and are especially useful when working with higher-order functions like map(), filter(), and sorted().

1. What Is a Lambda Function?

A lambda function is an anonymous function — meaning it doesn’t have a name (unless you assign it to a variable).

Syntax:

lambda arguments: expression

• lambda → keyword to define the function
• arguments → input parameters
• expression → a single expression that is evaluated and returned

Unlike normal functions:

• It contains only one expression
• It automatically returns the result
• It cannot contain multiple statements

2. Basic Example

Using a Normal Function:

def add(x, y):
    return x + y

Using a Lambda Function:

add = lambda x, y: x + y

Both work the same way:

print(add(5, 3))  # Output: 8

3. Why Use Lambda Functions?

Lambda functions are useful when:

• You need a short function temporarily
• You want cleaner and more readable inline code
• You're working with functions that accept other functions as arguments

4. Lambda with map()

The map() function applies a function to every item in an iterable.

Example:

numbers = [1, 2, 3, 4]

squared = list(map(lambda x: x**2, numbers))
print(squared)

Output:

[1, 4, 9, 16]

5. Lambda with filter()

The filter() function filters elements based on a condition.

numbers = [1, 2, 3, 4, 5, 6]

even = list(filter(lambda x: x % 2 == 0, numbers))
print(even)

Output:

[2, 4, 6]

6. Lambda with sorted()

Lambda functions are commonly used as a key function in sorting.

students = [
    ("Ali", 85),
    ("Sara", 92),
    ("John", 78)
]

sorted_students = sorted(students, key=lambda student: student[1])
print(sorted_students)

This sorts students by marks.

7. Multiple Arguments

Lambda functions can take multiple arguments:

multiply = lambda a, b, c: a * b * c
print(multiply(2, 3, 4))  # Output: 24

8. Lambda Inside Another Function

You can return a lambda function from another function:

def power(n):
    return lambda x: x ** n

square = power(2)
cube = power(3)

print(square(5))  # 25
print(cube(5))    # 125

This demonstrates closures in Python.

9. Limitations of Lambda Functions

Lambda functions:

• Can only contain a single expression
• Cannot include multiple statements
• Cannot contain complex logic
• Are less readable if overused

For complex functionality, always use a normal def function.

10. When NOT to Use Lambda

Avoid lambda functions when:

• The function is large or complex
• You need multiple lines of logic
• Readability is reduced
• You want proper documentation and naming

Conclusion

Lambda functions in Python provide a quick and efficient way to define small anonymous functions. They are powerful when used correctly — especially with functional programming tools like map(), filter(), and sorted().

However, clarity should always come first. Use lambda functions for simplicity, not complexity.