List comprehension ও iterator

এই বিতর্ক Python community-তে চিরন্তন। সঠিক উত্তর: "depends" — কিন্তু কখন কোনটা — এর সঠিক বোঝা ভাল kod ও অস্পষ্ট কোডের মধ্যে পার্থক্য।

Comprehension-এর performance:

• ~২০-৩০% দ্রুত explicit loop-এর চেয়ে।
• কারণ — bytecode-level optimization, append() call এড়ানো।
• NumPy vectorize-এর তুলনায় তুচ্ছ — ১০০× ধীর।

Comprehension কখন বাছবেন:

• Simple transform: [x*2 for x in lst] — clear।
• Filter + transform: [f(x) for x in lst if cond(x)] — concise।
• Dict/set creation: {k: v for k, v in pairs}
• One-line, simple expression।

Loop কখন বাছবেন:

• Side effect (print, log, db write) — comprehension এ বেমানান।
• Multiple statements — comprehension একটি expression।
• Try/except — loop ছাড়া উপায় নেই।
• Multiple output — দুটি list একসাথে তৈরি — loop সহজ।
• ৩+ nested loop — comprehension অপাঠ্য।

উদাহরণ — কী খারাপ comprehension:

# খারাপ
result = [
    [transform(x, y) for y in row if validate(y)]
    for row in matrix if any(check(y) for y in row)
]
# কয়েক sec বুঝতে যায় — loop-এ পরিষ্কার হত

"Side effect-এ comprehension" anti-pattern:

# খুব খারাপ
[print(x) for x in data]    # list তৈরির অপচয়, print-এর জন্য

# ভাল
for x in data:
    print(x)

NumPy/Pandas-এর সাথে priorities:

• Numerical data → NumPy/Pandas vectorize, comprehension না।
• Mixed type / Python objects → comprehension।
• Dict construction → dict comprehension সবচেয়ে ভাল।

"Walrus" (Python 3.8+):

# যদি repeated computation এড়াতে চান
result = [y for x in data if (y := f(x)) > 0]
# y শুধু একবার compute

Readability heuristic:

• One-line line ৭০-৮০ char-এর কম → comprehension OK।
• Nested ২ level → debatable।
• Nested ৩ level → ভুল।
• আপনি ৬ মাস পরে নিজে পড়লে বুঝবেন? — yes → keep।

মূল উপলব্ধি: Comprehension = transform-এর syntactic sugar, না magic। সঠিক জায়গায় — elegant। অপব্যবহারে — illegible। "Readability counts" (Zen of Python)। সন্দেহ থাকলে — explicit loop।

Generator — Python 2.2 (২০০১)-এ PEP 255-এ আসে। এটি functional programming-এর "lazy evaluation" idiom Python-এ আনে। আজকের AI data infra এর উপর দাঁড়িয়ে।

Lazy evaluation কী?

• Eager: সব value এখনই compute, memory-তে।
• Lazy: চাইলে এক-একটা দেয়, না চাইলে কিছু না।
• Generator = Python-এর lazy stream।

Memory analysis:

# ১০ কোটি sample
import sys

list_data = [i for i in range(10**8)]    # ~৮ GB RAM!

gen_data = (i for i in range(10**8))     # ~২০০ bytes
# স্মৃতি save: ৪ কোটি গুণ

Pipeline composition — Unix pipe-এর মতো:

def read_lines(path):
    with open(path) as f:
        for line in f:
            yield line.strip()

def parse(lines):
    for line in lines:
        yield json.loads(line)

def filter_active(records):
    for r in records:
        if r["active"]:
            yield r

# Pipeline — কোন ধাপেই memory-তে full data নেই
pipeline = filter_active(parse(read_lines("huge.jsonl")))
for record in pipeline:
    process(record)

Infinite sequence:

def counter():
    i = 0
    while True:
        yield i
        i += 1

c = counter()
for n in c:
    if n > 5: break
    print(n)
# 0 1 2 3 4 5

AI/ML-এ critical applications:

• PyTorch DataLoader: internal-এ iterator। Disk → batch তৈরি করে stream।
• TensorFlow tf.data: generator-based pipeline।
• HuggingFace datasets: streaming mode — terabyte ডেটা-ও memory-তে আনে না।
• Image augmentation: on-the-fly transform — pre-compute না।
• Tokenization: stream tokens through layers।
• Sliding window: sequence model-এ context window।

Generator-এর advanced features:

• send(): generator-এ value পাঠানো — coroutine-এর প্রাচীন রূপ।
• throw(): exception inject।
• yield from: sub-generator-এ delegate।
• async generator (3.6+): await + yield।

itertools — generator-এর ভাণ্ডার:

• chain, cycle, repeat — combine।
• islice, takewhile, dropwhile — slice।
• product, permutations, combinations — combinatorics।
• groupby, tee — group ও duplicate।

সাবধানতা:

• Single-pass — exhaustion-এর পর reset লাগে।
• len() নেই — explicit count।
• Index access নেই — only sequential।
• Debug কঠিন — print স্থায়ী state বদলায়।

মূল উপলব্ধি: Generator = Python-এর scaling secret। ছোট লেনদেন list, বিশাল data generator। AI-তে — ১ TB log file process? Generator without thinking। DataLoader internals মাস্টার করতে — generator অপরিহার্য।

Iterator protocol — Python-এর data model-এর foundation। এটা না বুঝলে — Python কীভাবে কাজ করে — অস্পষ্ট থাকবে।

Iterator protocol:

• __iter__() — iterator object ফেরত।
• __next__() — পরবর্তী value, না থাকলে StopIteration raise।

For loop ভেতরে যা করে:

# আপনি লিখলেন
for x in collection:
    use(x)

# Python ভেতরে
it = iter(collection)        # __iter__()
while True:
    try:
        x = next(it)         # __next__()
    except StopIteration:
        break
    use(x)

Iterable vs Iterator:

• Iterable: __iter__ আছে — list, tuple, dict, str, file।
• Iterator: __next__ আছে — iter()-এর result।
• Iterator নিজেও iterable (__iter__ ফেরায় self)।

Custom iterator class:

class CountDown:
    def __init__(self, start):
        self.current = start

    def __iter__(self):
        return self

    def __next__(self):
        if self.current <= 0:
            raise StopIteration
        self.current -= 1
        return self.current + 1

for n in CountDown(5):
    print(n)        # 5 4 3 2 1

সাধারণত generator function সহজ:

def countdown(start):
    while start > 0:
        yield start
        start -= 1

for n in countdown(5):
    print(n)

কখন class বাছবেন?

• State management complex।
• Multiple methods দরকার (reset, peek, etc.)।
• Inheritance ও extensibility।
• Type checking — isinstance(x, MyIterator)।

AI-তে এই pattern:

• PyTorch Dataset + DataLoader:

  class MyDataset(Dataset):
      def __getitem__(self, idx): ...
      def __len__(self): ...
  
  # DataLoader auto-creates iterator wrapping this

• Streaming HuggingFace dataset: internal iterator।
• Random sampler: custom __iter__ with shuffling।
• Curriculum learning: difficulty-ordered iterator।

Common built-in iterables:

• range, enumerate, zip, map, filter
• open() file — line-by-line iterator।
• dict.keys(), .values(), .items()

iter() with sentinel:

# ফাইল chunked read
with open("big.bin", "rb") as f:
    for chunk in iter(lambda: f.read(4096), b""):
        process(chunk)
# b"" পেলে stop

মূল উপলব্ধি: Iterator protocol = Python-এর "duck typing" of iteration। যেকোনো object যা __iter__+__next__ দেয় — for loop-এ কাজ করে। PyTorch Dataset, NumPy ndarray, Pandas DataFrame — সব এই protocol-এ। বুঝলে — Python ecosystem-এর design গভীরে দেখা যায়।

এই প্রশ্ন AI-র performance-এর হৃদয়ে নিয়ে যায়। List comprehension পrocessor-এর বন্ধু — কিন্তু GPU-র শত্রু।

List comprehension overhead:

• প্রতি iteration — Python interpreter dispatch।
• প্রতি object — type check, reference count।
• প্রতি element — Python heap allocation।
• Memory fragmentation — cache miss।

NumPy vectorization:

• Contiguous C array — cache-friendly।
• SIMD instruction — CPU একসাথে ৪/৮ float।
• BLAS/LAPACK — হাজার মানুষ-বছরের optimization।
• GIL release — multi-thread possible।

Concrete benchmark:

import numpy as np
import time

n = 10_000_000

# Comprehension
data = list(range(n))
t = time.time()
result = [x * 2 for x in data]
print(f"Comp: {time.time()-t:.3f}s")    # ~০.৫s

# NumPy
arr = np.arange(n)
t = time.time()
result = arr * 2
print(f"NumPy: {time.time()-t:.3f}s")   # ~০.০১s

Philosophical পার্থক্য:

• Comprehension: "প্রতিটি element-এর জন্য কী?" — element-thinking।
• Vectorization: "পুরো array-কে কী করব?" — array-thinking।
• Mind shift গুরুত্বপূর্ণ।

Vectorization-এর সীমা:

• Numerical-only — string operations চলে না (NumPy-তে limited)।
• Branching — if per element কঠিন (np.where ব্যবহার)।
• Sequential dependency — RNN-এর hidden state cumulative।
• Mixed type collection — list comprehension।

Vectorization patterns:

# Conditional - np.where
arr_relu = np.where(arr > 0, arr, 0)

# Boolean mask
positives = arr[arr > 0]

# Reduce
mean = arr.mean()

# Outer product
xy = x[:, None] * y[None, :]    # broadcasting

কখন কোনটা:

• Numerical, large data → NumPy/Pandas/PyTorch
• Mixed types, small data, complex logic → comprehension
• Side effects → for loop
• Streaming, infinite → generator

Hybrid approach:

# Step 1: comprehension to clean
clean = [parse(x) for x in raw if valid(x)]

# Step 2: NumPy for math
arr = np.array(clean)
result = (arr - arr.mean()) / arr.std()

GPU-এ আরো দ্রুত:

• PyTorch tensor.cuda() → ১০০০× speedup typical।
• JAX jit compile → XLA optimization।
• Numba @njit → Python loop → C speed।

মূল উপলব্ধি: Comprehension = Python idiom। Vectorization = math idiom। AI = math-heavy → vectorization default। কিন্তু comprehension-ও জানতে হবে — preprocessing, filtering, dict creation এ। দুটি tool — দুটি use case।