List - dict comprehensions and generators — Hinglish notes

1.4.3 · AI-ML › Python & Scientific Computing

What are comprehensions?

Definition List comprehension

Ek list comprehension ek syntactic construct hai jo ek iterable ke har item par expression apply karke ek list banata hai, optionally condition se items ko filter karta hai.

Syntax: [expression for item in iterable if condition] if clause optional hai. Yeh replace karta hai:

result = []
for item in iterable:
   if condition:
       result.append(expression)

Comprehensions kyun exist karte hain: Loop boilerplate intent ko obscure kar deta hai. Compare karo:

# Verbose loop
squares = []
for x in range(10):
    squares.append(x**2)
 
# Comprehension: intent clear in one line
squares = [x**2 for x in range(10)]

Doosra version declarative hai—tum state karte ho kya chahiye (squared numbers) bina kaise ke (list initialize karo, loop mein append karo). Python ka parser bhi comprehensions ko manual loops se behtar optimize kar sakta hai.

Worked example Do lists se dictionary banana

Task: keys = ['a', 'b', 'c'] aur values = [1, 2, 3] ko {'a':1, 'b':2, 'c':3} mein pair karo.

keys = ['a', 'b', 'c']
values = [1, 2, 3]
# Dict comprehension
mapping = {k: v for k, v in zip(keys, values)}
# Result: {'a': 1, 'b': 2, 'c': 3}

Yeh step kyun?
zip(keys, values) tuples ('a',1), ('b',2), ('c',3) produce karta hai. Comprehension mein k, v unpack karna har tuple ke elements assign karta hai. {k: v ...} syntax dict banata hai.

Worked example Conditions se filtering

Task: 0 se 9 tak ke even squares extract karo.

even_squares = [x**2 for x in range(10) if x % 2 == 0]
# Result: [0, 4, 16, 36, 64]

Yeh step kyun?
if x % 2 == 0 x**2 compute karne se pehle filter karta hai. Sirf condition pass karne wale values output mein jaate hain. Order: iterate → filter → transform → collect.

Worked example Nested comprehensions (flattening)

Task: matrix = [[1,2], [3,4], [5,6]] ko [1,2,3,4,5,6] mein flatten karo.

matrix = [[1,2], [3,4], [5,6]]
flat = [item for row in matrix for item in row]
# Result: [1, 2, 3, 4, 5, 6]

Yeh step kyun?
Left-to-right nested loops ki tarah padho: for row in matrix (outer), phir for item in row (inner). Har item append hota hai. Yeh mirror karta hai:

flat = []
for row in matrix:
   for item in row:
       flat.append(item)

What are generators?

Generators kyun: Ek list [x**2 for x in range(10**9)] 1 billion integers ke liye space allocate karta hai (~4-8 GB). Ek generator (x**2 for x in range(10**9)) iterator object ke liye ~200 bytes allocate karta hai. Values on the fly compute hoti hain.

Worked example Generator expression

gen = (x**2 for x in range(5))
print(list(gen))  # [0, 1, 4, 9, 16]
print(list(gen))  # [] — exhausted!

Yeh step kyun?
list(gen) call karna evaluation force karta hai: generator sequentially 0², 1², .., 4² yield karta hai, ek list mein collect hota hai. Exhaustion ke baad, generator ki internal state "end" par hai, isliye doosri call kuch bhi yield nahi karti.

Worked example Generator function

def fibonacci(n):
   a, b = 0, 1
   for _ in range(n):
       yield a
       a, b = b, a + b
for num in fibonacci(7):
   print(num, end=' ')
# Output: 0 1 1 2 3 5 8

Yeh step kyun?
yield a execution pause karta hai aur a caller ko return karta hai. Jab loop agla value maangti hai, execution yield ke bilkul baad resume hoti hai. a, b = b, a+b yields ke beech state update karta hai. Yeh stateful iteration hai bina saare Fibonacci numbers store kiye.

Worked example Generators ko chain karna (pipeline pattern)

Task: Numbers ko square karo, evens filter karo, pehle 3 lo.

def squares(n):
   for x in range(n):
       yield x**2
def evens(iterable):
   for item in iterable:
       if item % 2 == 0:
           yield item
result = list(evens(squares(10)))[:3]
# Result: [0, 4, 16]

Yeh step kyun?
squares(10) ek generator hai jo 0,1,4,9,... yield karta hai. evens(...) usse wrap karta hai, sirf even values yield karta hai. Koi intermediate list nahi banti—values pipeline se lazily flow karti hain. [:3] lena iteration jaldi rok deta hai (sirf 16 tak compute karta hai).

Comprehensions vs. generators

Feature	List comprehension `[...]`	Generator expression `(...)`
Memory	Saare items store karta hai	Sirf iterator state store karta hai
Speed (first access)	Slower (sab compute karta hai)	Faster (ek compute karta hai)
Speed (full iteration)	Faster (data cache mein)	Thoda slower (re-compute)
Reusability	Kai baar iterate kar sakte hain	Sirf ek baar iterate
Use case	Small datasets, multiple passes	Large datasets, single pass

Kab kya use karein, derivation:

Maano $T_{c}$ = ek item compute karne ka time, $n$ = items ki sankhya, $k$ = collection par iterations ki sankhya.

List: Cost = $n \cdot T_{c}$ (upfront) + $O (1)$ per access × $k$ passes → $(n \cdot T_{c} + n \cdot k)$
Generator: Cost = $T_{c}$ per access × $n$ items × $k$ passes → $(n \cdot T_{c} \cdot k)$

Agar $k = 1$ , generator jeet jaata hai ( $k$ ka factor chhota). Agar $k > 1$ aur $n$ chhota hai, list jeet jaati hai (recomputation bachao).

Common mistake

[] use karna jab memory tight ho Galat soch: "Main bas list bana lunga—yeh aasaan hai."

Kyun sahi lagta hai: Comprehensions readable aur familiar hain. Lists kai baar index aur iterate karne deti hain.

Fix: Agar dataset bada hai aur sirf ek pass chahiye, generator expression use karo. Example:

# BAD: loads 10 million records into memory
data = [process(line) for line in open('huge.csv')]
# GOOD: streams one record at a time
data = (process(line) for line in open('huge.csv'))
for record in data:
   train_model(record)  # process and discard

Steel-man: List version len(data) ya directly data[100] access karne deta hai. Lekin agar tumhe woh nahi chahiye, tum unused features ke liye memory cost pay kar rahe ho.

Common mistake Comprehension se iterate karte waqt list modify karna

Galat soch: [x for x in my_list if not my_list.remove(x)]

Kyun sahi lagta hai: "Main comprehension ke andar side effect se filter kar lunga."

Fix: Comprehensions pure expressions hone chahiye. Iteration ke dauran items remove karna elements skip kara deta hai (iterator invalidation). Sahi tarika:

# Create a new filtered list
my_list = [x for x in my_list if condition(x)]

Ya explicitly mutate karo:

my_list[:] = [x for x in my_list if condition(x)]  # in-place replacement

Recall Ek 12-saal ke bachche ko explain karo

Socho tumhare paas ek toy factory hai. Ek list comprehension aise hai jaise pehle saare toys banao, phir shelf par rakh do. Tum koi bhi toy kabhi bhi le sakte ho, lekin tumhe ek badi shelf chahiye.

Ek generator aise hai jaise tumhare paas ek magic box ho. Jab tum poochho "mujhe ek toy do," woh tab wahi ek toy banata hai aur tumhe deta hai. Agar aur chahiye, tum phir poochho aur woh agla banata hai. Box chhota hai, lekin tum peeche nahi ja sakte—ek baar toy lene ke baad, woh box se chala gaya.

Dict comprehension aise hai jaise phone book banana: tum names (keys) aur phone numbers (values) ek hi step mein pair kar lete ho, ek ek likhne ki jagah.

10 toys wale homework problems ke liye, sab bana lo (list). Santa ki workshop ke liye jo ek billion toys bana rahi hai, magic box use karo (generator)—ek billion toys shelf par kabhi fit nahi honge!

Connections

1.4.01-Basic-Python-syntaxand-data-structures — comprehensions lists, dicts, sets par build karte hain
1.4.02-NumPy-arrays-and-vectorization — NumPy ka apna "vectorized" iteration hai (broadcasting) jo numeric data ke liye comprehensions se faster hai
1.4.04-File-IO-and-data-loading — large CSV/JSON files stream karne ke liye generators crucial hain
1.5.01-Batch-processing-and-mini-batches — ML data loaders generators use karte hain batches lazily yield karne ke liye
2.3.02-Iterator-protocol — generators under the hood iterator protocol implement karte hain

#flashcards/ai-ml

List comprehension kya hai? :: Ek syntactic construct [expr for item in iterable if condition] jo har item par expression apply karke list banata hai, optionally filtering ke saath. Explicit for-loop-append patterns ko ek declarative one-liner se replace karta hai.

Generator kya hai?

Ek function jo yield use karta hai ya ek expression (expr for ...) jo values lazily produce karta hai (ek ek karke, on demand) memory mein saari values store karne ki jagah. Sequence ki length chahe kuch bhi ho, O(1) memory use karta hai.

List comprehension ki jagah generator kyun use karein?

Jab large datasets ke saath kaam karo aur sirf ek pass chahiye—generators constant memory use karte hain (sirf iterator state) saare items ke liye space allocate karne ki jagah. Tradeoff: generator ko reuse ya index nahi kar sakte.

Generator function mein yield kya karta hai?

Execution pause karta hai, caller ko ek value return karta hai, aur function ki state save karta hai. Jab agla value request hota hai, execution yield ke bilkul baad resume hoti hai. Saare results store kiye bina stateful iteration enable karta hai.

[x**2 for x in range(10**9)] ki memory cost kya hai?

Approximately 4-8 GB (1 billion integers × ~28 bytes per Python int object). Ek generator (x**2 for x in range(10**9)) ~200 bytes cost karta hai (sirf iterator overhead).

Comprehension se nested list ko flatten kaise karte hain?

[item for row in matrix for item in row]. Left-to-right nested loops ki tarah padho: outer for row in matrix, phir inner for item in row. Har item result mein append hota hai.

Kya generator ko kai baar iterate kar sakte hain?

Nahi. Generators ek iteration ke baad consumed ho jaate hain. list(gen) do baar call karne par pehli baar values milti hain, phir doosri baar empty list milti hai (generator exhausted ho jaata hai).

List comprehension generator se faster kab hoti hai?

Jab tumhe data par multiple passes chahiye aur dataset memory mein fit ho jaaye. List computation cost ek baar upfront pay karta hai; generator har access par recompute karta hai.

n

items par

k

passes ke liye, list cost

n \cdot T_{c} + n \cdot k

hai vs generator

n \cdot T_{c} \cdot k

Dict comprehension ka syntax kya hai?

{key_expr: value_expr for item in iterable if condition}. Example: {x: x**2 for x in range(5)} produce karta hai {0:0, 1:1, 2:4, 3:9, 4:16}.

Figure — List - dict comprehensions and generators