Built-in functions — map, filter, zip, enumerate, sorted, reversed, min, max, sum, any, all: Exercises

1.2.33 · D4 · Coding › Introduction to Programming (Python) › Built-in functions — map, filter, zip, enumerate, sorted, re

Shuru karne se pehle, ek reminder simple words mein: lazy ka matlab hai ki tool (map, filter, zip, enumerate, reversed) koi kaam nahi karta jab tak aap maango nahi — isliye hum answer ko list(...) mein wrap karte hain taaki woh apne items de sake. Jab aap kisi answer ke around list(...) dekhein, woh "mujhe items dikhao" wala button hai.

L1 — Recognition

Yahan aap bas sahi tool ka naam batao. Koi code run nahi karna — woh built-in choose karo jiska ek-sentence wala kaam request se match karta ho.

Exercise 1.1

Har task ke liye, ek sabse sahi built-in ka naam batao:

(a) "List mein har number ko double karo."
(b) "Sirf positive numbers ko rakhho."
(c) "Har naam ko uske score ke saath pair karo."
(d) "Kya koi bhi failing grade hai (< 40)?"
(e) "Ek numbered list print karo, 1 se shuru karke."

Recall Solution 1.1

(a) map — iska ek kaam hai "har item par f apply karo".
(b) filter — iska ek kaam hai "woh items rakho jahan test truthy ho".
(c) zip — items ko position-by-position pair karta hai.
(d) any — "kya koi ek truthy hai?" (isko booleans grade < 40 feed karo).
(e) enumerate(..., start=1) — aapko (index, item) saath mein deta hai.

Exercise 1.2

Inme se kaun lazy iterator return karta hai (values dekhne ke liye list() mein wrap karna padega), aur kaun finished value turant return karta hai? map, sorted, filter, sum, zip, enumerate, reversed, max, any, all.

Recall Solution 1.2

Lazy iterators (list() chahiye): map, filter, zip, enumerate, reversed. Finished values turant: sorted (ek real list), sum (ek number), max (ek element), any (ek bool), all (ek bool). Memory hook: paanch lazy wale pipeline tools hain jo kisi cheez mein feed hote hain; reducers/orderers aapko ek concrete answer dete hain.

L2 — Application

Ab short expressions likho aur evaluate karo.

Exercise 2.1

map aur ek lambda use karke, [1, 2, 3, 4] ke cubes ki list banao.

Recall Solution 2.1

list(map(lambda x: x**3, [1, 2, 3, 4]))   # [1, 8, 27, 64]

list(...) kyun? map lazy hai — iske bina aap <map object ...> dekhoge. Lambda ka rule hai "mujhe cube karo"; map isse har item par apply karta hai.

Exercise 2.2

['hi', 'yes', 'hello', 'ok', 'world'] mein se sirf woh strings rakho jo 3 characters se zyaada lambi hain.

Recall Solution 2.2

list(filter(lambda s: len(s) > 3, ['hi', 'yes', 'hello', 'ok', 'world']))
# ['hello', 'world']

Yeh kyun? filter har us item ko rakhta hai jiska test truthy ho. len(s) > 3 sirf 'hello' (5) aur 'world' (5) ke liye True hai; 'yes' ki length 3 hai, jo nahi hai > 3, isliye woh drop ho jaata hai.

Exercise 2.3

Maano names = ['Ann', 'Bo', 'Cy'] aur ages = [30, 25, 40, 99] hain, toh (name, age) pairs ki list banao. Kitne pairs honge, aur kyun?

Recall Solution 2.3

list(zip(['Ann','Bo','Cy'], [30, 25, 40, 99]))
# [('Ann', 30), ('Bo', 25), ('Cy', 40)]

Teen pairs. zip sabse chote iterable par ruk jaata hai. names mein 3 items hain, ages mein 4, isliye akela 99 (koi matching naam nahi) drop ho jaata hai.

Exercise 2.4

['pear', 'fig', 'banana', 'kiwi'] ko alphabetically sort karo, phir length ke hisaab se (sabse chota pehle).

Recall Solution 2.4

sorted(['pear','fig','banana','kiwi'])            # ['banana', 'fig', 'kiwi', 'pear']
sorted(['pear','fig','banana','kiwi'], key=len)   # ['fig', 'pear', 'kiwi', 'banana']

Pehli line: strings ke liye default order alphabetical hota hai, isliye banana < fig < kiwi < pear. Doosri line: key=len har word ki length se sort karta hai: fig(3), phir do length-4 words. 'pear' input mein 'kiwi' se pehle tha, aur Python ka sort stable hai, isliye ties apna original order rakhte hain — isliye pear, kiwi se pehle aata hai.

L3 — Analysis

Outputs predict karo aur kyun explain karo — yahan laziness aur edge cases bite karte hain.

Exercise 3.1

Dono outputs predict karo aur difference explain karo:

m = map(str, [1, 2, 3])
print(list(m))
print(list(m))

Recall Solution 3.1

['1', '2', '3']
[]

Kyun? map ek single-use lazy iterator return karta hai. Pehla list(m) ise end tak walk karta hai, consume kar deta hai. Doosra list(m) ise already exhausted paata hai — kuch nahi bacha → empty list. Fix pattern: ek baar materialize karo: m = list(map(str, [1,2,3])), phir m ko freely reuse karo.

Exercise 3.2

Bina run kiye, har ek ki value aur kyun batao:

any([])          # (a)
all([])          # (b)
any([0, '', None])   # (c)
all([1, 2, 0, 3])    # (d)

Recall Solution 3.2

(a) any([]) → False. any items par OR hai; OR ki identity False hai, isliye ek empty OR False hai.
(b) all([]) → True. all items par AND hai; AND ki identity True hai — yeh vacuous truth hai.
(c) any([0, '', None]) → False. Teeno falsy hain (zero, empty string, None), isliye "kya koi truthy hai?" → nahi.
(d) all([1, 2, 0, 3]) → False. all pehle falsy item par short-circuit karta hai — 0 — aur turant False return karta hai, 3 ko kabhi dekhta bhi nahi. Dekho Truthiness in Python.

Exercise 3.3

Maano pairs = [(1,'a'), (2,'b'), (3,'c')] hai, toh nums aur letters kya ban jaate hain?

nums, letters = zip(*pairs)

Recall Solution 3.3

nums    # (1, 2, 3)
letters # ('a', 'b', 'c')

Kyun? *pairs list ko spread karta hai, isliye call ban jaata hai zip((1,'a'), (2,'b'), (3,'c')). zip column-wise pair karta hai: pehle slots (1,2,3), doosre slots ('a','b','c'). Yeh wahi "unzip" karta hai jo zip ne originally join kiya tha.

L4 — Synthesis

Multiple tools ko ek clean pipeline mein combine karo.

Exercise 4.1

[3, -1, 4, -1, 5, -9, 2, 6] mein se, filter phir sum use karke sirf positive numbers ka total nikalo.

Recall Solution 4.1

data = [3, -1, 4, -1, 5, -9, 2, 6]
sum(filter(lambda x: x > 0, data))   # 20

Chain kyun? filter positives [3, 4, 5, 2, 6] rakhta hai; sum unhe ek total mein collapse karta hai. 3+4+5+2+6 = 20. Note karo ki sum ek lazy filter iterator bhi khushi se khaa jaata hai — koi list() zaroorat nahi kyunki sum ise directly consume karta hai.

Exercise 4.2

Maano people = [('Ann',30), ('Bo',25), ('Cy',40), ('Di',40)] hai, toh sabse bade umar wale person ka naam nikalo. Tie par kaun jeetta hai?

Recall Solution 4.2

people = [('Ann',30), ('Bo',25), ('Cy',40), ('Di',40)]
max(people, key=lambda p: p[1])   # ('Cy', 40)

key kyun? Iske bina, max poore tuples compare karta hai. key=lambda p: p[1] batata hai "age (index 1) se compare karo". Sabse badi age 40 hai, jo Cy aur Di dono ki hai. max pehla maximal element return karta hai jo use milta hai, aur Cy, Di se pehle aata hai, isliye Cy tie jeetta hai. Sirf naam lene ke liye: [0] se wrap karo.

Exercise 4.3

Ek leaderboard string banao. Maano scores = [('Ann',90), ('Cy',70), ('Bo',85)] hai, toh ek list produce karo jaise ['1. Ann (90)', '2. Bo (85)', '3. Cy (70)'] — sabse zyaada score pehle sort kiya, 1 se number kiya.

Recall Solution 4.3

scores = [('Ann',90), ('Cy',70), ('Bo',85)]
ranked = sorted(scores, key=lambda p: p[1], reverse=True)
# [('Ann',90), ('Bo',85), ('Cy',70)]
board = [f"{i}. {name} ({sc})" for i, (name, sc) in enumerate(ranked, start=1)]
# ['1. Ann (90)', '2. Bo (85)', '3. Cy (70)']

Har tool kyun? sorted(..., key, reverse=True) score ke hisaab se order karta hai, sabse bada pehle. enumerate(..., start=1) humein rank number aur pair saath mein deta hai, isliye hum kabhi woh buggy range(len(...)) wala dance nahi karte. Comprehension har line format karta hai. Neeche figure dekho.

Figure — Built-in functions — map, filter, zip, enumerate, sorted, reversed, min, max, sum, any, all

L5 — Mastery

Poore multi-step problems. Reveal karne se pehle dhyan se sochho.

Exercise 5.1 — Word frequency winner

Maano words = ['fig', 'pear', 'fig', 'kiwi', 'pear', 'fig'] hai, toh sirf built-ins (set, max, aur ek key) use karke sabse zyaada baar aane wala word nikalo.

Recall Solution 5.1

words = ['fig', 'pear', 'fig', 'kiwi', 'pear', 'fig']
max(set(words), key=words.count)   # 'fig'

Kyun? set(words) distinct candidates deta hai {'fig','pear','kiwi'}. key=words.count har candidate ko map karta hai ki woh kitni baar aata hai: fig→3, pear→2, kiwi→1. max phir woh candidate return karta hai jiska count sabse bada ho — fig. Edge note: tie par, max pehla maximal candidate return karta hai jo use milta hai — aur set iteration order guaranteed nahi hoti, isliye rely mat karo ki tie mein kaun jeetega.

Exercise 5.2 — Validate a grid

Ek grid rows (lists) ki list hai. Yeh valid hai agar har row ki length same ho. all, map, aur set use karke ek one-line check likho. Ise [[1,2,3],[4,5,6]] aur [[1,2],[3,4,5]] par test karo.

Recall Solution 5.2

def rectangular(grid):
    return len(set(map(len, grid))) == 1
 
rectangular([[1,2,3],[4,5,6]])   # True
rectangular([[1,2],[3,4,5]])     # False

Kyun? map(len, grid) har row ki length deta hai: [3, 3] vs [2, 3]. set(...) mein wrap karne se sirf distinct lengths bachti hain: {3} vs {2, 3}. Agar saari rows ek length share karti hain, toh set mein exactly ek element hoga → valid. (Aap all se bhi likh sakte ho: all(len(r) == len(grid[0]) for r in grid) — dono sahi hain.)

Exercise 5.3 — Running maximum via zip

Maano a = [3, 1, 4, 1, 5] aur b = [2, 7, 0, 8, 5] hain, toh har position par badi value wali list banao (element-wise max).

Recall Solution 5.3

a = [3, 1, 4, 1, 5]
b = [2, 7, 0, 8, 5]
list(map(lambda pair: max(pair), zip(a, b)))
# [3, 7, 4, 8, 5]
# equivalently: [max(x, y) for x, y in zip(a, b)]

zip + max chain kyun? zip(a, b) unhe position-pairs mein glue karta hai (3,2),(1,7),(4,0),(1,8),(5,5). Har pair par max apply karne se bada wala milta hai: 3,7,4,8,5. Aakhri position par dono 5 hain, isliye max 5 return karta hai — ties yahan harmless hain.

Exercise 5.4 — Reverse-order ranked flags

Maano temps = [18, 25, 30, 12, 22] hai, toh (rank_from_hottest, temp) pairs list karo. Rank 1 = sabse garam.

Recall Solution 5.4

temps = [18, 25, 30, 12, 22]
hottest_first = sorted(temps, reverse=True)   # [30, 25, 22, 18, 12]
list(enumerate(hottest_first, start=1))
# [(1, 30), (2, 25), (3, 22), (4, 18), (5, 12)]

reverse=True kyun, reversed nahi? sorted(temps, reverse=True) ek step mein sort aur flip karta hai. reversed(sorted(temps)) bhi kaam karta (ascending sort karo, phir ulta chalao) — same result — lekin reverse=True ek clear step hai. Phir enumerate(..., start=1) sabse garam se number karta hai.

Recall Ek-screen recap

Pipeline (lazy): map transform · filter keep · zip pair · enumerate number · reversed back-to-front. Answers (eager): sorted naya ordered list · min/max extreme (key use karo!) · sum total · any/all OR/AND with short-circuit. Gotchas: iterators single-use hote hain → ek baar list() karo; key order karta hai kabhi remove nahi karta; all([])=True, any([])=False.