Dictionary and set comprehensions: Question bank — Hinglish deep dive

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

Shuru karne se pehle, teen words jo hum baar baar use karenge:

iterable — koi bhi cheez jise tum item by item walk kar sako (jaise range, list, d.items()).
hashable — ek aisi value jise Python ek fixed fingerprint mein convert kar sake, taaki wo dict key ya set element ban sake. Dekho Hashing and hashable types.
ternary — A if cond else B wala one-line chooser. Dekho Ternary conditional expression.

True or false — justify karo

Har item ek statement hai. Reveal karne se pehle true/false aur reason bolo.

{} ek empty set banata hai.

False. {} ek empty dict hai; historically braces pehle dicts ne claim ki thi. Empty set ke liye set() likhna padega.

{x for x in range(3)} aur {x: x for x in range(3)} same type produce karte hain.

False. Pehle mein colon nahi hai isliye ye set hai {0,1,2}; doosre mein k:v colon hai isliye ye dict hai {0:0, 1:1, 2:2}. Poora fark sirf colon ka hai.

Ek set comprehension mein duplicate elements ho sakte hain agar source mein duplicates hon.

False. Ek set kabhi duplicates store nahi karta; source repeat kar sakta hai, lekin result mein equal values collapse hokar ek ho jaati hain. Yahi collapsing wajah hai ki tum set choose karte ho.

Ek dict comprehension mein, do alag items safely same key par map ho sakti hain bina data lose kiye.

False. Keys unique hoti hain, isliye baad wala item silently pehle wale ko overwrite kar deta hai — pehli value chali jaati hai. Dekho Dictionaries in Python.

{[1,2]: "a"} aur {[1,2] for _ in range(1)} dono same reason se fail karte hain.

True. List unhashable hai, aur dict keys aur set elements dono ka hashable hona zaroori hai. Dono list nahi rakh sakte. Dekho Hashing and hashable types.

Ek comprehension hamesha poora collection memory mein build aur store karta hai.

True dict/set/list comprehensions ke liye. Lazy cousin jo materialise nahi karta wo hai generator expression (...) ke saath.

{v: k for k, v in d.items()} guaranteed hai ki ye d ka perfect inverse hoga.

False. Ye tabhi cleanly invert hoga jab d ki saari values unique hon; duplicate values duplicate keys ban jaati hain aur collide karti hain, entries kho jaati hain.

Filtering if aur if/else value-chooser dono same cheez ke do spellings hain.

False. Trailing if decide karta hai kaunse items andar aayenge; if/else ternary un items ki value choose karta hai jo andar aa chuke hain. Alag kaam, alag positions.

Set aur dict comprehensions equivalent explicit loop se faster hote hain mainly isliye ki wo for statement skip karte hain.

False. Ye phir bhi har item par loop karte hain. Speed-up isliye hota hai ki iteration aur building C mein internally chalti hai, har item ke liye per-item Python bytecode (.add/d[k]=) se bachte hue.

Error dhundo

Har line ka ek stated kaam hai lekin usme bug ya wrong assumption hai. Use name karo.

Intent: empty set banao. s = {}

s ek empty dict ban jaata hai, set nahi. Use karo s = set().

Intent: har item ko remainder ke basis par group karo. {x % 3: x for x in range(9)}

Sirf 3 keys bachti hain (0,1,2) aur har ek us remainder wala last x rakhti hai — pehle wale overwrite ho jaate hain. Sab rakhne ke liye loop ke saath lists wali dict banao.

Intent: coordinate pairs ka set. {[a, b] for a, b in pts}

Lists unhashable hain, isliye ye crash karta hai. Tuple use karo: {(a, b) for a, b in pts}.

Intent: har naam ko ek flag ke saath pair karo, sirf long names ke liye. {name: True for name in names if len(name) > 3 else False}

Trailing if ke saath else nahi aa sakta. Agar har naam ke liye flag chahiye, to choice ko value mein ternary ke roop mein daalo: {name: (len(name) > 3) for name in names}. Agar short names drop karne hain, toh trailing if rakho aur else hatao.

Intent: dict se (key, value) unpack karo. {v: k for k, v in grades}

Dict par directly iterate karne se sirf keys milti hain, pairs nahi, isliye unpack fail ho jaata hai. .items() call karna zaroori hai: for k, v in grades.items().

Intent: ek set banao, ek ek value. {k: v for k, v in pairs}

Colon ki wajah se ye dict ban jaata hai, set nahi. Set of keys ke liye :v hatao, ya pairs ke set ke liye {(k, v) for ...} likho.

Intent: do lists par dict comprehension. {a: b for a in xs for b in ys}

Ye nested (Cartesian) loop hai, isliye har a ko overwriting ke baad last b milta hai — one-to-one zip nahi hota. Use karo {a: b for a, b in zip(xs, ys)}.

Why questions

Colon ki presence, aur sirf wahi, dict-vs-set kyun decide karti hai?

Braces {} dono mein shared hain, isliye Python ko andar ek signal chahiye; colon kehta hai "ye element ek key→value pair hai," uski absence kehti hai "ye element ek akela value hai."

Dict keys (aur set elements) ka hashable hona zaroori kyun hai?

Dono structures ek hash use karte hain — value ka ek fixed fingerprint — ye decide karne ke liye ki use kahan store karna hai near-instant lookup ke liye. Jo value change ho sake (jaise list) us stored location ko tod degi, isliye Python use forbid karta hai. Dekho Hashing and hashable types.

"Distinct cheezein" ke liye set comprehension natural tool kyun hai, list comprehension kyun nahi?

List har item rakhti hai repeats ke saath; set ki defining property yahi hai ki equal elements ek mein collapse ho jaate hain, isliye de-duplication apne aap hoti hai bina filter kiye. Dekho Sets in Python vs List comprehensions.

Filtering if end mein kyun hoti hai jabki value-choosing if/else front mein?

End wala if loop ko gate karta hai — ye pair banne se pehle chalta hai, entry decide karta hai. Front wala ternary value build karte waqt chalta hai, decide karta hai ki accepted item kya store karega.

Ek comprehension 3–4 line loop ko result change kiye bina ek line mein kyun replace kar sakta hai?

Comprehension ka head exactly wahi hai jo tum store kar rahe the (d[k]=v ya s.add(v)), aur tail exactly wahi loop hai jo use drive kar raha tha — same computation hai, bas ek expression mein fold ho gaya.

{v: k for k, v in d.items()} se dict invert karna generally risky kyun hai lekin bijection ke liye theek hai?

Inversion purani values ko naye keys banata hai; agar do purani values equal thi toh ab collide karengi aur ek kho jaayegi. Jab mapping one-to-one (bijection) ho, values already unique hoti hain, isliye koi collision nahi hota.

{x for x in []} empty set kyun deta hai, lekin {} empty dict kyun deta hai?

{x for x in []} mein colon ke bina comprehension body hai, isliye Python ise ek set maanta hai jo khali hota hai. Bare {} mein koi body nahi hai, aur empty braces ka default matlab dict hai.

Edge cases

{n: n for n in range(0)} kya produce karta hai?

Ek empty dict {}. Iterable empty hai isliye body kabhi nahi chali, lekin colon phir bhi type ko dict fix karta hai.

{x % 2 for x in range(100)} kya hai?

Set {0, 1}. Sau items sirf do distinct values par map hote hain, aur set har ek ko ek baar rakhta hai — collapsing ka compact demonstration.

Kya {True: "a", 1: "b"}-style overwriting comprehensions mein bhi hoti hai?

Haan. True ka hash 1 ke barabar hota hai (aur False ka 0 ke), isliye {k: k for k in [1, True, 1.0]} ek single key deta hai. Numerically equal, same-hash values ko same key maana jaata hai.

{s: len(s) for s in ("", "a", "ab")} mein kya hota hai — kya empty string valid key hai?

Haan. "" ek perfectly hashable string hai, isliye result hai {"": 0, "a": 1, "ab": 2}. "Empty" aur "missing" ek nahi hote.

Agar same value alag keys se aaye, jaise {"x": 5, "y": 5} comprehension se bana ho, kya allowed hai?

Bilkul allowed hai. Sirf keys unique honi chahiye dict mein; values freely repeat ho sakti hain.

Runtime par unhashable items wala set comprehension jaise {[i] for i in range(3)} kya karta hai?

Ye pehle element par hi TypeError: unhashable type: 'list' raise karta hai — sets unhashable members bilkul refuse karte hain jaise dict keys karte hain.

Kya comprehension ki condition non-empty iterable ke saath bhi zero entries produce kar sakti hai?

Haan. Agar trailing if har item ke liye false ho (jaise {n: n for n in range(5) if n > 10}), tum empty dict paate ho — ek valid, common edge result.

Recall One-line self-test

{expr for item in it} mein colon hai ya nahi? ::: Colon nahi → set; k: v daalo → dict. {} ka type? ::: dict (empty set hai set()). Dict comprehension mein duplicate keys? ::: Last wala jeet ta hai, pehla kho jaata hai. Filter if kahan rehta hai? ::: Bilkul end mein, for ke baad.

Connections

Dictionary and set comprehensions — parent topic
List comprehensions — [] wala sibling jo duplicates rakhta hai
Dictionaries in Python — kyun keys unique hoti hain
Sets in Python — kyun duplicates gayab hote hain
Generator expressions — lazy (...) non-materialising cousin
Hashing and hashable types — kyun keys/elements hashable hone chahiye
Ternary conditional expression — front-slot value chooser