Python - Lambda Function with Examples
Lambda functions follow a simple syntax: `lambda arguments: expression`. The function evaluates the expression and returns the result automatically—no return statement needed.
Key Insights
- Lambda functions are anonymous, single-expression functions in Python that provide a concise alternative to regular function definitions for simple operations
- They excel in functional programming contexts like map(), filter(), and reduce(), and as inline callbacks, but should be avoided for complex logic requiring multiple statements
- Understanding when to use lambdas versus named functions is critical—lambdas sacrifice readability and debugging capability for brevity
Understanding Lambda Syntax
Lambda functions follow a simple syntax: lambda arguments: expression. The function evaluates the expression and returns the result automatically—no return statement needed.
# Regular function
def add(x, y):
return x + y
# Equivalent lambda
add_lambda = lambda x, y: x + y
print(add(3, 5)) # 8
print(add_lambda(3, 5)) # 8
Lambdas can accept any number of arguments but contain only a single expression. The expression’s result becomes the return value.
# No arguments
greet = lambda: "Hello, World!"
print(greet()) # Hello, World!
# Single argument
square = lambda x: x ** 2
print(square(4)) # 16
# Multiple arguments
multiply = lambda x, y, z: x * y * z
print(multiply(2, 3, 4)) # 24
Lambda Functions with map()
The map() function applies a function to every item in an iterable. Lambdas provide clean inline transformations without cluttering your code with one-off function definitions.
numbers = [1, 2, 3, 4, 5]
# Without lambda
def square(x):
return x ** 2
squared = list(map(square, numbers))
print(squared) # [1, 4, 9, 16, 25]
# With lambda
squared = list(map(lambda x: x ** 2, numbers))
print(squared) # [1, 4, 9, 16, 25]
# Multiple iterables
nums1 = [1, 2, 3]
nums2 = [4, 5, 6]
products = list(map(lambda x, y: x * y, nums1, nums2))
print(products) # [4, 10, 18]
Real-world example: converting temperature data.
celsius_temps = [0, 10, 20, 30, 40]
fahrenheit = list(map(lambda c: (9/5) * c + 32, celsius_temps))
print(fahrenheit) # [32.0, 50.0, 68.0, 86.0, 104.0]
Filtering Data with Lambda
The filter() function constructs an iterator from elements for which the function returns true. Lambdas excel at expressing filtering conditions concisely.
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) # [2, 4, 6, 8, 10]
# Filter numbers greater than 5
greater_than_5 = list(filter(lambda x: x > 5, numbers))
print(greater_than_5) # [6, 7, 8, 9, 10]
Filtering complex data structures:
users = [
{"name": "Alice", "age": 25, "active": True},
{"name": "Bob", "age": 17, "active": False},
{"name": "Charlie", "age": 30, "active": True},
{"name": "David", "age": 16, "active": True}
]
# Filter active adult users
active_adults = list(filter(
lambda user: user["active"] and user["age"] >= 18,
users
))
print([u["name"] for u in active_adults]) # ['Alice', 'Charlie']
Sorting with Lambda Keys
Lambda functions shine as key functions in sorting operations, defining custom sort criteria without separate function definitions.
# Sort by absolute value
numbers = [-5, -2, 1, 3, -8, 4]
sorted_by_abs = sorted(numbers, key=lambda x: abs(x))
print(sorted_by_abs) # [1, -2, 3, 4, -5, -8]
# Sort strings by length
words = ["python", "is", "awesome", "for", "development"]
sorted_by_length = sorted(words, key=lambda x: len(x))
print(sorted_by_length) # ['is', 'for', 'python', 'awesome', 'development']
Sorting complex objects:
products = [
{"name": "Laptop", "price": 1200, "stock": 5},
{"name": "Mouse", "price": 25, "stock": 50},
{"name": "Keyboard", "price": 75, "stock": 30},
{"name": "Monitor", "price": 300, "stock": 15}
]
# Sort by price
by_price = sorted(products, key=lambda p: p["price"])
print([p["name"] for p in by_price]) # ['Mouse', 'Keyboard', 'Monitor', 'Laptop']
# Sort by stock (descending)
by_stock = sorted(products, key=lambda p: p["stock"], reverse=True)
print([p["name"] for p in by_stock]) # ['Mouse', 'Keyboard', 'Monitor', 'Laptop']
# Multi-criteria: sort by stock availability, then price
sorted_products = sorted(products, key=lambda p: (-p["stock"], p["price"]))
Lambda with reduce()
The reduce() function from functools applies a rolling computation to sequential pairs of values. Lambdas provide compact reduction operations.
from functools import reduce
numbers = [1, 2, 3, 4, 5]
# Sum all numbers
total = reduce(lambda x, y: x + y, numbers)
print(total) # 15
# Find maximum
maximum = reduce(lambda x, y: x if x > y else y, numbers)
print(maximum) # 5
# Product of all numbers
product = reduce(lambda x, y: x * y, numbers)
print(product) # 120
Practical example: flattening nested lists.
nested_lists = [[1, 2], [3, 4], [5, 6]]
flattened = reduce(lambda x, y: x + y, nested_lists)
print(flattened) # [1, 2, 3, 4, 5, 6]
Lambda in Event Handlers and Callbacks
Lambda functions work well for simple callbacks and event handlers where defining a separate function adds unnecessary verbosity.
# Button click handlers (conceptual example)
buttons = {
"submit": lambda: print("Form submitted"),
"cancel": lambda: print("Action cancelled"),
"reset": lambda: print("Form reset")
}
buttons["submit"]() # Form submitted
# With parameters
def create_multiplier(n):
return lambda x: x * n
double = create_multiplier(2)
triple = create_multiplier(3)
print(double(5)) # 10
print(triple(5)) # 15
Dictionary-based dispatch tables:
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 None
}
result = operations["multiply"](6, 7)
print(result) # 42
Conditional Expressions in Lambdas
Lambdas support conditional expressions (ternary operators) for simple branching logic.
# Absolute value
abs_value = lambda x: x if x >= 0 else -x
print(abs_value(-5)) # 5
print(abs_value(3)) # 3
# Grade assignment
assign_grade = lambda score: "Pass" if score >= 60 else "Fail"
print(assign_grade(75)) # Pass
print(assign_grade(45)) # Fail
# Nested conditions
classify = lambda x: "positive" if x > 0 else ("zero" if x == 0 else "negative")
print(classify(5)) # positive
print(classify(0)) # zero
print(classify(-3)) # negative
When to Avoid Lambdas
Lambdas sacrifice clarity for brevity. Avoid them when:
Complex logic requires multiple statements:
# Bad: trying to cram complex logic
process = lambda x: (x.strip().lower().replace(" ", "_")
if isinstance(x, str) else str(x))
# Good: use a named function
def process_input(x):
if not isinstance(x, str):
x = str(x)
return x.strip().lower().replace(" ", "_")
Debugging is important:
# Lambda stack traces are less informative
numbers = [1, 2, "3", 4]
try:
result = list(map(lambda x: x ** 2, numbers))
except TypeError as e:
print(e) # Stack trace shows <lambda>
# Named functions provide better error context
def square(x):
return x ** 2
try:
result = list(map(square, numbers))
except TypeError as e:
print(e) # Stack trace shows 'square'
Reusability matters:
# Bad: duplicating lambda logic
sorted_by_price = sorted(products, key=lambda p: p["price"] * (1 - p.get("discount", 0)))
filtered = filter(lambda p: p["price"] * (1 - p.get("discount", 0)) < 100, products)
# Good: define once, use multiple times
def calculate_final_price(product):
return product["price"] * (1 - product.get("discount", 0))
sorted_by_price = sorted(products, key=calculate_final_price)
filtered = filter(lambda p: calculate_final_price(p) < 100, products)
Lambda functions are powerful tools for concise functional programming in Python. Use them for simple, single-expression operations where brevity improves readability. For anything more complex, named functions provide better maintainability, debugging, and code documentation.