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

• expr = w.upper() — jo naye list mein jaata hai.
• iterable = ["hi", "yo"] — jahan se har w aata hai.
• condition = len(w) == 2 — w ko tabhi rakho jab yeh True ho.

Dono words ki length 2 hai, isliye dono survive karte hain → ["HI", "YO"].

Koi if nahi, isliye har item rakha jaata hai. Hum har ek mein 1 add karte hain:

• $10\to 11$
• $20\to 21$
• $30\to 31$

Answer: [11, 21, 31].

Yahan expr sirf n hai, isliye survivors unchanged pass hote hain. Test n > 5 7 aur 9 ko rakhta hai, 4 aur 2 ko drop karta hai.

Answer: [7, 9].

Odd ka matlab x % 2 == 1 (2 se divide karne ke baad remainder 1 ho).

[x**2 for x in range(6) if x % 2 == 1]

range(6) hai 0,1,2,3,4,5. Odds hain 1, 3, 5:

• $1^2=1$
• $3^2=9$
• $5^2=25$

Answer: [1, 9, 25].

Hum items drop nahi kar rahe, balki ek value choose kar rahe hain, isliye hum conditional expression (a if cond else b) use karte hain jo for ke pehle aata hai:

[n if n >= 0 else 0 for n in [3, -1, -4, 5]]

• $3\ge 0$ → 3 rakho
• $-1\ge 0$? Nahi → 0
• $-4\ge 0$? Nahi → 0
• $5\ge 0$ → 5 rakho

Answer: [3, 0, 0, 5]. (Dekho Conditional expressions (ternary).)

(a) Iterable empty hai, isliye loop body kabhi nahi chalta → []. (b) Paanch items consider hote hain, koi bhi x > 100 pass nahi karta, isliye sab filter out ho jaate hain → []. (c) range(0) koi number produce nahi karta → [].

Lesson: ek empty result do alag tareekon se hota hai — ek empty source, ya ek filter jo sab kuch reject kar de. Dono legal hain, dono error nahi hain.

Do fors outer-to-inner, top-to-bottom padte hain — bilkul nested loops ki tarah:

for row in grid:      # outer (leftmost for)
    for cell in row:  # inner
        result.append(cell)

Row by row: [1,2,3] → 1,2,3; [4] → 4; [] → (kuch nahi); [5,6] → 5,6.

Answer: [1, 2, 3, 4, 5, 6], jisme 6 elements hain. Empty inner list kuch contribute nahi karta — bilkul waisa jaise ek empty list par inner loop zero times chalta hai.

Outer i 0,1,2 chalta hai; har ek ke liye, inner j 0,1,2 chalta hai; sirf wahi pairs rakho jahan i < j.

• i=0: j=1→(0,1), j=2→(0,2) (j=0 fail karta hai 0<0)
• i=1: j=2→(1,2) (j=0,1 fail)
• i=2: koi j 2 < j satisfy nahi karta

Answer: [(0, 1), (0, 2), (1, 2)] — exactly 3 "strictly increasing" pairs.

Execution order ke hisaab se inner for y in range(x) y ko bind karta hai filter if y > 0 ke pehle, isliye y hamesha defined hota hai jab test hota hai. Trace karo:

• x=0: range(0) empty hai → koi y nahi.
• x=1: range(1) = 0 → y=0, 0 > 0 False → drop.
• x=2: range(2) = 0,1 → y=0 dropped, y=1 kept.

Answer: [1]. Rule yeh hai: ek filter if koi bhi variable use kar sakta hai jo uske left ke kisi for ne already bind kiya ho.

"3 se divisible" ka matlab x % 3 == 0. "Cube" ka matlab x**3.

[x**3 for x in range(1, 11) if x % 3 == 0]

range(1, 11) = 1..10; 3 ke multiples hain 3, 6, 9:

• $3^3=27$
• $6^3=216$
• $9^3=729$

Answer: [27, 216, 729].

Do ifs saath kaam karte hain — filter if (for ke baad) odds drop karta hai; ternary (for se pehle) label pick karta hai:

["big" if n > 4 else "small" for n in [-5, -2, 0, 3, 8] if n % 2 == 0]

Evens hain -2, 0, 8 (note: -5 % 2 == 1, 3 % 2 == 1, isliye dono odd → dropped).

• -2 > 4? Nahi → "small"
• 0 > 4? Nahi → "small"
• 8 > 4? Haan → "big"

Answer: ["small", "small", "big"].

Comprehension (ek English sentence):

[len(w) for w in ["cat", "dog", "banana", "sky"] if "a" in w]

"a" wale words: "cat" (3), "banana" (6). → [3, 6].

Functional equivalent:

list(map(len, filter(lambda w: "a" in w, ["cat","dog","banana","sky"])))

Same result [3, 6], lekin comprehension left-to-right padhta hai jaise "mujhe length do har word ki agar usme 'a' ho" — map(filter(...)) ko inside-out nest karne se zyada clear. Yahan comprehension prefer karo.

Main diagonal hai (0,0), (1,1), (2,2). Hum do fors nest karte hain aur r != c se unhe filter out karte hain:

[(r, c) for r in range(3) for c in range(3) if r != c]

Saare 9 pairs minus 3 diagonal wale = 6 pairs: [(0,1),(0,2),(1,0),(1,2),(2,0),(2,1)].

Sanity count: $3\times 3-3=6$ — list length se match karta hai.

(a) A ek list hai — saare 1000 squares turant build aur store ho jaate hain. (b) B ek generator hai (dekho Generator expressions) — yeh ek recipe store karta hai, squares ek ek karke, demand par produce karta hai, almost koi memory use nahi karta. (c) ${\sum }_{x=0}^{999}{x}^2=\frac{999\cdot 1000\cdot 1999}{6}=332833500$. Toh sum(B) = 332833500. (d) Ek generator ek full pass ke baad exhausted ho jaata hai. Doosra sum(B) kuch nahi dekhta → 0. (Ek list A baar baar sum kiya ja sakta hai; ek generator nahi.)

Comprehension trace (for → if → expr):

• x=0: even → append 0
• x=1: odd → skip
• x=2: even → append 20
• x=3: odd → skip

→ [0, 20].

Loop jisme yeh desugar hota hai:

r = []
for x in range(4):
    if x % 2 == 0:
        r.append(x * 10)
# r == [0, 20]

Identical output [0, 20]. Yahi defining law hai: comprehension us loop ke liye pure syntactic sugar hai — same picks, same filter, same appends, same list.

Filter if ki position ::: for ke baad (koi else nahi) — decide karta hai ki include karna hai ya nahi. Ternary if/else ki position ::: for se pehle, expr ke andar — decide karta hai kya value. Nested for order ::: sabse left wala for sabse outer loop hai, top-to-bottom padho. Empty result ke do tarike ::: empty source iterable, ya ek filter jo sab kuch reject kar de. Generator jo full consumption ke baad reuse ho ::: kuch yield nahi karta — woh exhausted hai.