Exercises — Nested data structures — list of dicts, dict of lists

comprehension kya hota hai (aur hum ise kyun use karte hain) Ek list comprehension [f(x) for x in seq] shorthand hai "ek nayi list banao f ko seq ke har x pe run karke." Yeh 3-line loop replace karta hai:

out = []
for x in seq:
    out.append(f(x))

Hum ise yahan kyun use karte hain: LoD mein, ek column ki values alag-alag dicts mein bikhri hoti hain. Ek comprehension unhe gather karne ka compact tarika hai — [row["score"] for row in people_lod] har row pe chalta hai aur uska score ek flat list mein kheench laata hai. Sirf kuch rows rakhne ke liye end mein if cond add karo. Poori treatment List Comprehensions mein.

mutable objects identity share karte hain (kyun ek edit do names pe dikh sakta hai) Lists aur dicts mutable hain — tum unka content in place change kar sakte ho. Importantly, ek variable list ki copy nahin rakhta; woh memory mein ek list object ka reference (pointer) rakhta hai. Agar do names usi list ki taraf point kar rahein hain, toh ek ke through edit karna doosre se bhi dikhta hai:

a = []
b = a          # b points to the SAME list as a
a.append(1)
b              # [1]  — b changed too, they are one object

Yahan kyun matter karta hai: kai exercises mein galti se bahut saare dict keys ek hi list share kar lete hain, toh ek mein append karna sab mein append karta dikh jaata hai. Fix yeh hai ki hamesha ek fresh list banao. Poori treatment Mutable vs Immutable mein.

• A ek LoD hai: outer [...] hai (ek list), har element ek dict hai → list of dicts.
• B ek DoL hai: outer {...} hai (ek dict), har value ek list hai → dict of lists. Giveaway hamesha sabse baahri bracket hoti hai: [ ⇒ list ⇒ LoD, { ⇒ dict ⇒ DoL.

Pehle outer peel karo. people_lod[1] doosri row hai (index 0 se start hoti hai): {"name": "Ravi", "age": 22, "score": 73}. Phir ["name"] us dict ka name field padhta hai. Answer: "Ravi".

Transpose law apply karo — pehle key, phir integer index: people_dol["name"][1] → "Ravi". LoD ke people_lod[1]["name"] se compare karo: dono coordinates ka order literally swap ho gaya.

LoD (scores alag-alag dicts mein bikhre hain → pehle comprehension se gather karo):

total = sum(p["score"] for p in people_lod)   # 88 + 73 + 95 = 256
avg = total / len(people_lod)                 # 256 / 3

DoL (column already flat list hai → directly sum karo):

avg = sum(people_dol["score"]) / len(people_dol["score"])   # 256 / 3

Dono $256/3\approx 85.33$ dete hain. Yahi reason hai ki DoL column math mein jeet jaata hai: koi gathering step nahin. p["score"] for p in ... engine ke liye List Comprehensions dekho.

LoD — pehle row dhundhni padegi (naam se search), phir uski field edit karo:

for p in people_lod:
    if p["name"] == "Ravi":
        p["score"] += 5     # 73 → 78

DoL — agar position already pata hai (row index 1), directly edit karo:

people_dol["score"][1] += 5   # 73 → 78

Dono mein nayi value: 78. (Yeh in place mutate karta hai — Mutable vs Immutable dekho.)

top = [p for p in people_lod if p["score"] >= 85]
names = [p["name"] for p in top]   # ["Asha", "Meera"]

Asha (88) aur Meera (95) pass karte hain; Ravi (73) fail karta hai. Result names: ["Asha", "Meera"]. Humne in place delete karne ki jagah nayi list banai — zyada safe hai (L5 trap dekho).

people_lod ek list hai. List ko sirf integer (ya slice) se index kiya ja sakta hai, kabhi string se nahin. Python TypeError raise karta hai: "list indices must be integers or slices, not str." Fix transpose law hai: pehle integer → people_lod[0]["name"].

1. LoD — ek record ek self-contained dict hota hai jise tum list mein sirf .append(...) kar dete ho.
2. DoL — age column already ek flat list hai, toh max(people_dol["age"]) seedha kaam karta hai. (Yahaan max = 22.)
3. DoL — key strings ("name", "age", "score") dict keys ke roop mein ek baar store hote hain, ek million dicts mein baar baar nahin. LoD mein key strings ek million baar store honge. Yahi shape Pandas DataFrame hood ke andar use karta hai.

count = sum(1 for p in people_lod if p["age"] > 20)   # Ravi(22), Meera(21) → 2

sum(1 for ...) un rows ko count karta hai jo pass karte hain. Answer: 2. (Asha exactly 20 hai, toh > 20 use exclude karta hai.)

Haath se: har key ke liye chalo, us key ki value ko order mein har row se collect karo.

• name column: ["Asha", "Ravi"]
• score column: [88, 73] One-liner:

dol = {k: [row[k] for row in lod] for k in lod[0]}
# {"name": ["Asha", "Ravi"], "score": [88, 73]}

Outer comprehension keys pe iterate karta hai (pehli row lod[0] se liye, kyunki sab rows keys share karte hain). Inner comprehension har row pe chalta hai us key ki values gather karne ke liye. Yeh literally $\text{[i][c]}\to \text{[c][i]}$ swap perform karta hai.

keys = list(dol)                 # ["name", "score"]
n = len(dol[keys[0]])            # rows = length of any column = 2
lod = [{k: dol[k][i] for k in keys} for i in range(n)]
# [{"name":"Asha","score":88}, {"name":"Ravi","score":73}]

list(dol) ["name", "score"] kyun deta hai: Python mein ek dict ko iterate karna — ya use list(...) mein wrap karna — uski keys pe chalta hai, values pe nahin. Toh list(dol) insertion order mein column names ki ek plain list hai. (Values ke liye tum dol.values() maangoge; pairs ke liye dol.items().) Hume yahan column names chahiye, toh list(dol) bilkul sahi hai. Phir row index i ko 0 se n-1 tak loop karo. Har i ke liye, har column ka i-wa element padh ke ek dict banao. Woh hai dol[k][i] — DoL coordinate — lod[i][k] mein assemble kiya gaya.

groups = {}
for t in tx:
    groups.setdefault(t["city"], []).append(t["amt"])
# {"Pune": [100, 60], "Delhi": [40]}

setdefault(key, []) key ke liye existing list return karta hai, ya pehli baar us key ko dekhne par ek fresh empty list create karta hai, phir hum .append karte hain. Result: Pune → [100, 60], Delhi → [40]. Har city ka sum: Pune = 160, Delhi = 40.

Pehle saari rows mein se poora key set collect karo (sirf lod[0] par bharosa mat karo, woh kuch keys miss kar sakta hai jo kuch rows mein hain aur kuch mein nahin). Phir .get(k) use karo jo key absent hone par None return karta hai.

keys = {k for row in lod for k in row}          # {"name", "score"}
dol = {k: [row.get(k) for row in lod] for k in keys}
# {"name": ["Asha", "Ravi"], "score": [88, None]}

score column [88, None] hai — Ravi ki missing cell KeyError raise karne ki jagah None ban gayi. Yeh exactly wahi shape hai jo JSON and APIs tab deta hai jab records inconsistent hote hain.

Galat (iterate karte waqt mutate karna):

for p in people_lod:
    if p["score"] < 80:
        people_lod.remove(p)   # BUG: shifts indices mid-loop → skips elements

Jab tum ek item remove karte ho, uske baad sab kuch left shift ho jaata hai, lekin loop ka internal counter phir bhi aage badhta hai — toh woh element jo freed slot mein slide ho gaya woh skip ho jaata hai. Correct (nayi list banao):

people_lod = [p for p in people_lod if p["score"] >= 80]
# keeps Asha(88), Meera(95); drops Ravi(73)

Surviving names: ["Asha", "Meera"]. Kyun nayi list mein filter karna safe idiom hai, yeh Loops and Iteration mein dekho.

1. sum(p["score"] for p in []) / len([]) → sum 0 hai, len 0 hai → ZeroDivisionError. Safe: avg = total / n if n else 0 (ya None). Divide-by-zero ko explicitly guard karo.
2. {k: [...] for k in lod[0]} → empty list par lod[0] IndexError hai (koi pehli row nahin). Safe: dol = {} if not lod else {k: [row.get(k) for row in lod] for k in lod[0]}. Empty dataset mein koi column nahin hota, toh empty DoL {} sahi answer hai.