Dictionary and set comprehensions: Visual walkthrough

1.2.35 · D2 · Coding › Introduction to Programming (Python) › Dictionary and set comprehensions

Koi bhi code se pehle, teen plain words jinhe hum baar baar point karte rahenge:

Step 1 — Undeniable starting point: ek empty box

KYA. Hum squares ki ek dictionary sabse dheeme, sabse obvious tarike se banaate hain — pehle ek empty container banao, phir usse bharo.

squares = {}          # an empty dict — the box

KYUN. Hume kisi aisi cheez se shuru karna hai jis par koi argue na kar sake. {} ek empty dict hai (yaad rakho empty-braces trap: {} ek dict hai, set() ek set hai). Abhi isme kuch nahi hai — zero key→value arrows.

PICTURE. Left mein box empty hai. Right mein conveyor belt par numbers 0,1,2,3,4 hain jo range(5) hume dega, ek ek karke. Abhi tak kuch move nahi hua.

Figure — Dictionary and set comprehensions

Step 2 — Ek item, ek arrow

KYA. Belt se pehla item uthao, n = 0, aur ek entry store karo: key 0 point karta hai value 0*0 = 0 par.

n = 0
squares[n] = n * n    # squares[0] = 0

Term by term, squares[n] = n*n par:

squares :::: woh box jise hum fill kar rahe hain.
[n] :::: kaunsa slot — key, yahan 0.
= n*n :::: us slot mein kya jaata hai — value, yahan 0.

KYUN. Yeh poori idea ka atom hai: belt se ek item ek key→value arrow banata hai. Baaki sab bas isko repeat karna hai.

PICTURE. Ek yellow arrow ab button 0 (key) se snack 0 (value) tak jaata hai. Belt ek step aage badh gayi hai.

Step 3 — Loop ko paanch baar karne do

KYA. Step 2 ko ek for loop mein wrap karo taaki belt par har item ko uska arrow mile.

squares = {}
for n in range(5):        # walk the belt: 0,1,2,3,4
    squares[n] = n * n    # one arrow per pass

KYUN. Loop bas Step 2 ka repetition hai. Pass 1 banata hai 0→0, pass 2 banata hai 1→1, pass 3 banata hai 2→4, wagera. Loop box ko drive karta hai; kuch naya invent nahi hua — sirf repetition.

PICTURE. Ab paanch arrows draw hain: 0→0, 1→1, 2→4, 3→9, 4→16. Notice karo ki loop mein teen moving parts hain, colour-coded: belt source range(5) (blue), key n (yellow), value n*n (green).

Step 4 — Fold: rearrange karo, kuch delete mat karo

KYA. Step 3 ke teen coloured pieces lo aur unhe ek line mein slide karo, unka order badlo lekin unka meaning nahi.

$slot squares[n] fill = n*n ⟹ {key n : value n*n the belt for n in range(5)}$

squares = {n: n*n for n in range(5)}
# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

KYUN. Comprehension ko left to right padho: yeh result-rule pehle kehta hai ("n : n*n, matlab yeh key us value ke saath pair hogi") aur source last ("har n ke liye belt par"). Woh reversed order hi ek naya cheez hai jiske adat daalni hai — machinery loop se bilkul identical hai.

PICTURE. Loop ke teen coloured blocks physically migrate karte hain: key n aur value n*n aage fly karte hain (unke beech colon ke saath), belt for n in range(5) peeche slide ho jaati hai. Same arrows, same result — bas ek line mein re-pack ho gaya.

Step 5 — Ek gate lagao: filtering `if`

KYA. Sirf even numbers ko assembly line par aane do by if ko end mein attach karke.

{n: n**2 for n in range(1, 11) if n % 2 == 0}
# {2: 4, 4: 16, 6: 36, 8: 64, 10: 100}

Term by term tail for n in range(1,11) if n % 2 == 0 par:

for n in range(1,11) :::: belt ab 1..10 carry kar rahi hai.
if n % 2 == 0 :::: ek gate — n % 2 remainder hai 2 se divide karne ke baad; == 0 matlab "koi remainder nahi", yaani even.

KYUN. if pair banne se pehle run hota hai. Agar n gate fail kare, to us par koi arrow kabhi nahi banta — odd numbers belt se gir jaate hain aur box tak kabhi nahi pahunchte.

PICTURE. Conveyor par ek gate hai. Even numbers (green) pass through hote hain aur apna arrow paate hain; odd numbers (red) pair hone se pehle bounce ho jaate hain. Gate sentence ke end mein hai — tum source padhte ho, phir gate, phir jaante ho kya survive hua.

Step 6 — Colon hatao: same animation, ab ek set

KYA. Key aur colon delete karo, sirf value rakho. Factory ab ek set build karta hai.

words = ["cat", "dog", "tiger", "ox"]
{len(w) for w in words}
# {2, 3, 5}

KYUN. Colon nahi hone par, har pass ek value produce karta hai (len(w)), pair nahi. Set sirf distinct values store karta hai, toh jab "cat" aur "dog" dono length 3 dete hain, doosra silently ignore ho jaata hai — set mein pehle se 3 hai. (Dekho Sets in Python kyun sets deduplicate karte hain, aur Hashing and hashable types kaise wo jaante hain ki ek value "already there" hai.)

PICTURE. Do length 3 set mein jaati hain; pehli place ho jaati hai, doosri ek already-occupied slot ki wall se bounce kar jaati hai. Top row (dict: pairs with colon) ko bottom row (set: single values, no colon) se compare karo — ek glyph hi poora difference hai.

Step 7 — Degenerate & edge cases (reader kabhi surprised na ho)

KYA. Teen boundary situations jinhe animations cover karni chahiye.

(a) Empty belt. Agar iterable empty hai, zero passes hote hain, toh tum ek empty collection paate ho — ek empty dict {} ya ek empty set().

{n: n*n for n in range(0)}   # {}   (belt had nothing)
{x for x in []}              # set()

(b) Colliding keys — later wins. Do items jo same key produce karte hain woh coexist nahi karte; baad wala pass pehle wale ko overwrite karta hai.

{x % 3: x for x in range(6)}
# expected 6 entries, got 3: {0: 3, 1: 4, 2: 5}
# key 0 got x=0 then x=3 -> 3 wins; key 1 got 1 then 4 -> 4; key 2 got 2 then 5 -> 5

(c) Unhashable key — ek crash, silent bug nahi. Key hashable honi chahiye; list nahi hoti.

{[1, 2]: "a"}   # TypeError: unhashable type: 'list'
# fix: use a tuple, which IS hashable
{(1, 2): "a"}   # fine

KYUN. Yahi exactly woh moments hain jab ek beginner sochta hai "comprehension broken hai." Nahi hai — yeh dict rules follow kar raha hai: unique hashable keys, later-writer-wins. (b) ka ek set version simply same logic se har value ki ek copy rakhta hai. (Ternary value-choosers jaise ("even" if n%2==0 else "odd") value slot mein rehte hain — dekho Ternary conditional expression.)

PICTURE. Left panel: empty belt → empty box. Middle panel: do arrows key 0 par aimed hain, doosra (green) pehle ko (faded) overwrite kar raha hai, ek entry bachi. Right panel: ek list-shaped key ek red barrier se "unhashable" stamped tak hit karti hai, tuple-shaped key pass ho jaati hai.

Ek-picture summary

Is page ki har cheez ek single frame mein compressed: ek belt items ko ek optional gate se feed karti hai; har survivor ya to ek key:value pair ban jaata hai (colon present → dict) ya ek single value (no colon → set); dicts unique hashable keys enforce karte hain, sets distinct values enforce karte hain.

Recall Feynman retelling — ek saanp mein kaho

Ek conveyor belt imagine karo jo numbers ek ek karke feed karti hai. Tum belt par ek box ke saath khade ho. Har number ke liye, tum do cheezein decide karte ho: ise kaunsa button milta hai (key) aur kaunsa snack yeh produce karta hai (value) — yahi front par key : value hai. for ... part bas belt hai jo tumhe batati hai kaunse numbers aate hain. Agar tum end mein ek if lagate ho, woh ek gate hai: numbers jo fail karte hain woh pair hone se pehle gir jaate hain. Agar tum colon drop karo, tum pairs banana band kar dete ho aur bas single values ek aisi bag mein toss karte ho jo duplicates refuse karta hai — woh set hai. Do items same button chahte hain? Baad wala pehle wale ko bahar dhakelta hai. Ek list ko button ki tarah use karne ki koshish? Machine jam ho jaati hai, kyunki buttons hashable hone chahiye. Woh puri story yahi hai jo ek line {k: v for x in xs if c} C speed par kar raha hai jabki tum ise Python mein dheere dheere karte.

Connections

1.2.35 Dictionary and set comprehensions (Hinglish) — parent topic, rule stated
List comprehensions — same fold, [] ke saath list produce karta hai
Dictionaries in Python — woh structure jo colon form se banta hai
Sets in Python — woh structure jo no-colon form se banta hai
Generator expressions — same head/tail shape lekin lazy, (...) mein
Hashing and hashable types — kyun keys/elements hashable hone chahiye
Ternary conditional expression — value-slot if/else