Visual walkthrough — List comprehensions — `[expr for x in iterable if condition]`

1.2.34 · D2 · Coding › Introduction to Programming (Python) › [[1.2.34 List comprehensions — `[expr for x in iterable if condition]`|List comprehensions — `[expr for x in iterable if condition]`]]

Step 1 — Conveyor belt (ek "iterable" hota kya hai)

KYA HAI. Koi bhi code se pehle, ek belt imagine karo jo items ko tumhare paas se ek-ek karke le jaati hai. Python mein us belt ko iterable kehte hain: kuch bhi jis par for loop chal sake — ek list, ek range, ek string. (Kya qualify karta hai, iske baare mein aur: range() and iterables.)

KYUN. Har comprehension for x in iterable phrase se shuru hoti hai. Agar tum yeh na socho ki items kahan se aate hain, toh baaki sab sirf symbols ko dhakkelna hai. Toh hum pehle symbol, iterable, ko ek chalti hui belt se anchor karte hain.

PICTURE. Niche, belt numbers 0,1,2,3,4 le jaati hai (yeh range(5) hai). x label wala chhota pointer us item par baitha hai jo abhi inspect ho rahi hai. x ek fixed number nahi hai — yeh current item ka naam hai, aur ek notch aage khisak jaata hai.

Step 2 — Honest 4-line loop (hamaari ground truth)

KYA HAI. Hum plain loop likhte hain jo "even numbers ke squares" banata hai. Kuch clever nahi — boring version jo sabko samajh aata hai.

result = []              # (a) empty box
for x in range(5):       # (b) belt: x = 0,1,2,3,4
    if x % 2 == 0:       # (c) guard: keep only evens
        result.append(x**2)   # (d) machine: square it, drop in box

KYUN. Yeh hamaari ground truth hai. Baad wale har ek-liner ko exactly yehi produce karna chahiye, warna woh galat hai. Hum comprehension ko kabhi memorise nahi karenge — hum ise hamesha is loop se re-derive kar payenge.

PICTURE. Ek ke baad ek chaar stations: empty box (a), belt (b), guard (c) jo items ko phenk deta hai, aur machine (d) jo survivors ko transform karke box mein daalti hai. Arrows follow karo: ek item box tak tabhi pahuncha jab woh guard se bach gaya.

Annotated code padhte hue, term-by-term:

• result = [] — woh box jo empty shuru hota hai aur badhta hai.
• for x in range(5) — belt; x har value leta hai.
• if x % 2 == 0 — guard; x % 2 2 se divide karne par remainder hai, toh == 0 ka matlab "even" hai.
• x**2 — machine; ** Python ka "to the power of" hai, toh x**2 hai $x^2$.
• .append(...) — "yeh box mein, end mein daal do".

Step 3 — Ek complete pass trace karo (box ko bhart dekho)

KYA HAI. Loop ko haath se, tick by tick, chalao, aur record karo guard aur box par kya hota hai.

KYUN. Sabse zyada common misreading (parent ke mistake callout ke according) yeh hai ki expr pehle chalta hai. Tracing us idea ko khatam kar deta hai: tum literally kisi item ko square nahi kar sakte jab tak belt ne use tumhe de na diya ho aur guard ne use through na jaane diya ho. Sahi order hai belt → guard → machine.

PICTURE. Table-as-picture: paanch rows, ek per tick. Green rows guard se bach gayi; faded rows phenk di gayi; sabse daahini column box ko badhta dikhata hai.

Final box: [0, 4, 16]. Yeh number yaad rakho — niche ka har ek-liner ise reproduce karna chahiye.

Step 4 — Teen slots ka naam rakho

KYA HAI. Loop se teen interchangeable pieces nikalo aur unhe unke official slot names do.

KYUN. Comprehension kuch nahi hai sirf yeh teen slots, rearranged. Jab ek baar tum loop mein har ek ko point kar sako, toh ek-liner sirf ek re-shuffle hai — koi nayi logic seekhne ki zaroorat nahi.

PICTURE. Loop mein exactly un parts ke around teen colored boxes drawn hain jo move hone waale hain: machine x**2 (coral), belt for x in range(5) (lavender), guard if x % 2 == 0 (mint).

Step 5 — Fold (loop → ek line)

KYA HAI. Teeno colored blocks ko physically ek line par, square brackets [ ] ke andar, move karo.

KYUN. Empty box aur .append pure mechanics hain — Python unhe free mein supply kar sakta hai. Jo actually meaning carry karta hai woh sirf teen slots hain. Toh hum mechanics drop karte hain aur meaning rakhte hain, reading order mein arrange karke: expr pehle (yeh woh answer hai jissi humein parwah hai), phir belt, phir guard.

PICTURE. Ek-frame-mein-animation: dashed arrows har colored block ko loop se upar uthake bracketed line mein le jaate hain. Box aur append strikethrough ke saath fade ho jaate hain.

$\underset{\text{new list}}{\underbrace{\text{[}}}\underset{expr=\text{machine}}{\underbrace{\text{x**2}}}\underset{\text{belt}}{\underbrace{\text{for x in range(5)}}}\underset{\text{guard}}{\underbrace{\text{if x \% 2 == 0}}}\text{]}$

Har symbol ko wahin padhna jahan woh baitha hai:

• [ ... ] — brackets hi woh box hain; Python ise banata hai aur hamare liye append karta hai.
• x**2 — wohi machine jaise line (d) mein thi; yeh sirf front mein aa gayi kyunki hum pehle answer padhte hain.
• for x in range(5) — wohi belt jaise line (b) mein thi, unchanged.
• if x % 2 == 0 — wohi guard jaise line (c) mein tha, ab belt ke baad likha gaya.

[x**2 for x in range(5) if x % 2 == 0]   # → [0, 4, 16]  ✓ matches Step 3

Step 6 — Reading order vs execution order (trap, drawn)

KYA HAI. Dono orders ko ek doosre ke upar dikhao taaki mismatch miss karna impossible ho.

KYUN. Tumhari aankh x**2 pehle padhti hai, toh brain assume karta hai ki woh pehle run hota hai. Aisa hota nahi. Python ab bhi belt → guard → machine run karta hai (Step 3 ne yeh prove kiya). Ek-liner sirf writing rearrange karta hai, execution kabhi nahi.

PICTURE. Usi line ke upar do arrows: ek top arrow (reading) expr se shuru hokar left→right point karta hai; ek bottom arrow (execution) jo pehle for par jump karta hai, phir if, phir expr par waapis loop karta hai.

Step 7 — Do ifs opposite sides par rehte hain (edge case)

KYA HAI. Do bilkul alag ifs hain, aur woh for ke opposite sides par baithte hain. Pakka karo kaun kaun sa hai.

KYUN. Yeh #1 real bug hai. Ek filter if items ko drop karta hai aur iske paas koi else nahi hota; yeh for ke baad jaata hai. Ek ternary if/else ek value choose karta hai aur hamesha else chahiye hota hai; yeh expr ke andar rehta hai, toh yeh for se pehle jaata hai. (Value-chooser par deep dive: Conditional expressions (ternary).)

PICTURE. for beech mein ek fence ki tarah baitha hai. Left side par (for se pehle) value-chooser n if n>0 else 0 khada hai. Right side par (for ke baad) item-dropper if n>0 khada hai. Do chhoti belts alag-alag outputs dikhati hain.

nums = [3, -1, 4, -5]
 
# FILTER if (for ke baad): items drop karta hai → chhoti list
[n for n in nums if n > 0]        # → [3, 4]
 
# TERNARY if/else (for se pehle, expr ke andar): sab rakhta hai, value change karta hai
[n if n > 0 else 0 for n in nums] # → [3, 0, 4, 0]

• Filter output mein kam items hain (-1, -5 chale gaye).
• Ternary output ki same length hai (negatives 0 ban gaye, kuch drop nahi hua).

Step 8 — Degenerate & boundary cases (kabhi surprise mat lo)

KYA HAI. Har corner walk karo: empty belt, guard jo sab reject karta hai, guard jo sab accept karta hai, aur koi guard hi nahi.

KYUN. Contract kehta hai reader ko koi aisa scenario nahi milna chahiye jo humne dikhaaya na ho. Comprehensions gracefully har edge par behave karti hain — woh simply waही return karti hain jo loop karta.

PICTURE. Chaar mini-belts side by side, har ek ke niche resulting box drawn hai.

Empty result error nahi hai — yeh honest answer hai "kuch nahi bachा". Same as loop building an empty box.

Ek-picture summary

Upar sab kuch, compressed: 4-line loop fold hoti hai ek line mein; teen slots apna meaning rakhte hain aur sirf position change karte hain; execution ab bhi belt → guard → machine flow karta hai chahe hum machine-first padhein; aur do ifs for ke dono taraf hain.

Connections

• For loops — woh loop jise yeh poora page fold karta hai.
• Conditional expressions (ternary) — Step 7 ka "choose a value" if/else.
• range() and iterables — for x in iterable mein belt ko kya feed karta hai.
• map() and filter() — map machine hai, filter guard hai, standalone functions ke roop mein.
• Generator expressions — same fold, lekin ( ) ke saath, items ko ek saath ki jagah lazily build karta hai.
• Dictionary and set comprehensions — { } ke saath identical fold.

Concept Map