Lambda Functions in Python

Lambda functions are small, anonymous functions defined using the lambda keyword. They can take any number of arguments but can only have one expression.

Basic Syntax

python

lambda arguments: expression

Simple Examples

1. Basic Lambda Function

python

# Regular function
def add(x, y):
    return x + y

# Equivalent lambda function
add_lambda = lambda x, y: x + y

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

2. Single Argument Lambda

python

# Double a number
double = lambda x: x * 2
print(double(7))  # Output: 14

# Square a number
square = lambda x: x ** 2
print(square(4))  # Output: 16

Lambda with Built-in Functions

3. Using with map()

python

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

# Double each number using map + lambda
doubled = list(map(lambda x: x * 2, numbers))
print(doubled)  # Output: [2, 4, 6, 8, 10]

4. Using with filter()

python

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

# Filter even numbers
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)  # Output: [2, 4, 6, 8, 10]

# Filter numbers greater than 5
greater_than_5 = list(filter(lambda x: x > 5, numbers))
print(greater_than_5)  # Output: [6, 7, 8, 9, 10]

5. Using with sorted()

python

# Sort by length of words
words = ["apple", "banana", "cherry", "date"]
sorted_by_length = sorted(words, key=lambda x: len(x))
print(sorted_by_length)  # Output: ['date', 'apple', 'banana', 'cherry']

# Sort by last character
sorted_by_last_char = sorted(words, key=lambda x: x[-1])
print(sorted_by_last_char)  # Output: ['banana', 'apple', 'date', 'cherry']

Practical Examples

6. Simple Calculator Operations

python

operations = {
    'add': lambda x, y: x + y,
    'subtract': lambda x, y: x - y,
    'multiply': lambda x, y: x * y,
    'divide': lambda x, y: x / y if y != 0 else "Cannot divide by zero"
}

print(operations['add'](10, 5))       # Output: 15
print(operations['multiply'](4, 6))   # Output: 24
print(operations['divide'](10, 2))    # Output: 5.0

7. Conditional Logic in Lambda

python

# Check if number is positive
is_positive = lambda x: True if x > 0 else False
print(is_positive(5))   # Output: True
print(is_positive(-3))  # Output: False

# Grade classifier
grade = lambda score: "Pass" if score >= 50 else "Fail"
print(grade(75))  # Output: Pass
print(grade(45))  # Output: Fail

8. Multiple Arguments

python

# Calculate area of rectangle
area = lambda length, width: length * width
print(area(5, 10))  # Output: 50

# String formatting
greet = lambda name, age: f"Hello {name}, you are {age} years old!"
print(greet("Alice", 25))  # Output: Hello Alice, you are 25 years old!

Advanced Examples

9. Immediately Invoked Lambda

python

# Lambda function called immediately
result = (lambda x, y: x ** y)(2, 3)
print(result)  # Output: 8

# Another example
message = (lambda name: f"Welcome, {name}!")("Bob")
print(message)  # Output: Welcome, Bob!

10. Lambda in List Comprehensions

python

# Create a list of functions
functions = [lambda x, n=i: x + n for i in range(5)]
for i, func in enumerate(functions):
    print(f"func({10}, n={i}) = {func(10)}")

11. Using with reduce()

python

from functools import reduce

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

# Calculate product using reduce + lambda
product = reduce(lambda x, y: x * y, numbers)
print(product)  # Output: 120 (1*2*3*4*5)

# Find maximum number
max_num = reduce(lambda x, y: x if x > y else y, numbers)
print(max_num)  # Output: 5

When to Use Lambda Functions

Good for:

• Simple, one-line operations
• Functions used only once
• As arguments to higher-order functions (map, filter, sorted, etc.)

Not good for:

• Complex logic (use regular def functions)
• Functions that need documentation strings
• Functions with multiple statements

Key Points to Remember

1. Anonymous: Lambda functions don’t have names (unless assigned to a variable)
2. Single Expression: Can only contain one expression
3. No Statements: Cannot include statements like return, pass, assert, etc.
4. Implicit Return: The expression is automatically returned

Lambda functions make your code more concise and readable when used appropriately for simple operations!