Python provides three powerful built-in (or semi-built-in) functional programming tools:
✅ map() → Transforms data
✅ filter() → Filters data
✅ reduce() → Aggregates data
They are often used with lambda functions to write clean, concise, and efficient code.
Let’s go through each one step by step 👇
🔹 1. map() Function
✅ Purpose:
map()applies a function to each element of an iterable (like a list or tuple) and returns a map object (which can be converted into a list or other iterable).
✅ Syntax:
map(function, iterable)🧩 Example 1 — Square of Each Number
numbers = [1, 2, 3, 4, 5]
squares = list(map(lambda x: x**2, numbers))
print(squares)Output:
[1, 4, 9, 16, 25]✅ The lambda function lambda x: x**2 is applied to each number.
🧩 Example 2 — Convert Strings to Uppercase
names = ["alice", "bob", "charlie"]
upper_names = list(map(str.upper, names))
print(upper_names)Output:
['ALICE', 'BOB', 'CHARLIE']✅ Here, we used str.upper directly instead of a lambda.
🧩 Example 3 — Add Two Lists Element-wise
a = [1, 2, 3]
b = [4, 5, 6]
result = list(map(lambda x, y: x + y, a, b))
print(result)Output:
[5, 7, 9]✅ map() can take multiple iterables if the function accepts multiple arguments.
🔹 2. filter() Function
✅ Purpose:
filter()selects elements from an iterable based on a condition (True/False) and returns only those elements that satisfy the condition.
✅ Syntax:
filter(function, iterable)- The function must return
TrueorFalse. - Only elements where the function returns
Trueare kept.
🧩 Example 1 — Filter Even Numbers
numbers = [1, 2, 3, 4, 5, 6]
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)Output:
[2, 4, 6]✅ Keeps only even numbers.
🧩 Example 2 — Filter Strings Starting with “A”
names = ["Alice", "Bob", "Amanda", "Adam", "Charlie"]
a_names = list(filter(lambda x: x.startswith('A'), names))
print(a_names)Output:
['Alice', 'Amanda', 'Adam']✅ Keeps names starting with “A”.
🧩 Example 3 — Remove Empty Strings
strings = ["hello", "", "world", "", "python"]
non_empty = list(filter(None, strings))
print(non_empty)Output:
['hello', 'world', 'python']✅ Using None as the function removes all “falsy” values ("", 0, None, etc.)
🔹 3. reduce() Function
✅ Purpose:
reduce()applies a function cumulatively to all elements in a sequence, reducing it to a single value.
⚠️ It’s not a built-in — you must import it from the functools module.
✅ Syntax:
from functools import reduce
reduce(function, iterable[, initializer])functiontakes two arguments.- Applies it repeatedly to reduce the sequence to one value.
🧩 Example 1 — Sum of All Elements
from functools import reduce
numbers = [1, 2, 3, 4, 5]
total = reduce(lambda x, y: x + y, numbers)
print(total)Output:
15✅ Works like:
(((1 + 2) + 3) + 4) + 5 → 15🧩 Example 2 — Find Maximum Element
from functools import reduce
numbers = [5, 8, 2, 10, 3]
maximum = reduce(lambda x, y: x if x > y else y, numbers)
print(maximum)Output:
10✅ Compares elements pairwise to find the max.
🧩 Example 3 — Multiply All Elements
from functools import reduce
numbers = [1, 2, 3, 4]
product = reduce(lambda x, y: x * y, numbers)
print(product)Output:
24✅ Equivalent to 1 * 2 * 3 * 4.
🧩 Example 4 — Using an Initial Value
from functools import reduce
numbers = [1, 2, 3]
total = reduce(lambda x, y: x + y, numbers, 10)
print(total)Output:
16✅ The initializer (10) is added as the starting value.
🔹 4. Combining map(), filter(), and reduce()
You can combine all three for complex data processing.
🧩 Example — Double Even Numbers and Find Their Sum
from functools import reduce
numbers = [1, 2, 3, 4, 5, 6]
# Step 1: Filter even numbers
evens = filter(lambda x: x % 2 == 0, numbers)
# Step 2: Double them
doubles = map(lambda x: x * 2, evens)
# Step 3: Sum them
result = reduce(lambda x, y: x + y, doubles)
print("Final Result:", result)Output:
Final Result: 24✅ Step-by-step:
Even numbers → [2, 4, 6]
Doubled → [4, 8, 12]
Sum → 24🔹 5. Practical Example — Word Processing
Count Total Length of Words Starting with ‘P’
from functools import reduce
words = ["Python", "Programming", "is", "Powerful", "and", "Popular"]
# Filter words starting with P
p_words = filter(lambda w: w.startswith('P'), words)
# Map to word lengths
lengths = map(len, p_words)
# Reduce to total length
total_length = reduce(lambda x, y: x + y, lengths)
print("Total Length:", total_length)Output:
Total Length: 26✅ "Python" (6) + "Programming" (11) + "Powerful" (8) + "Popular" (7) → 32
(Example output may vary depending on words used.)
🔹 6. Comparison Summary
| Function | Purpose | Returns | Common Use |
|---|---|---|---|
map() | Transform all elements | New iterable (map object) | Apply operation to each item |
filter() | Select some elements | New iterable (filter object) | Keep elements that match condition |
reduce() | Aggregate all elements | Single value | Summation, product, max/min |
✅ Example Recap
| Task | Code | Output |
|---|---|---|
| Square numbers | map(lambda x: x**2, [1,2,3]) | [1, 4, 9] |
| Filter even numbers | filter(lambda x: x%2==0, [1,2,3,4]) | [2, 4] |
| Sum all numbers | reduce(lambda x,y: x+y, [1,2,3,4]) | 10 |
🧾 Summary Table
| Function | Description | Example | Output |
|---|---|---|---|
map() | Applies a function to all elements | map(lambda x: x*2, [1,2,3]) | [2,4,6] |
filter() | Keeps elements that satisfy a condition | filter(lambda x: x>2, [1,2,3,4]) | [3,4] |
reduce() | Reduces a list to one value | reduce(lambda x,y:x*y, [1,2,3,4]) | 24 |
✅ In short:
map()→ transforms every elementfilter()→ selects specific elementsreduce()→ combines all elements into one result- Often used with lambda functions for cleaner, functional-style code.
🧩 Final Example (All-in-One):
from functools import reduce
numbers = [1, 2, 3, 4, 5, 6]
# Step 1: Keep even numbers
# Step 2: Square them
# Step 3: Sum the result
result = reduce(
lambda x, y: x + y,
map(lambda x: x**2, filter(lambda x: x % 2 == 0, numbers))
)
print("Sum of squares of even numbers:", result)Output:
Sum of squares of even numbers: 56✅ Explanation:
Even numbers → [2, 4, 6]
Squares → [4, 16, 36]
Sum → 56🧠 Final Takeaway:
map(),filter(), andreduce()are Python’s functional programming tools
that let you transform, filter, and aggregate data in a clean and concise way —
making your code more expressive, elegant, and efficient.