Visual walkthrough — Lambda functions — anonymous, used with map - filter

1.2.32 · D2 · Coding › Introduction to Programming (Python) › Lambda functions — anonymous, used with map - filter

Step 1 — Ek function ek machine hai jisme ek slot hota hai

KYA. Lambda ko haath lagane se pehle, socho ki koi bhi function kya hota hai: ek box jisme left side pe ek input slot hota hai aur right side pe ek output chute. Tum kuch daalo, ek rule chalta hai, ek cheez bahar aati hai.

KYUN. Is page ki har cheez — map, filter, sorted ka key — bas "ek machine ko doosri machine ko de do" hai. Toh pehle hume visually agree karna hoga ki ek akeli machine kaisi dikhti hai. Agar ek machine hi fuzzy ho, toh machine-jo-machines-use-kare woh toh bilkul hopeless hai.

PICTURE. Neeche, same rule "2 se multiply karo" do baar draw ki gayi hai: ek baar named machine ke roop mein jo def se bani hai, ek baar anonymous sticky-note machine ke roop mein jo lambda se likhi gayi hai. Same insides, same behaviour — sirf label alag hai.

Isliye lambda ko first-class kaha jaata hai: poori sticky note khud ek value hai jo tum kisi aur ko de sakte ho — bilkul wahi jo hum aage karte hain.

Step 2 — map: machine ko har item pe chalao

KYA. map do cheezon ko leta hai: ek machine f aur items ki ek basket it. Yeh basket ko walk karta hai, har item ko f mein daalta hai, aur outputs ko same order mein line up karta hai.

KYUN. Hum map tak pahunchte hain (haath se likhe loop ki jagah) jab kaam hota hai "har element ko same tarike se transform karo". Yeh sawaal ka jawaab deta hai "meri poori list kaisi dikhegi agar is ek rule ko har piece pe apply karoon?" — kuch add ya remove nahi hota, sirf change hota hai.

PICTURE. Basket [1, 2, 3, 4] left-to-right machine lambda x: x * 2 se guzarti hai. Dekho kaise har item box mein enter karta hai aur double hokar nikalta hai. Output basket ki same length hoti hai — har ek ke liye ek bahar.

nums = [1, 2, 3, 4]
list(map(lambda x: x * 2, nums))   # [2, 4, 6, 8]

Hum list(...) isliye bolte hain kyunki map ek lazy conveyor belt deta hai, finished basket nahi — Step 5 mein yeh visible hoga.

Step 3 — filter: ek transformer nahi, ek bouncer

KYA. filter bhi ek machine f aur ek basket leta hai. Lekin ab f ek predicate hai — ek aisi machine jiska output sirf haan ya na (True/False) hota hai. filter har item ko unchanged rakhta hai agar jawaab haan ho, aur drop kar deta hai agar na ho.

KYUN. Hum filter tak pahunchte hain jab kaam hota hai "kuch elements select karo, kuch bhi change mat karo". Yeh jawaab deta hai "kaun se items mera test pass karte hain?" Step 2 se contrast karo: map kabhi kuch remove nahi karta; filter kabhi kuch alter nahi karta. Do opposite kaam, same shape ka call.

PICTURE. Same basket [1, 2, 3, 4, 5, 6] test lambda x: x % 2 == 0 ("kya x even hai?") se milti hai. Green door evens ke liye khulta hai; odds bounce off karte hain. Output basket choti ya equal hoti hai — kabhi lambi nahi.

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

Step 4 — Inhe nest karna: pehle thin karo, phir transform karo

KYA. Kyunki dono machines take-a-basket-and-return-a-basket hain, tum ek ka output doosre mein feed kar sakte ho. Yahan: filter odds rakhta hai, phir map jo bachta hai use square karta hai.

KYUN. Hum nest karte hain taaki do simple jobs ko ek pipeline mein compose kar sakein, bespoke loop likhne ki jagah. Order matter karta hai: Python ko inside-out padhne pe, innermost call pehle chalta hai.

PICTURE. Basket do stages mein split hoti hai. Stage 1 (green, filter) evens ko drop karta hai, [1, 3, 5] bachti hai. Stage 2 (blue, map) har survivor ko square karke [1, 9, 25] deta hai. Single item 3 follow karo: yeh bouncer se pass hota hai, phir square hokar 9 ban jaata hai.

$\text{map}(\underset{\text{stage 2: transform}}{\underbrace{\text{lambda x: x*x}}},\underset{\text{stage 1: select — runs first}}{\underbrace{\text{filter(lambda x: x\%2==1, nums)}}})$

nums = [1, 2, 3, 4, 5]
list(map(lambda x: x*x, filter(lambda x: x % 2 == 1, nums)))   # [1, 9, 25]

Aksar ek list comprehension aur bhi clear lagti hai: [x*x for x in nums if x % 2 == 1].

Step 5 — Degenerate case: belt khatam ho jaati hai (laziness)

KYA. map aur filter tumhe finished basket nahi dete. Woh tumhe ek conveyor belt (lazy iterator) dete hain jo items tab produce karta hai jab maanga jaaye, aur ek pass ke baad khatam ho jaata hai.

KYUN. Yeh #1 surprise hai, isliye iske liye alag step hai. Laziness memory bachati hai (kuch tab tak compute nahi hota jab tak pull na ho), lekin iska matlab hai ki same belt ko dobaara padhne ki koshish se khali belt milegi — har item pehle hi girf gaya.

PICTURE. Left panel: belt ko directly print karne pe cryptic <map object ...> dikhta hai — tum machine dekh rahe ho, uska output nahi. Right panel: pehla list(belt) use poora drain karta hai; doosra list(belt) kuch nahi utha pata → [].

belt = map(lambda x: x * 2, [1, 2, 3])
print(belt)          # <map object at 0x...>  ← machine, jawaab nahi
list(belt)           # [2, 4, 6]  ← belt ab drain ho gayi
list(belt)           # []         ← uthane ke liye kuch bacha nahi

Step 6 — Ek aur degenerate case: filter(lambda x: x, items)

KYA. Agar predicate sirf item khud hi ho — lambda x: x — toh filter har us item ko rakhta hai jiska apna value truthy count hota hai, aur falsy walon ko drop karta hai.

KYUN. Yeh Step 3 ki ek boundary hai: kya hoga agar "test" koi comparison na ho balki raw item ho? Python haan/na decide karta hai yeh poochh ke ki value truthy hai ya nahi. Toh yeh one-liner 0, '', None, [], False strip karta hai — yeh genuinely useful idiom hai, koi bug nahi.

PICTURE. Mixed basket [0, 1, '', 'hi', None, 5] identity door se milti hai. Falsy items (0, '', None, red mein dikhaaye) bounce karte hain; truthy items (1, 'hi', 5, green mein dikhaaye) pass hote hain.

items = [0, 1, '', 'hi', None, 5]
list(filter(lambda x: x, items))   # [1, 'hi', 5]

Step 7 — Ek machine jo compare karti hai: sorted ka key

KYA. `sorted` key=<ek machine> le sakta hai. Har item ke liye yeh machine se poochha jaata hai "tumhe kis single value se compare karoon?", phir items un values ke basis pe order hote hain — items khud whole rehte hain.

KYUN. By default sorted poore items compare karta hai (tuples pehle element se compare hote hain). Jab hum alag field se sort karna chahte hain, hum ek lambda dete hain jo woh field extract kare. Yeh wahi "machine haath mein do" idea hai, ab comparison keys produce karne ke liye use ho raha hai, transformed items ki jagah.

PICTURE. List [(1,'b'), (3,'a'), (2,'c')] ke saath key=lambda p: p[1] (letter lo). Har pair apne letter 'b','a','c' pe project karta hai; unhe alphabetically sort karne se pairs reorder hokar [(3,'a'),(1,'b'),(2,'c')] ban jaate hain.

$\text{sorted}(\text{pairs},\text{key}=\underset{\text{ek pair andar}}{\underbrace{\text{lambda p}}}:\underset{\text{uska 2nd element bahar}}{\underbrace{\text{p[1]}}})$

pairs = [(1, 'b'), (3, 'a'), (2, 'c')]
sorted(pairs, key=lambda p: p[1])   # [(3, 'a'), (1, 'b'), (2, 'c')]

Ek-picture summary

Sab kuch ek image mein compress hota hai: ek lambda ek choti si machine hai, aur map / filter / sorted-key badi machines hain jo ise borrow karti hain aur poori basket pe apply karti hain — transform karte hue, select karte hue, ya compare karte hue.

Connections

• Functions and def — Step 1 mein anonymous machine ka named twin.
• First-class functions — kyun lambda ko map/filter ko haath mein diya ja sakta hai.
• Higher-order functions — map, filter, sorted exactly yehi hain: woh ek machine lete hain.
• Iterators and lazy evaluation — Step 5 ka one-pass belt.
• List comprehensions — Step 4 pipeline ka readable rewrite.
• sorted and key functions — Step 7 ka comparison-key idea poora.