Lambda Functions

Intermediate ~20 min read

Lambda functions are small, anonymous functions defined with a single expression. They're perfect for short operations you need to pass to other functions like sorted(), map(), or filter(). While powerful, lambdas have their place - knowing when to use them (and when not to) is key to writing clean Python!

Lambda Function Basics

The syntax is lambda arguments: expression. A lambda can take any number of arguments but consists of a single expression that's automatically returned. Think of it as a compact way to define simple functions inline.

# Lambda Function Basics

# 1. Basic lambda syntax
print("=== Basic Lambda ===")
# lambda arguments: expression

# A simple lambda that adds 10
add_ten = lambda x: x + 10
print(f"add_ten(5) = {add_ten(5)}")
print(f"add_ten(100) = {add_ten(100)}")
print()

# 2. Equivalent regular function
print("=== Lambda vs def ===")
# Lambda:
square_lambda = lambda x: x ** 2

# Equivalent def:
def square_def(x):
    return x ** 2

print(f"Lambda: {square_lambda(5)}")
print(f"Def:    {square_def(5)}")
print()

# 3. Multiple arguments
print("=== Multiple Arguments ===")
add = lambda a, b: a + b
multiply = lambda a, b: a * b
power = lambda base, exp: base ** exp

print(f"add(3, 5) = {add(3, 5)}")
print(f"multiply(4, 6) = {multiply(4, 6)}")
print(f"power(2, 8) = {power(2, 8)}")
print()

# 4. No arguments
print("=== No Arguments ===")
say_hello = lambda: "Hello, World!"
get_pi = lambda: 3.14159

print(say_hello())
print(f"Pi = {get_pi()}")
print()

# 5. Lambdas are expressions
print("=== Lambda as Expression ===")
# Can be used immediately without assigning
result = (lambda x, y: x + y)(3, 7)
print(f"Immediate call: {result}")

# In a list
operations = [
    lambda x: x + 1,
    lambda x: x * 2,
    lambda x: x ** 2
]

value = 5
for op in operations:
    print(f"Operation on {value}: {op(value)}")

Output

Click Run to execute your code

Why "Lambda"? The name comes from lambda calculus, a mathematical notation for defining functions. In Python, lambda x: x + 1 is equivalent to the mathematical notation λx.x+1. Don't worry about the theory - just think of lambdas as "inline functions."

Lambda with Built-in Functions

Lambdas truly shine when used with Python's built-in functions that accept function arguments: sorted() for custom sorting, map() for transforming data, and filter() for selecting elements.

# Lambda with Built-in Functions

# 1. sorted() with key
print("=== sorted() with Lambda ===")
words = ["banana", "pie", "Washington", "book"]

# Sort by length
by_length = sorted(words, key=lambda w: len(w))
print(f"By length: {by_length}")

# Sort alphabetically (case-insensitive)
by_alpha = sorted(words, key=lambda w: w.lower())
print(f"Alphabetically: {by_alpha}")
print()

# 2. Sorting complex data
print("=== Sorting Complex Data ===")
students = [
    {"name": "Alice", "grade": 88},
    {"name": "Bob", "grade": 95},
    {"name": "Charlie", "grade": 72}
]

# Sort by grade
by_grade = sorted(students, key=lambda s: s["grade"])
print("By grade (ascending):")
for s in by_grade:
    print(f"  {s['name']}: {s['grade']}")

# Sort by grade descending
by_grade_desc = sorted(students, key=lambda s: s["grade"], reverse=True)
print("\nBy grade (descending):")
for s in by_grade_desc:
    print(f"  {s['name']}: {s['grade']}")
print()

# 3. map() - transform every item
print("=== map() with Lambda ===")
numbers = [1, 2, 3, 4, 5]

# Square each number
squares = list(map(lambda x: x ** 2, numbers))
print(f"Squares: {squares}")

# Convert to strings
strings = list(map(lambda x: f"num_{x}", numbers))
print(f"Strings: {strings}")
print()

# 4. filter() - select items
print("=== filter() with Lambda ===")
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Even numbers only
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(f"Evens: {evens}")

# Greater than 5
big = list(filter(lambda x: x > 5, numbers))
print(f"Greater than 5: {big}")
print()

# 5. Combining map and filter
print("=== Combining map() and filter() ===")
# Get squares of even numbers
even_squares = list(map(lambda x: x ** 2, filter(lambda x: x % 2 == 0, numbers)))
print(f"Even squares: {even_squares}")

# Note: list comprehension is often clearer
even_squares_comp = [x ** 2 for x in numbers if x % 2 == 0]
print(f"Same with comprehension: {even_squares_comp}")

Output

Click Run to execute your code

The key Parameter: Functions like sorted(), max(), and min() accept a key parameter - a function that extracts the value to compare. Lambdas are perfect here: sorted(items, key=lambda x: x["price"]) sorts by the "price" field.

Advanced Lambda Patterns

Lambdas can include conditional expressions, be returned from functions to create specialized functions, and work with reduce() for aggregation. These patterns unlock functional programming techniques in Python.

# Advanced Lambda Patterns

# 1. Lambda with conditional expression
print("=== Conditional Lambdas ===")
# Syntax: lambda x: value_if_true if condition else value_if_false

is_even = lambda x: "even" if x % 2 == 0 else "odd"
print(f"is_even(4) = {is_even(4)}")
print(f"is_even(7) = {is_even(7)}")

abs_val = lambda x: x if x >= 0 else -x
print(f"abs_val(-5) = {abs_val(-5)}")
print(f"abs_val(3) = {abs_val(3)}")
print()

# 2. Higher-order function returning lambda
print("=== Functions Returning Lambdas ===")
def make_multiplier(n):
    """Create a function that multiplies by n."""
    return lambda x: x * n

double = make_multiplier(2)
triple = make_multiplier(3)
times_ten = make_multiplier(10)

print(f"double(5) = {double(5)}")
print(f"triple(5) = {triple(5)}")
print(f"times_ten(5) = {times_ten(5)}")
print()

# 3. Lambda in dictionaries (dispatch pattern)
print("=== Lambda Dispatch ===")
operations = {
    "add": lambda a, b: a + b,
    "subtract": lambda a, b: a - b,
    "multiply": lambda a, b: a * b,
    "divide": lambda a, b: a / b if b != 0 else "Error"
}

a, b = 10, 3
for op_name, op_func in operations.items():
    print(f"{a} {op_name} {b} = {op_func(a, b)}")
print()

# 4. Using lambda with reduce()
print("=== reduce() with Lambda ===")
from functools import reduce

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

# Sum all numbers
total = reduce(lambda acc, x: acc + x, numbers)
print(f"Sum: {total}")

# Find maximum
maximum = reduce(lambda a, b: a if a > b else b, numbers)
print(f"Max: {maximum}")

# Product of all
product = reduce(lambda acc, x: acc * x, numbers)
print(f"Product: {product}")
print()

# 5. min/max with key
print("=== min/max with Lambda ===")
data = [{"name": "A", "value": 10}, {"name": "B", "value": 5}, {"name": "C", "value": 15}]

min_item = min(data, key=lambda x: x["value"])
max_item = max(data, key=lambda x: x["value"])

print(f"Min value: {min_item}")
print(f"Max value: {max_item}")

Output

Click Run to execute your code

Lambda Limitations: Lambdas can only contain a single expression - no statements, no multiple lines, no assignments. If you need any of these, use a regular def function. Lambdas also can't have docstrings, making them harder to document.

Lambda vs def: When to Use Which

While lambdas are convenient, they're not always the best choice. Understanding when to use lambda versus def is crucial for writing readable, maintainable code. Often, list comprehensions are clearer than map/filter with lambdas.

# Lambda vs def - When to Use Which

# 1. Readability comparison
print("=== Readability ===")

# Lambda: concise for simple operations
nums = [1, 2, 3, 4, 5]
squares = list(map(lambda x: x**2, nums))
print(f"Lambda map: {squares}")

# def: better for anything complex
def calculate_square(x):
    """Return the square of x."""
    return x ** 2

squares = list(map(calculate_square, nums))
print(f"def map: {squares}")
print()

# 2. When lambda is appropriate
print("=== Good Lambda Use Cases ===")

# Short sorting keys
students = [("Alice", 88), ("Bob", 95), ("Charlie", 72)]
sorted_students = sorted(students, key=lambda s: s[1])
print(f"Sorted by grade: {sorted_students}")

# Quick filter conditions
words = ["apple", "pie", "elephant", "hi"]
long_words = list(filter(lambda w: len(w) > 3, words))
print(f"Long words: {long_words}")

# Simple transformations
prices = [10, 20, 30]
with_tax = list(map(lambda p: p * 1.1, prices))
print(f"With tax: {with_tax}")
print()

# 3. When def is better
print("=== When def is Better ===")

# Multiple statements needed
def process_user(user):
    """Process user data with validation."""
    if not user.get("name"):
        return None
    if not user.get("email"):
        return None
    return {
        "name": user["name"].strip().title(),
        "email": user["email"].lower()
    }

user = {"name": "  alice  ", "email": "ALICE@EXAMPLE.COM"}
print(f"Processed: {process_user(user)}")

# Need docstring for documentation
def calculate_tax(amount, rate=0.1):
    """
    Calculate tax on an amount.

Args:
        amount: The base amount
        rate: Tax rate (default 10%)

Returns:
        The tax amount
    """
    return amount * rate

print(f"Tax: {calculate_tax(100)}")
print()

# 4. Comprehensions vs map/filter with lambda
print("=== Comprehensions Are Often Clearer ===")
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Lambda approach
result1 = list(map(lambda x: x**2, filter(lambda x: x % 2 == 0, numbers)))
print(f"Lambda: {result1}")

# Comprehension approach (preferred)
result2 = [x**2 for x in numbers if x % 2 == 0]
print(f"Comprehension: {result2}")

# Same result, but comprehension is more Pythonic

Output

Click Run to execute your code

Common Mistakes

1. Assigning lambdas to variables (use def instead)

# Not recommended (PEP 8)
square = lambda x: x ** 2

# Better - use def for named functions
def square(x):
    return x ** 2

# Lambdas are best used inline
sorted(items, key=lambda x: x.value)  # Good!

2. Complex logic in lambdas

# Bad - too complex, hard to read
process = lambda x: x.strip().lower().replace(' ', '_') if x else 'default'

# Better - use a named function
def process(x):
    if not x:
        return 'default'
    return x.strip().lower().replace(' ', '_')

3. Forgetting that lambda captures variables by reference

# Problem: all functions use the LAST value of i
funcs = []
for i in range(3):
    funcs.append(lambda: i)

print([f() for f in funcs])  # [2, 2, 2] - not [0, 1, 2]!

# Fix: capture i as default argument
funcs = []
for i in range(3):
    funcs.append(lambda i=i: i)  # i=i captures current value

print([f() for f in funcs])  # [0, 1, 2] - correct!

4. Using map/filter with lambda when comprehension is clearer

# Overly functional style
result = list(map(lambda x: x*2, filter(lambda x: x > 0, numbers)))

# More Pythonic - use comprehension
result = [x * 2 for x in numbers if x > 0]

# Even clearer for complex operations
result = [
    transform(x)
    for x in numbers
    if is_valid(x)
]

5. Trying to use statements in lambda

# Wrong - print is a statement effect, not useful here
# And assignments aren't allowed
process = lambda x: print(x)  # Works but returns None
process = lambda x: x = x + 1  # SyntaxError!

# Lambda can only have expressions
process = lambda x: x + 1  # Expression returns value

Exercise: Sort and Transform

Task: Use lambda functions to sort and transform data.

Requirements:

Sort a list of products by price (ascending)
Use map() to apply a 10% discount to all prices
Use filter() to get products under $50

Output

Click Run to execute your code

Show Solution

products = [
    {"name": "Laptop", "price": 999},
    {"name": "Mouse", "price": 25},
    {"name": "Keyboard", "price": 75},
    {"name": "Monitor", "price": 300}
]

# Sort by price
sorted_products = sorted(products, key=lambda p: p["price"])
print("Sorted by price:")
for p in sorted_products:
    print(f"  {p['name']}: ${p['price']}")

# Apply 10% discount
discounted = list(map(lambda p: {**p, "price": p["price"] * 0.9}, products))
print("\nWith 10% discount:")
for p in discounted:
    print(f"  {p['name']}: ${p['price']:.2f}")

# Filter under $50
cheap = list(filter(lambda p: p["price"] < 50, products))
print(f"\nUnder $50: {[p['name'] for p in cheap]}")

Summary

Syntax: lambda arguments: expression
Best use: Short operations passed to sorted(), map(), filter()
With key: sorted(items, key=lambda x: x.value)
With map: map(lambda x: x*2, items)
With filter: filter(lambda x: x > 0, items)
Conditional: lambda x: "yes" if x else "no"
Limitation: Single expression only, no statements
When to use def: Named functions, complex logic, need docstrings
Often prefer: List comprehensions over map/filter with lambda

What's Next?

Now let's explore Recursion - functions that call themselves! This powerful technique is perfect for problems that have a natural recursive structure, like traversing trees, calculating factorials, or solving puzzles.

Previous Variable Scope

Next Recursion

Lambda Function Basics

Lambda with Built-in Functions

Advanced Lambda Patterns

Lambda vs def: When to Use Which

Common Mistakes

1. Assigning lambdas to variables (use def instead)

2. Complex logic in lambdas

3. Forgetting that lambda captures variables by reference

4. Using map/filter with lambda when comprehension is clearer

5. Trying to use statements in lambda

Exercise: Sort and Transform

Summary

What's Next?

Enjoying these tutorials?