Lambda functions — anonymous, used with map - filter: Worked examples

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

Scenario matrix

Ek lambda-with-a-tool problem ko kuch independent "dials" wala socho. Har dial kuch positions mein ho sakti hai. Neeche ki matrix har position list karti hai jo hum cover karenge taaki tum kabhi aise case se na milo jo humne dikhaya nahi.

Cell	Case class	Kya bite kar sakta hai
A	`map` ek normal list ko transform karta hai	`list(...)` bhool jaana → `<map object>` dikhega
B	`filter` ek predicate se select karta hai	`x % 2 == 0` vs `x % 2 == 1` remainder ka sign
C	empty / degenerate iterable `[]`	result `[]` hoga, error nahi
D	laziness — iterator ek pass ke baad exhaust ho jaata hai	doosra `list()` `[]` deta hai
E	nesting `map(f, filter(g, it))`	inside-out evaluation order
F	multi-argument lambda + `sorted(key=...)`	har item ke liye ek comparable value
G	truthiness `filter(lambda x: x, ...)`	`0, '', None, [], False` drop ho jaate hain
H	ternary inside lambda (sirf yehi "logic" allowed hai)	`if`/`else` ek expression ke roop mein, statement nahi
I	real-world word problem	map vs filter choose karna
J	exam twist — `map` do iterables par	`map(f, a, b)` shorter par ruk jaata hai

Ab hum 10 examples karte hain, har ek cell(s) ke saath tagged. Milke yeh poora table fill karte hain.

Woh figure jise hum baar baar refer karte hain

Figure — Lambda functions — anonymous, used with map - filter

Worked examples

Worked example Ex 4 — Laziness: one-pass trap (Cell D)

Statement. Doosra list(...) kya print karta hai?

m = map(lambda x: x * 2, [1, 2, 3])
a = list(m)   # ?
b = list(m)   # ?

Forecast: kya a aur b equal hain?

a = list(m) har value pull karta hai: [2, 4, 6]. Yeh step kyun? list iterator ko completion tak drive karta hai.
Iterator m ab exhausted hai — iska internal cursor end ke baad baitha hai. Yeh step kyun? Lazy iterators demand par compute karte hain aur position yaad rakhte hain; yeh rewind nahi karte.
b = list(m) kuch nahi pata → [].

Result: a = [2, 4, 6], b = []. Verify: a + b == [2, 4, 6] (doosre pass ne kuch add nahi kiya). ✓

Worked example Ex 5 — Nesting: pehle filter, phir map (Cell E)

Statement. [1, 2, 3, 4, 5, 6] ke sirf odd numbers ko square karo.

list(map(lambda x: x * x,
         filter(lambda x: x % 2 == 1, [1,2,3,4,5,6])))

Forecast: dono stages ke baad kya bachega?

Inside-out padho: innermost call pehle run hota hai — filter(lambda x: x % 2 == 1, ...). Yeh step kyun? Function calls apne arguments evaluate karte hain outer call se pehle.
Filter odds rakhta hai: [1, 3, 5]. Yeh step kyun? Odd numbers 2 se divide karne par remainder 1 dete hain.
map(lambda x: x*x, ...) har survivor ko square karta hai: 1→1, 3→9, 5→25. Yeh step kyun? map already-thinned stream ko transform karta hai — saaro ko square karne se sasta.

Result: [1, 9, 25] Verify: 3 odds in ⇒ 3 squares out; har output ek odd number ka square hai. ✓

Worked example Ex 6 — Multi-argument lambda

sorted ke key ke saath (Cell F) Statement. Students ko unke score se sort karo (descending), phir names dikhao.

people = [("Asha", 82), ("Ravi", 91), ("Meena", 77)]
ranked = sorted(people, key=lambda p: p[1], reverse=True)
names = list(map(lambda p: p[0], ranked))

Forecast: pehle kaun aayega?

key=lambda p: p[1] sorted ko har item ke liye ek comparable value deta hai — score. Yeh step kyun? sorted items compare karta hai; ek tuple pehle name se compare karta, jo hum nahi chahte.
reverse=True ascending → descending flip karta hai, taki highest score aage aaye. Yeh step kyun? Hume ek ranking chahiye, top down.
map(lambda p: p[0], ranked) har ranked tuple mein se name (index 0) nikalta hai.

Result: ranked = [("Ravi",91),("Asha",82),("Meena",77)], names = ["Ravi","Asha","Meena"]. Verify: scores 91 ≥ 82 ≥ 77 non-increasing hain. ✓ Dekho sorted and key functions.

Worked example Ex 8 — Lambda ke andar Ternary (Cell H)

Statement. Har number ko even/odd label karo:

list(map(lambda x: 'even' if x % 2 == 0 else 'odd', [1, 2, 3, 4]))

Forecast: charo labels guess karo.

a if condition else b ek expression hai (yeh ek value produce karta hai), isliye lambda mein legal hai. Yeh step kyun? Lambdas statements (if x: apni line par) forbid karte hain lekin is one-line conditional ki allow hai.
Har item par evaluate karo: 1→odd, 2→even, 3→odd, 4→even. Yeh step kyun? map tiny classifier ko har element par ek baar run karta hai.

Result: ['odd', 'even', 'odd', 'even'] Verify: value ke even indices (2, 4) 'even' pe map karte hain. ✓

Worked example Ex 9 — Real-world word problem (Cell I)

Statement. Ek shop ki cart prices hain [199, 0, 499, 0, 89] (jo 0 hain woh removed items hain). Removed items ignore karke 18% GST add karne ke baad total compute karo.

Forecast: pehle map ya filter — aur kyun?

Removed items (jo 0 hain) ko filter karo: filter(lambda p: p > 0, prices) → [199, 499, 89]. Yeh step kyun? Hum koi bhi maths karne se pehle real items select karte hain — filter selector hai.
Har surviving price ko GST-inclusive value mein map karo: lambda p: p * 1.18. Yeh step kyun? Har real item same tarah transform hota hai — yeh map ka kaam hai.
Results ko built-in sum(...) se sum karo. Yeh step kyun? sum mapped iterator ko ek number mein fold karta hai (ek higher-order reduction).

prices = [199, 0, 499, 0, 89]
total = sum(map(lambda p: p * 1.18,
                filter(lambda p: p > 0, prices)))

Result: 787 * 1.18 = 928.66 Verify: rakha gaya sum 199 + 499 + 89 = 787; 787 * 1.18 = 928.66. Units: rupees × (dimensionless factor) = rupees. ✓

Matrix coverage check

Recall Kya humne har cell fill ki? (reveal)

A→Ex1 · B→Ex2 · C→Ex3 · D→Ex4 · E→Ex5 · F→Ex6 · G→Ex7 · H→Ex8 · I→Ex9 · J→Ex10. Har row worked hai. ✓

Recall Rapid self-test

list(map(lambda x: x*3, [1,2,3,4])) ::: [3, 6, 9, 12] list(filter(lambda x: x % 2 == 0, [10,15,20,25])) ::: [10, 20] list(filter(lambda x: x, [0,1,'', 'hi', None, [], [0], False, 5])) ::: [1, 'hi', [0], 5] list(map(lambda a,b: a+b, [1,2,3,4],[10,20,30])) ::: [11, 22, 33] Exhausted map object par doosra list() kya deta hai? ::: []

Connections

Functions and def — yahan har lambda ka ek equivalent named def hai.
First-class functions — isliye hum functions ko map/filter/sorted ko de sakte hain.
List comprehensions — Ex 5 hai [x*x for x in nums if x % 2 == 1].
Iterators and lazy evaluation — Ex 3, 4, 10 ke peeche ka engine.
sorted and key functions — Ex 6 mein use hone wala tool.
Higher-order functions — Ex 9 mein sum(map(...)).

Worked examples — Lambda functions — anonymous, used with map - filter