Noesis
1.2.35 · D4 · HinglishIntroduction to Programming (Python)

Exercises — Dictionary and set comprehensions

2,432 words11 min read↑ Read in English

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

Shuru karne se pehle, yeh ek mental picture hai jo hum baar baar reuse karte hain — ek comprehension ki anatomy. Har coloured zone ek kaam hai: kya store karte ho, source kahan se aata hai, aur kya keep karte ho.

Figure — Dictionary and set comprehensions

Level 1 — Recognition

Goal: ek comprehension padho aur uska exact output predict karo. Abhi likhna nahi — bas dekhna hai.

L1.1

Har ek ka type aur value kya hai?

A = {}
B = {1, 2, 3}
C = {"a": 1}
D = {x for x in range(3)}
Recall Solution
  • A → empty dict (akele braces = dict, classic trap). type(A) hai dict.
  • B → ek set {1, 2, 3} (values hain, colon nahi).
  • C → ek dict {"a": 1} (colon present hai ⇒ key:value).
  • D → ek set comprehension jo {0, 1, 2} produce karta hai.

Yahan use hua rule: braces mein kahin bhi colon ⇒ dict; warna set; empty braces ⇒ dict.

L1.2

Output predict karo:

{n: n + 10 for n in range(3)}
Recall Solution

DRIVE deta hai n = 0, 1, 2. HEAD store karta hai n: n+10. Result: {0: 10, 1: 11, 2: 12}.

L1.3

Output predict karo:

{len(s) for s in ["hi", "yo", "sun"]}
Recall Solution

Lengths hain 2, 2, 3. Colon nahi ⇒ set, aur set duplicates drop karta hai. Dono 2 ek mein collapse ho jaate hain. Result: {2, 3}.

Level 2 — Application

Goal: ek stated task ke liye scratch se comprehension likho.

L2.1

Har number 1..5 ko uske cube se map karta hua ek dict banao.

Recall Solution 
{n: n**3 for n in range(1, 6)}
# {1: 1, 2: 8, 3: 27, 4: 64, 5: 125}

HEAD n: n**3, DRIVE for n in range(1, 6). range(1, 6) 6 se pehle rok leta hai, toh yeh 1..5 hai.

L2.2

nums = [4, 7, 10, 13] se, sirf 2 se divisible numbers ka ek set banao.

Recall Solution 
nums = [4, 7, 10, 13]
{x for x in nums if x % 2 == 0}
# {10, 4}

GATE if x % 2 == 0 element keep hone se pehle run hota hai. Sirf 4 aur 10 pass karte hain. (x % 2 2 se divide karne ke baad remainder hai; == 0 ka matlab hai "evenly divisible".)

L2.3

["cat", "dog", "ox"] mein har word ko uski length se map karta hua dict banao.

Recall Solution 
words = ["cat", "dog", "ox"]
{w: len(w) for w in words}
# {'cat': 3, 'dog': 3, 'ox': 2}

Note: values freely repeat ho sakte hain (yahan do 3 hain). Sirf keys unique hone chahiye — aur words already hain.

Level 3 — Analysis

Goal: collisions, ordering, aur kya silently disappear ho jaata hai, iske baare mein reason karo.

L3.1

Is dict mein kitni entries hain, aur kaun si survive karti hain?

{x % 3: x for x in range(7)}
Recall Solution

x run karta hai 0..6. Key hai x % 3, toh keys cycle karti hain 0,1,2,0,1,2,0. Same key ⇒ baad ki value overwrite karti hai pehli ko. Har key ka last writer track karo:

  • key 0: x=0,3,6 ne likha → last hai 6
  • key 1: x=1,4 ne likha → last hai 4
  • key 2: x=2,5 ne likha → last hai 5

Result: {0: 6, 1: 4, 2: 5} — 3 entries, 7 nahi.

L3.2

Is set ki size kya hai?

{abs(x) for x in [-2, -1, 0, 1, 2]}
Recall Solution

abs deta hai 2, 1, 0, 1, 2. Distinct values: {0, 1, 2} → size 3. -1,1 dono 1 mein collapse ho jaate hain aur -2,2 dono 2 mein. Yeh halving ek set ka poora point hai: yeh guarantee karta hai koi duplicates nahi.

L3.3

d = {"a": 1, "b": 2, "c": 1} ko {v: k for k, v in d.items()} se invert karo. Kitni entries result mein aati hain?

Recall Solution

.items() yield karta hai ("a",1), ("b",2), ("c",1). Naye keys hain purane values 1, 2, 1. Key 1 do baar appear hoti hai ("a" se phir "c" se); baad wala jeetta hai → "c". Result: {1: "c", 2: "b"} → 2 entries (ek grade collide kar gaya).

Level 4 — Synthesis

Goal: comprehensions ko ternaries, nesting, aur doosre iterables ke saath combine karo.

L4.1

Har n ko 0..5 mein string "even" ya "odd" se map karo.

Recall Solution 
{n: ("even" if n % 2 == 0 else "odd") for n in range(6)}
# {0:'even',1:'odd',2:'even',3:'odd',4:'even',5:'odd'}

Ternary conditional expression A if cond else B value slot (head) mein rehta hai. Yeh choose karta hai, toh har n ko phir bhi ek entry milti hai — kuch filter nahi hota.

L4.2

Do lists names = ["Asha", "Ravi"] aur scores = [90, 75] se, pairing dict banao.

Recall Solution 
names = ["Asha", "Ravi"]
scores = [90, 75]
{name: score for name, score in zip(names, scores)}
# {'Asha': 90, 'Ravi': 75}

zip dono lists ko lockstep mein walk karta hai, pehle ("Asha", 90) phir ("Ravi", 75) deta hai. Hum har pair ko name, score mein unpack karte hain.

L4.3

["bee", "add", "cab"] mein appear hone wale saare distinct letters ka set banao.

Recall Solution 
words = ["bee", "add", "cab"]
{ch for w in words for ch in w}
# {'b', 'e', 'a', 'd', 'c'}

Nested drive: dono fors ko left to right, outer to inner padho — "har word w ke liye, us word mein har character ch ke liye." Letters b,e,e,a,d,d,c,a,b collapse hokar 5 distinct {a, b, c, d, e} ban jaate hain.

Level 5 — Mastery

Goal: ek chhota tool design karo, dict vs set choose karo aur collisions deliberately handle karo.

L5.1

data = [3, 1, 4, 1, 5, 9, 2, 6, 5] diya hai, ek dict banao jo har distinct value ko uske appear hone ki count se map kare. (Hint: pehle distinct set banao, phir count karo.)

Recall Solution 
data = [3, 1, 4, 1, 5, 9, 2, 6, 5]
{v: data.count(v) for v in set(data)}
# {1: 2, 2: 1, 3: 1, 4: 1, 5: 2, 6: 1, 9: 1}

DRIVE mein set(data) kyun? Yeh har value ko ek baar deta hai, toh koi wasted recomputation nahi aur koi collisions nahi. data.count(v) list scan karke v count karta hai. 1 aur 5 do baar appear hote hain; baaki sab ek baar. Total distinct keys = 7.

L5.2

pairs = [("a", 1), ("b", 2), ("a", 3)] se ek dict banao jahan har key apni SAARI values ek list mein rakhe (toh "a" par collision preserve ho, overwrite na ho).

Recall Solution

Ek single comprehension "a": 3 ko "a": 1 overwrite karne dega. Saare rakhne ke liye, value ke andar distinct keys ko drive ke roop mein use karke group karo:

pairs = [("a", 1), ("b", 2), ("a", 3)]
keys = {k for k, _ in pairs}                 # {'a', 'b'}
{k: [v for kk, v in pairs if kk == k] for k in keys}
# {'a': [1, 3], 'b': [2]}

Outer dict comprehension distinct keys par drive karta hai; inner list comprehension har woh v gather karta hai jiska original key match kiya. "a" ab safely [1, 3] rakhta hai.

L5.3

Har n ke liye 1..10 mein ek dict banao jo "fizz" map kare agar 3 se divisible ho, "buzz" agar 5 se divisible ho, "fizzbuzz" agar dono se, warna n khud.

Recall Solution 
{n: ("fizzbuzz" if n % 15 == 0
     else "fizz" if n % 3 == 0
     else "buzz" if n % 5 == 0
     else n)
 for n in range(1, 11)}
# {1:1, 2:2, 3:'fizz', 4:4, 5:'buzz', 6:'fizz',
#  7:7, 8:8, 9:'fizz', 10:'buzz'}

Order matter karta hai: n % 15 (dono) pehle test karo, warna ek fizzbuzz number n % 3 branch mein catch ho jaayega aur galat label mil jaayega. Yeh ek chained ternary hai jo poori tarah value slot mein rehta hai — phir bhi koi filtering nahi, har n ko ek entry milti hai.

Connections

  • Dictionary and set comprehensions — parent topic jisko yeh exercises drill karte hain
  • List comprehensions — inner [v for ...] jo L5.2 mein use hua
  • Ternary conditional expression — L4.1 aur L5.3 mein value-chooser
  • Dictionaries in Python · Sets in Python — woh structures jo build ho rahe hain
  • Hashing and hashable types — kyun keys unique aur hashable honi chahiye
  • Generator expressions — lazy cousin jo (...) use karta hai