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

1.2.33 · Coding › Introduction to Programming (Python)

The mental model: har function EK sawaal ka jawab deta hai

Function	Jawab deta hai yeh sawaal	Returns
`map(f, xs)`	"Har item pe `f` apply karo"	lazy iterator
`filter(f, xs)`	"Woh items rakho jahan `f(item)` truthy ho"	lazy iterator
`zip(a, b)`	"Items ko position-by-position pair karo"	lazy iterator of tuples
`enumerate(xs)`	"Mujhe index aur item dono chahiye"	lazy iterator of `(i, item)`
`sorted(xs)`	"Ek nayi ordered list do"	list
`reversed(xs)`	"Ise back-to-front walk karo"	lazy iterator
`min` / `max`	"Sabse chhota / sabse bada"	one element
`sum(xs)`	"Sab jodo"	number
`any(xs)`	"Kam se kam ek truthy hai kya?"	bool
`all(xs)`	"Sab truthy hain kya?"	bool

1. Transforming — `map`

Worked example Har number ko square karo

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

list(...) kyun? map lazy hai; iske bina tum <map object ...> print karoge. Lambda kyun? f ek function hona chahiye; lambda x: x**2 ek chhota sa inline function hai.

map multiple iterables le sakta hai — tab f ek-ek item har iterable se receive karta hai:

list(map(lambda a, b: a + b, [1,2,3], [10,20,30]))  # [11, 22, 33]

Yeh step kyun? Yeh sabse chhote iterable pe ruk jaata hai, bilkul zip ki tarah.

2. Selecting — `filter`

Worked example Even numbers rakho

list(filter(lambda x: x % 2 == 0, range(10)))  # [0, 2, 4, 6, 8]

x % 2 == 0 kyun? Even ⇔ remainder 0. Predicate ko True/False-ish return karna chahiye. Special case: filter(None, xs) saare falsy items (0, '', None, []) drop kar deta hai.

3. Pairing — `zip` aur 4. Indexing — `enumerate`

Definition zip

zip(a, b, ...) tuples (a[i], b[i], ...) yield karta hai, sabse chhote pe ruk ke.

names  = ['A: ','Bo','Cy']
scores = [90, 85, 70]
list(zip(names, scores))   # [('A: ',90),('Bo',85),('Cy',70)]

Definition enumerate

enumerate(iterable, start=0) (index, item) yield karta hai. Yeh literally zip(count, iterable) hai.

for i, v in enumerate(['a','b','c'], start=1):
    print(i, v)        # 1 a / 2 b / 3 c

Ise kyun use karo? Galti-prone for i in range(len(xs)): xs[i] ki jagah, tumhe index + value saaf milte hain.

Worked example Unzip (ulta)

* se

pairs = [(1,'a'), (2,'b'), (3,'c')]
nums, letters = zip(*pairs)   # (1,2,3) , ('a','b','c')

Yeh kyun kaam karta hai: *pairs list ko zip((1,'a'),(2,'b'),(3,'c')) mein spread kar deta hai, toh column-wise pairing unhe phir se alag kar deti hai.

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

5. Ordering — `sorted` (aur 6. `reversed`)

Worked example Words ko length se sort karo, sabse lamba pehle

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

key=len kyun? Python key(item) ke return value se sort karta hai, yahan length. Items khud saath aate hain. Tie-break: pear aur kiwi dono length 4 — Python ka sort stable hai, toh ties mein original order preserve hoti hai.

7–11. Summarizing — `min, max, sum, any, all`

Worked example max with a key

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

Key kyun? Iske bina max poore tuples compare karta; key batata hai "age (index 1) se compare karo".

Recall Feynman: ek 12-saal ke bachche ko explain karo

Socho ek line mein bachche khade hain, har koi ek card pakde hua.

map: har bachcha apna card ek hi rule se badalta hai (number double karo).
filter: sirf woh bachche rukते hain jinka card laal hai; baaki baith jaate hain.
zip: ladkon ki line aur ladkiyon ki line ko pair mein haath milao.
enumerate: ek teacher line mein chalti hai kehte hue "#1 tum ho, #2 tum ho…".
sorted: bachcho ko lambe se chhote order mein ek nayi line mein lagao (puraani line waise hi rehti hai).
reversed: usi line ko peeche se chalo.
min/max/sum: sabse chhota bachcha / sabse lamba bachcha / total height dhundo.
any: "kya koi bhi laal pehne hua hai?" — all: "kya sab laal pehne hue hain?"

Common mistakes (Steel-man + Fix)

Common mistake Ek consumed iterator ko reuse karna

m = map(str, [1,2,3])
list(m)   # ['1','2','3']
list(m)   # []  ← already exhausted!

Kyun sahi lagta hai: lists ko kai baar loop kiya ja sakta hai. Fix: ek baar materialize karo: m = list(map(...)).

Flashcards

map(f, xs) kya return karta hai aur kya yeh lazy hai?

Ek iterator jo har x ke liye f(x) yield karta hai; haan, lazy aur single-use hai — dekhne ke liye list() mein wrap karo.

enumerate aur zip ka kya rishta hai?

enumerate(xs) ≈ zip(itertools.count(start), xs); yeh har item ke saath ek index pair karta hai.

all([]) True kyun return karta hai?

Vacuous truth — all items pe AND hai; AND ka identity element True hai, toh khaali all True hota hai.

any([]) False kyun return karta hai?

any items pe OR hai; OR ka identity False hai, toh khaali any False hota hai.

sorted(xs) aur xs.sort() mein kya fark hai?

sorted ek NAYI list return karta hai (koi mutation nahi); .sort() in-place mutate karta hai aur None return karta hai.

sorted/min/max mein key argument kya karta hai?

Har item ko ek aisi value pe map karta hai jis SE compare kiya jaata hai; items khud rakhe/return kiye jaate hain.

pairs = [(1,'a'),(2,'b')] ko unzip kaise karte hain?

nums, letters = zip(*pairs).

Iterables ki length alag hone par zip kya karta hai?

Sabse chhote wale pe ruk jaata hai.

print(filter(...)) <filter object> kyun dikhata hai?

filter ek lazy iterator hai; values materialize karne ke liye list() mein wrap karo.

filter(None, xs) kya karta hai?

Sirf truthy items rakhta hai (0, '', None, [], etc. drop kar deta hai).

Kya any/all short-circuit hain?

Haan; any pehle truthy pe ruk jaata hai, all pehle falsy pe.

Strings ke liye sum(['x','y']) ka equivalent kya hai?

''.join(['x','y']) — sum 0 se shuru hota hai aur string mein add nahi ho sakta.

Connections

List comprehensions — aksar map/filter ka ek saaf alternative: [x**2 for x in xs].
Lambda functions — woh chhoti si f jo tum map/filter/sorted mein pass karte ho.
Iterators and generators — "lazy" aur "single-use" explain karta hai.
functools.reduce — sum/min/max ke peeche ka general reducer.
Truthiness in Python — filter, any, all ko drive karta hai.
Sorting algorithms — sorted (Timsort) under the hood kya karta hai, aur stability.