iterator, generator আর yield — একটি একটি করে মান

১ · for লুপের ভেতরের কথোপকথন — iterable আর iterator

পর্ব ১২ থেকে আপনি for লুপ লিখছেন — list-এর ওপর, string-এর ওপর, range-এর ওপর, ফাইলের লাইনের ওপর। কখনো ভেবেছেন, একই for এত ভিন্ন জিনিসের সাথে কীভাবে কাজ করে? list মেমরিতে সাজানো থাকে, কিন্তু ফাইলের লাইন থাকে ডিস্কে, আর range-এর সংখ্যাগুলো কোথাও জমানোই থাকে না। তবু লুপ একই রকম দেখতে।

রহস্যটা হলো, for লুপ নিজে কিছুই জানে না সে কিসের ওপর চলছে। সে শুধু একটি ছোট চুক্তি মানে, যার নাম iterator protocol. চুক্তিতে মাত্র দুটি প্রশ্ন:

1. শুরুতে একবার: “আমাকে একটি iterator দিন।” — এটাই iter(obj).
2. তারপর বারবার: “পরের জিনিসটা দিন।” — এটাই next(it). জিনিস ফুরালে উত্তর আসে একটি বিশেষ exception দিয়ে: StopIteration. for লুপ সেটা ধরে চুপচাপ থেমে যায়।

এই ছবিটা মাথায় রাখলে এই পর্বের প্রায় সব কিছু সহজ হয়ে যায়। দুটির পার্থক্য এক টেবিলে:

একটি সূক্ষ্ম কিন্তু জরুরি কথা: প্রতিটি iterator নিজেও একটি iterable, কারণ তার __iter__ নিজেকেই ফেরত দেয়। এজন্যই for x in some_iterator লেখা যায়। কিন্তু উল্টোটা সত্যি নয় — list একটি iterable, iterator নয়। list-এর ওপর সরাসরি next() ডাকলে TypeError: 'list' object is not an iterator.

২ · iter(), next() আর StopIteration — for লুপ খুলে দেখা

চুক্তিটা হাতে-কলমে দেখা যাক। for x in [10, 20]: print(x) — এই দুই লাইনের লুপ Python ভেতরে মোটামুটি নিচের while লুপের মতো চালায়। ধাপে ধাপে চালিয়ে দেখুন, বুকমার্ক কীভাবে এগোয় আর লুপ কখন জানতে পারে যে শেষ:

1it = iter([10, 20])      # বুকমার্ক নাও2while True:3    try:4        x = next(it)     # পরেরটা দাও5    except StopIteration:6        break            # শেষ — লুপ থামাও7    print(x)             # লুপের body

REPL-এ নিজে এই কথোপকথন চালাতে পারেন:

>>> it = iter("হাই")
>>> next(it), next(it)
('হ', 'া')
>>> next(it)
'ই'
>>> next(it)
Traceback (most recent call last):
  ...
StopIteration
>>> next(it, "শেষ")     # দ্বিতীয় argument = শেষ হলে এটা দাও
'শেষ'

দুটি জিনিস খেয়াল করুন। প্রথমত, string-এর iterator একটি একটি Unicode code point দেয় — তাই “হাই”-এর “া” কারটি আলাদা হয়ে এসেছে (পর্ব ০৯). দ্বিতীয়ত, next(it, default): শেষে পৌঁছালে exception না দিয়ে default মানটি দেয়। “প্রথম যে জিনিসটা শর্ত মানে, না পেলে None” — এই কাজের জন্য এটা খুব কাজের: next((m for m in marks if m < 33), None).

৩ · iterator একবারই হাঁটা যায় — “দ্বিতীয় লুপে কিছুই নেই” বাগ

বুকমার্কের উপমার সবচেয়ে বড় শিক্ষা এখানে। বুকমার্ক শেষ পাতায় পৌঁছালে সেখানেই থেকে যায়। একে বলে iterator-এর exhaustion — ফুরিয়ে যাওয়া। list-এর ওপর আপনি যতবার খুশি লুপ চালাতে পারেন, কারণ প্রতিবার for লুপ iter(list) ডেকে একটি নতুন বুকমার্ক নেয়। কিন্তু একটি iterator-এর ওপর iter() ডাকলে সে নতুন কিছু বানায় না — নিজেকেই ফেরত দেয়, সেই পুরোনো ফুরানো বুকমার্ক। ফল: দ্বিতীয় লুপ সাথে সাথে StopIteration পায়, একবারও ঘোরে না, আর কোনো error-ও দেখায় না।

এই বাগ বাস্তবে খুব প্রচলিত, কারণ চোখে দেখে বোঝা যায় না কোনটি list আর কোনটি iterator. ধাপে ধাপে দেখুন:

1sales = (int(s) for s in ["500", "300"])2print("মোট:", sum(sales))3for s in sales:4    print("বিক্রি:", s)5sales = [int(s) for s in ["500", "300"]]  # সমাধান

কারা iterator ফেরত দেয়?

Python 3-এ অনেক পরিচিত built-in ফাংশন list নয়, iterator ফেরত দেয় — ঠিক এই কারণে যে বড় ডেটায় পুরো list বানানো অপচয়। তাই এদের ফল একবারই হাঁটা যায়:

৪ · নিজের iterator class — একটি লঞ্চ Countdown

চুক্তিটা যেহেতু শুধু দুটি dunder method, তাই নিজের class-কেও iterator বানানো যায়। ধরুন একটি অ্যাপে নতুন অফার চালুর আগে “৩… ২… ১…” কাউন্টডাউন দেখাতে হবে। চাই এমন একটি object, যার ওপর সরাসরি for লুপ চালানো যায়:

• __iter__(self) — “বুকমার্ক দাও”. iterator নিজেই বুকমার্ক, তাই শুধু return self.
• __next__(self) — “পরেরটা দাও”. অবস্থা (self.current) এক ধাপ এগিয়ে মান ফেরত দেয়; দেওয়ার কিছু না থাকলে raise StopIteration.

নিচের কোডে প্রথমে list-এর ওপর হাতে next() চালানো, তারপর Countdown class, তারপর exhaustion-এর প্রমাণ — সব একসাথে:

nums = [10, 20]
it = iter(nums)
print(next(it), next(it))
print(next(it, "শেষ"))

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

launch = Countdown(3)
print(list(launch), "উড়ল!")
print(list(launch))
pairs = zip("ab", [1, 2])
print(list(pairs), list(pairs))
print(iter(nums) is iter(nums), iter(it) is it)

বারবার চালানো যায় এমন Countdown

উপরের Countdown একবার ব্যবহারেই শেষ। যদি চান c = Countdown(3)-এর ওপর যতবার খুশি লুপ চালানো যাক, তাহলে বই আর বুকমার্ক আলাদা করুন: class-টি হবে শুধু iterable, যার __iter__ প্রতিবার একটি নতুন iterator ফেরত দেয়, আর __next__ থাকবেই না। সেই নতুন iterator বানানোর সবচেয়ে সহজ উপায় হলো পরের অংশের generator:

class Countdown:
    def __init__(self, start):
        self.start = start
    def __iter__(self):                 # প্রতিবার নতুন generator
        for n in range(self.start, 0, -1):
            yield n

c = Countdown(3)
print(list(c), list(c))   # [3, 2, 1] [3, 2, 1]

list, dict, str — Python-এর নিজের সংগ্রহগুলো ঠিক এভাবে কাজ করে: এরা বই, প্রতিটি লুপ নিজের বুকমার্ক পায়। নিয়মটি মনে রাখুন: সংগ্রহ (container) হবে iterable; iterator হবে আলাদা, ক্ষণস্থায়ী object.

৫ · generator — yield দিয়ে থেমে থেমে চলা ফাংশন

প্রথম Countdown class লিখতে আমাদের লেগেছে ১০ লাইন, একটি __init__, অবস্থা রাখার জন্য self.current, আর হাতে raise StopIteration. প্রতিটি নতুন ধরনের ধারার জন্য এত কিছু লেখা ক্লান্তিকর, আর ভুলের সুযোগও বেশি (শেষ মানটি একবার বেশি বা কম দেওয়া — পর্ব ১২-এর off-by-one). Python এর একটি অনেক সহজ উপায় দেয়: generator function.

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

for x in countdown(3):
    print(x)          # 3, 2, 1

দেখতে সাধারণ ফাংশন, শুধু return-এর জায়গায় yield. কিন্তু এই একটি শব্দ ফাংশনের আচরণ পুরোপুরি বদলে দেয়:

• ডাকলে body চলে না। countdown(3) লিখলে ভেতরের একটি লাইনও চলে না। ফেরত আসে একটি generator object — একটি iterator, যার __iter__ আর __next__ Python নিজে বানিয়ে দিয়েছে।
• প্রতিটি next() পরের yield পর্যন্ত চালায়। yield n-এ পৌঁছে generator মানটি দেয় আর থেমে যায় — শেষ হয় না। সব local variable (n), এমনকি কোন লাইনে থেমেছে সেটাও, জমা থাকে।
• ফাংশন শেষ হলে StopIteration. body-র শেষে পৌঁছালে (বা return চললে) Python নিজেই StopIteration দেয়। আপনাকে হাতে raise করতে হয় না।

এই “থামা আর আবার চলা”-ই generator-এর জাদু। একটি print যোগ করে ধাপে ধাপে দেখুন, কোন লাইন কখন চলে:

1def countdown(n):2    print("শুরু")3    while n > 0:4        yield n          # থামো, মান দাও5        n -= 1           # এখান থেকে আবার6    print("শেষ")7g = countdown(2)8next(g)                  # কয়েকবার ডাকা

return, yield আর generator object

একটি ফাংশনের ভেতরে কোথাও একটি yield থাকলেই — এমনকি এমন জায়গায়, যা কখনো চলে না — পুরো ফাংশনটি generator function হয়ে যায়। Python এটা ঠিক করে ফাংশন compile করার সময়ই, চলার সময় নয়। generator-এর ভেতরে return লেখা যায়; সেটা শুধু generator শেষ করে (আর ফেরত মানটি StopIteration-এর ভেতরে লুকানো থাকে, যা পরে yield from কাজে লাগায়)। কিন্তু for লুপ বা list() সেই return মান দেখতে পায় না।

৬ · মেমরির হিসাব — list বনাম generator

generator শুধু কম লাইনের সুবিধা নয়। এর আসল শক্তি মেমরিতে। একটি list তার সব জিনিস একসাথে মেমরিতে রাখে। generator একসাথে রাখে শুধু নিজের ছোট frame — জিনিস যতই হোক।

• range(10**9): একশো কোটি সংখ্যার range object-এর আকার মাত্র কয়েক ডজন বাইট, কারণ সে শুধু start, stop আর step মনে রাখে। list(range(10**9)) লিখলে প্রতিটি সংখ্যার জন্য list-এ একটি reference আর একটি int object লাগবে — সাধারণ ল্যাপটপের মেমরিতে আঁটবেই না, প্রোগ্রাম MemoryError দেবে বা কম্পিউটার জমে যাবে।
• বিশাল লগ ফাইল: একটি পেমেন্ট সার্ভারের ১০ GB-র লেনদেন-লগ। f.readlines() পুরো ফাইল একবারে list-এ তোলে — ৮ GB RAM-এর মেশিনে অসম্ভব। কিন্তু for line in f: ফাইল object-কে iterator হিসেবে ব্যবহার করে, একসাথে মেমরিতে থাকে প্রায় একটি লাইন (আর ছোট একটি buffer). ১০ GB হোক বা ১০০ GB, মেমরি একই।
• প্রথম উত্তর দ্রুত: list আগে পুরোটা বানায়, তারপর প্রথম জিনিস দেয়। generator প্রথম জিনিস সাথে সাথে দেয়। ১০ লাখ রেকর্ডের মধ্যে প্রথম সন্দেহজনক লেনদেন খুঁজতে generator ৫০তম রেকর্ডেই থেমে যেতে পারে — বাকিগুলো কখনো পড়াই হয় না।

এটাই পর্ব ১৮-এ দেখা lazy evaluation. তাহলে কি সবসময় generator? না। generator-এর সীমাবদ্ধতাগুলোও জানুন — একবারই হাঁটা যায়, len() নেই, g[5] নেই, আর ছাপালে শুধু <generator object ...> দেখায়। সিদ্ধান্তের একটি সহজ নিয়ম:

৭ · generator pipeline, yield from আর অসীম generator

generator-এর সবচেয়ে সুন্দর ব্যবহার হলো কয়েকটিকে জুড়ে একটি pipeline বানানো। প্রতিটি ধাপ একটি generator, যে আগের ধাপ থেকে একটি করে জিনিস নেয় আর পরের ধাপকে একটি করে জিনিস দেয়। Linux-এর terminal-এ যাঁরা cat sales.log | grep bKash | wc -l লিখেছেন, তাঁরা ধারণাটি চেনেন — | চিহ্ন (pipe) এক প্রোগ্রামের আউটপুট আরেকটির ইনপুটে জোড়ে।

একটি বাস্তব কাজ: দোকানের বিক্রির লগ থেকে শুধু bKash লেনদেনের মোট টাকা। তিনটি ধাপ — লাইন পড়া, bKash-গুলো ছাঁকা, টাকার অঙ্ক বের করা — তারপর sum:

def read_lines(path):
    with open(path, encoding="utf-8") as f:
        for line in f:
            yield line.strip()

def only_bkash(lines):
    for ln in lines:
        if ln.startswith("bKash,"):
            yield ln

def amounts(lines):
    for ln in lines:
        yield int(ln.split(",")[1])

total = sum(amounts(only_bkash(read_lines("sales.log"))))

শেষ লাইনে কোনো কাজই হয় না, যতক্ষণ না sum প্রথম মান চায়। তারপর টানটা শেষ থেকে শুরুর দিকে চলে। ছোট একটি লগ দিয়ে ধাপে ধাপে দেখুন — একসাথে মেমরিতে কতগুলো লাইন থাকে:

yield from — কাজ অন্য generator-কে দিয়ে দেওয়া

কখনো একটি generator-কে আরেকটি iterable-এর সব মান হুবহু পার করে দিতে হয়। ধরুন একটি দোকানের দুটি শাখার লগ পরপর পড়বেন। লেখা যায় for x in sub: yield x, কিন্তু Python 3.3 থেকে (PEP 380) এর সংক্ষিপ্ত ও শক্তিশালী রূপ আছে — yield from:

def all_branches(paths):
    for p in paths:
        yield from read_lines(p)     # এই শাখার সব লাইন, তারপর পরের শাখা

def flatten(items):                  # যেকোনো গভীরতার nested list
    for x in items:
        if isinstance(x, list):
            yield from flatten(x)    # recursion
        else:
            yield x

print(list(flatten([1, [2, [3, 4]], 5])))   # [1, 2, 3, 4, 5]

yield from শুধু লেখা ছোট করে না। ভেতরের generator return দিয়ে যে মান দেয়, result = yield from sub() লিখলে সেটা result-এ আসে; আর পরের অংশের send() ও close()-ও সরাসরি ভেতরের generator-এ পৌঁছে যায়। সাধারণ for-yield লুপে এগুলো হাতে লিখতে হতো।

অসীম generator আর islice

generator একটি একটি মান দেয় বলে সে চিরকাল চলতে পারে — যতক্ষণ কেউ টানছে। ইনভয়েস নম্বর (INV-1001, INV-1002, …), অর্ডার ID, Fibonacci সংখ্যা — এগুলোর “শেষ” নেই। কিন্তু অসীম generator-এর ওপর সরাসরি list() বা for চালালে প্রোগ্রাম কখনো থামবে না (infinite loop). তাই দরকারমতো কয়েকটি কেটে নিতে হয়। এর জন্য standard library-র itertools module-এ আছে islice — iterator-এর slicing: islice(gen, 5) প্রথম ৫টি দিয়ে থামে, বাকিগুলো কখনো তৈরিই হয় না।

নিচের কোডে তিনটি বাস্তব কাজ: অসীম ইনভয়েস-নম্বর generator থেকে প্রথম তিনটি; bKash লেনদেনের যোগফল, যেখানে ভাঙা লাইন (abc) নিঃশব্দে বাদ যায়; আর ২৩টি রেকর্ডকে ১০টি করে পাতায় ভাগ করা (chunk বা pagination):

from itertools import count, islice

def invoice_numbers(start=1001):
    for n in count(start):            # count: 1001, 1002, ... অসীম
        yield f"INV-{n}"
def amounts(lines):
    for ln in lines:
        if (amt := ln.split(",")[1]).isdigit():
            yield int(amt)
def chunks(items, size):
    it = iter(items)
    while batch := list(islice(it, size)):
        yield batch

log = ["bKash,500", "Nagad,300", "bKash,1200", "card,700", "bKash,abc"]
bkash = (row for row in log if row.startswith("bKash,"))
print(list(islice(invoice_numbers(), 3)))
print("bKash মোট:", sum(amounts(bkash)))
for page in chunks(range(1, 24), 10):
    print(len(page), page[0], "...", page[-1])

একই কৌশলে অসীম Fibonacci: def fib(): a, b = 0, 1; while True: yield a; a, b = b, a + b (আলাদা লাইনে লিখে), তারপর list(islice(fib(), 10)). Python 3.12 থেকে pagination-এর জন্য তৈরি itertools.batched(items, 10)-ও আছে, যা tuple দেয়। count, islice, chain, groupby সহ itertools-এর পুরো ভ্রমণ পর্ব ৩৮-এ।

৮ · আরও গভীরে — send, close আর PEP 479

send() আর close() — দুই দিকের কথা

এতক্ষণ generator শুধু মান দিয়েছে। কিন্তু yield আসলে একটি expression — এর নিজেরও একটি মান আছে। g.send(value) ডাকলে generator থেমে থাকা yield থেকে আবার চলে, আর সেই yield-এর মান হয় value. অর্থাৎ বাইরে থেকে generator-এর ভেতরে তথ্য পাঠানো যায়:

def running_average():
    total, count, avg = 0, 0, None
    while True:
        x = yield avg            # avg দাও, তারপর পরের x-এর অপেক্ষা
        total, count = total + x, count + 1
        avg = total / count

avg = running_average()
next(avg)                        # প্রথম yield পর্যন্ত চালু করা
print(avg.send(10), avg.send(20))   # 10.0 15.0
avg.close()                      # ভেতরে GeneratorExit, generator শেষ

যে generator এভাবে বাইরে থেকে মান গ্রহণ করে, তাকে বলে generator-ভিত্তিক coroutine. শুরুতে একবার next() (বা send(None)) দিয়ে প্রথম yield পর্যন্ত নিয়ে যেতে হয় — নইলে TypeError. close() থেমে থাকা yield-এর জায়গায় GeneratorExit exception তোলে; ভেতরে try/finally বা with থাকলে পরিষ্কারের কাজ (যেমন ফাইল বন্ধ) তখন চলে। একটি generator-কে মাঝপথে ছেড়ে দিলে garbage collector-ও শেষে এটাই করে।

এই ধারণা থেকেই আধুনিক Python-এর async/await জন্মেছে (ভাবনার প্রশ্ন ৫)। আজ নতুন কোডে send-ভিত্তিক coroutine খুব কম লেখা হয় — একসাথে অনেক কাজের জন্য asyncio আছে, যা পর্ব ৪২-এ দেখবেন। এখানে শুধু জেনে রাখুন যে generator দুই দিকে কথা বলতে পারে।

generator-এর ভেতরে StopIteration — এখন RuntimeError

একটি সূক্ষ্ম ফাঁদ। generator-এর ভেতরে আপনি অন্য কোনো iterator-এ next() ডাকলেন, আর সেটা ফুরিয়ে StopIteration দিল। আগে এই StopIteration generator থেকে বেরিয়ে বাইরের for লুপকে বলত “আমি শেষ” — ফলে ডেটা মাঝপথে কাটা পড়ত, কোনো error ছাড়াই। Python 3.7 থেকে (PEP 479) generator-এর body থেকে বেরিয়ে আসা StopIteration স্বয়ংক্রিয়ভাবে RuntimeError: generator raised StopIteration-এ বদলে যায়। নিঃশব্দ বাগের বদলে এখন জোরালো error.

generator expression — পর্ব ১৮-এর পুনরালোচনা

(x * x for x in nums) হলো generator function-এর এক লাইনের সংক্ষিপ্ত রূপ — ভেতরে এটা ঠিক একটি for-yield লুপওয়ালা লুকানো generator. একটি ছাঁকনি বা রূপান্তরে genexp যথেষ্ট; একাধিক ধাপ, try/except, অবস্থা মনে রাখা (যেমন আগের লাইন) বা yield from লাগলে generator function লিখুন। দুটিই একই iterator protocol মানে, তাই একই pipeline-এ মিশিয়ে ব্যবহার করা যায় — উপরের চালানো কোডে ঠিক তাই হয়েছে।

৯ · AI-এর যুগে — AI-এর লেখা iterator-কোড যাচাই

AI কোড-সহকারীরা ছোট উদাহরণে প্রায় নিখুঁত কোড দেয়, কারণ ছোট ডেটায় list আর generator-এর পার্থক্য চোখে পড়ে না। সমস্যা দেখা দেয় আসল ডেটায় — ১০ GB লগ, ১০ লাখ রেকর্ড, বা একই iterator দুই জায়গায়। AI-এর লেখা কোডে বারবার যেসব ভুল দেখা যায়:

AI-এর লেখা iterator/generator কোড পেলে — যাচাইয়ের চেকলিস্ট

• ডেটা কত বড় হতে পারে ভেবেছি; বড় হলে কোথাও পুরো ডেটা list-এ উঠছে কি না (readlines, list(...), append-লুপ) খুঁজেছি
• প্রতিটি zip, map, filter, generator কতবার হাঁটা হচ্ছে গুনেছি — একবারের বেশি হলে list বা নতুন generator
• generator-এ len(), index বা print(gen) দিয়ে “দেখা” নেই তা নিশ্চিত করেছি
• generator-এর ভেতরে raise StopIteration নেই, আর except StopIteration শুধু একটি next()-কে ঘিরে আছে
• অসীম generator থাকলে তার ভোক্তা islice, break বা অন্য কোনো সীমা দিয়ে থামে কি না দেখেছি; খালি ইনপুট দিয়ে একবার চালিয়েছি