Week 04 - Task 2.1: Functional Programming in Python: map(), filter(), reduce() 🗺️🔎➕

Give Python a collection of values, and you'll almost always want to do one of three things to it: change every item, pick out some items, or combine everything into one. That's the entire story of map(), filter(), and reduce().

---

🧠 What Is Functional Programming, Really?

Nothing scary — it's just a style where you process data by passing it through functions, rather than manually looping and mutating things.

[1, 2, 3, 4, 5]
       ↓
   multiply by 2
       ↓
[2, 4, 6, 8, 10]

Python gives you three built-in tools for exactly this kind of thinking: map(), filter(), and reduce().

---

🗺️ map() — "Do this to EVERY item"

map() transforms every single element the same way.

numbers = [1, 2, 3, 4, 5]
result = list(map(lambda x: x * 2, numbers))
print(result)
# [2, 4, 6, 8, 10]

What's lambda x: x * 2? Just a tiny, unnamed function — shorthand for:

def double(x):
    return x * 2

Real example:

names = ["deepika", "rahul", "ananya"]
result = list(map(str.upper, names))
# ['DEEPIKA', 'RAHUL', 'ANANYA']

Interview-ready answer: "map() applies a function to every element of an iterable and produces the transformed results."

Use it when: you're converting/transforming every item the same way — uppercasing strings, doubling numbers, converting units, extracting a field from each object.

🧠 MAP = MODIFY EVERYONE

---

🔎 filter() — "Keep only the ones I want"

filter() doesn't change anything — it selects items based on a condition.

numbers = [1, 2, 3, 4, 5, 6]
result = list(filter(lambda x: x % 2 == 0, numbers))
print(result)
# [2, 4, 6]

For each number, lambda x: x % 2 == 0 asks "is this even?" — only the ones that return True survive:

1 → False → ❌
2 → True  → ✅
3 → False → ❌
4 → True  → ✅
5 → False → ❌
6 → True  → ✅

Interview-ready answer: "filter() keeps only the elements for which the condition returns True."

🧠 FILTER = CHOOSE

---

🆚 map() vs filter() — the quick gut-check

	map()	filter()
Job	Transform every item	Select some items
Item count	Stays the same	Can shrink
Mental model	"Do something to everyone"	"Keep only those who qualify"

---

➕ reduce() — "Combine everything into ONE result"

The trickiest of the three — because instead of many outputs, you get one.

from functools import reduce

numbers = [1, 2, 3, 4, 5]
result = reduce(lambda x, y: x + y, numbers)
print(result)
# 15

It works step by step:

1 + 2 = 3
3 + 3 = 6
6 + 4 = 10
10 + 5 = 15

Why two parameters (x, y) instead of one? Because reduce() is always combining two things at a time: the accumulated result so far (x) and the next item (y).

Note: unlike map() and filter(), reduce() isn't built-in by default — you import it from functools.

🧠 REDUCE = COMBINE

---

🍕 Real-World Example: Running a Pizza Shop

prices = [100, 200, 300, 400]

map() — bump every price by ₹50:

new_prices = list(map(lambda x: x + 50, prices))
# [150, 250, 350, 450]

filter() — show only pizzas above ₹200:

expensive = list(filter(lambda x: x > 200, prices))
# [300, 400]

reduce() — get the total bill:

from functools import reduce
total = reduce(lambda x, y: x + y, prices)
# 1000

---

🏆 The Cheat Sheet

Function	Meaning	Question it answers	Result
map()	Transform	"What should I do to every item?"	Transformed values
filter()	Select	"Which items should I keep?"	Selected values
reduce()	Combine	"How can I combine everything?"	Usually one value

MAP    → TRANSFORM
FILTER → SELECT
REDUCE → COMBINE

---

⚠️ A Small Gotcha

map() and filter() don't hand you a plain list directly — they return a lazy map/filter object. That's why you'll almost always wrap them in list(...):

result = list(map(lambda x: x * 2, numbers))
result = list(filter(lambda x: x % 2 == 0, numbers))

---

🤔 "Why not just use a for loop?"

You absolutely can:

result = []
for x in numbers:
    result.append(x * 2)

This does the exact same thing as list(map(lambda x: x * 2, numbers)). map()/filter() can express intent more concisely for simple transformations — but they're not automatically "better." Python developers often reach for a plain loop when the logic gets more complex or less readable as a one-liner.

---

✨ The More "Pythonic" Alternative: List Comprehensions

For simple cases, most Python code actually favors list comprehensions over map()/filter():

# instead of:
result = list(map(lambda x: x * 2, numbers))
# you'll often see:
result = [x * 2 for x in numbers]

# instead of:
result = list(filter(lambda x: x % 2 == 0, numbers))
# you'll often see:
result = [x for x in numbers if x % 2 == 0]

Still — understanding map(), filter(), and reduce() matters, because they're the foundation of functional-programming thinking in Python (and show up constantly in interviews and other languages too).

---

🎯 One Sentence to Remember

map() changes every item, filter() picks the items that qualify, and reduce() collapses everything down into a single result.