A lambda is a small, anonymous, single-expression function. map, filter, and reduce are functional tools that apply a function across an iterable. Together they enable a functional style — though Python often prefers comprehensions for the same tasks.
# a lambda is a one-line function with no name
square = lambda x: x ** 2
square(5) # 25
# equivalent named function:
def square(x): return x ** 2
Lambdas shine as inline arguments to other functions, especially as sort/filter keys:
people.sort(key=lambda p: p.age) # sort by an attribute
sorted(words, key=lambda w: len(w)) # sort by length
max(items, key=lambda x: x.score) # find max by a criterion
nums = [1, 2, 3, 4]
list(map(lambda x: x ** 2, nums)) # [1, 4, 9, 16]
# more Pythonic alternative — a comprehension:
[x ** 2 for x in nums] # [1, 4, 9, 16]
list(filter(lambda x: x % 2 == 0, nums)) # [2, 4]
# comprehension equivalent:
[x for x in nums if x % 2 == 0] # [2, 4]
from functools import reduce
reduce(lambda acc, x: acc + x, nums, 0) # 10 (sum)
# but built-ins are clearer when they exist:
sum(nums) # 10
For map/filter, COMPREHENSIONS are usually more readable and idiomatic:
map(f, xs) → [f(x) for x in xs]
filter(pred, xs) → [x for x in xs if pred(x)]
Lambdas are best for short inline keys (sort/max/filter), NOT complex logic.
Guido (Python's creator) and the community generally favor comprehensions over map/filter for readability; reduce was even moved out of builtins. But lambdas as key= functions remain idiomatic and common.
These functional tools let you express transformations and filters concisely.
While Python can be written functionally, the idiomatic choice is usually a comprehension over map/filter for readability, and a built-in (sum, max, min) over reduce.
Where lambdas genuinely shine is as small inline functions passed to sort/max/min/filter as a key.
Understanding both — and knowing the Pythonic preference for comprehensions and built-ins — helps you write clean, idiomatic code and read the functional-style code that does appear in real projects.