লুপ — for, range, enumerate, zip আর while

১ · লুপ কেন — একই কাজ বারবার

আগের পর্বে আপনি প্রোগ্রামকে সিদ্ধান্ত নিতে শিখিয়েছেন — if দিয়ে এই পথ, নইলে ওই পথ। কিন্তু সিদ্ধান্তের কোড একবারই চলে। ভাবুন, একটি স্কুলের ৬০ জন শিক্ষার্থীর নম্বর দেখে প্রত্যেকের ফল লিখতে হবে। একই তিন লাইনের কোড ৬০ বার কপি করবেন? ৬০০ জন হলে? একজন নতুন শিক্ষার্থী ভর্তি হলে আবার কোড বদলাবেন?

এখানেই loop-এর দরকার। লুপ মানে একই কাজ বারবার করানো — কাজটি আপনি একবার লেখেন, কম্পিউটার যতবার দরকার ততবার চালায়। লুপের প্রতিটি ঘোরাকে বলে একটি iteration. কম্পিউটারের আসল শক্তি এখানেই: মানুষ ৬০টি খাতা দেখতে ক্লান্ত হয়, কম্পিউটার ৬০ লাখটি দেখেও ক্লান্ত হয় না।

Python-এ লুপ দুই রকম, আর দুটির ভাবনা আলাদা:

২ · for লুপ — প্রতিটি জিনিসের জন্য একবার

for লুপের গঠন একটি ইংরেজি বাক্যের মতো: for letter in letters: — “letters-এর প্রতিটি letter-এর জন্য”। কোলনের পরের ঢুকিয়ে লেখা (indentation দেওয়া) লাইনগুলো হলো লুপের body — প্রতিটি ঘোরায় এগুলো চলে। আর letter হলো loop variable: প্রতিটি ঘোরার শুরুতে Python সংগ্রহের পরের জিনিসটি এই নামে লাগিয়ে দেয়।

পর্ব ০৫-এর লেবেল-ছবিটি মনে আছে? Loop variable-ও একটি লেবেল। প্রতি ঘোরায় লেবেলটি খুলে পরের object-এর গায়ে লাগানো হয় — কোনো কপি হয় না। নিচের ধাপগুলোতে দেখুন, letter লেবেলটি কীভাবে এক বর্ণ থেকে আরেক বর্ণে সরে যায়, আর লুপ শেষেও কোথায় থেকে যায়:

1letters = ["ক", "খ", "গ"]2for letter in letters:3    print(letter, "পড়লাম")4print("শেষে letter =", letter)

for লুপ শুধু list-এ নয়, যেকোনো iterable-এ চলে — অর্থাৎ এমন যেকোনো object, যার কাছে “জিনিসগুলো একটি একটি করে দাও” বলা যায়। কয়েকটি উদাহরণ:

৩ · range() — সংখ্যার সারি, কিন্তু অলস

কখনো সত্যিই সংখ্যা গুনতে হয় — ১২ মাসের হিসাব, ১ থেকে ১০-এর নামতা। তখন ব্যবহার করুন range. এর তিনটি রূপ:

এবার একটি বাস্তব হিসাব। ধরুন একজন গার্মেন্টস কর্মী প্রতি মাসে ১,৫০০ টাকা সঞ্চয় করবেন। ১২ মাসে কত জমবে, আর প্রতি তিন মাস পরপর অবস্থা কেমন — দেখা যাক:

savings = 1500
total = 0
for month in range(1, 13):        # 1 থেকে 12 — 13 নেই
    total += savings
    if month % 3 == 0:            # প্রতি তিন মাস পরপর
        print(f"মাস {month:2}: মোট {total} টাকা")

মাস  3: মোট 4500 টাকা
মাস  6: মোট 9000 টাকা
মাস  9: মোট 13500 টাকা
মাস 12: মোট 18000 টাকা

লুপের আগে total = 0, ভেতরে total += savings — এই জুটির নাম accumulator প্যাটার্ন: একটি “জমার খাতা” খুলে প্রতি ঘোরায় তাতে কিছু যোগ করা। অংশ ৯-এ দেখবেন, এমন অনেক খাতার কাজ Python-এর built-in নিজেই করে দেয়।

range কেন অলস

range(1, 13) লিখলে মেমরিতে ১২টি সংখ্যার কোনো list তৈরি হয় না। range object শুধু তিনটি জিনিস মনে রাখে — start, stop, step. লুপ যখন পরের সংখ্যা চায়, তখনই সেটি হিসাব করে দেয়। একে বলে lazy আচরণ: দরকারের আগে কোনো কাজ নয়। ফলাফল?

• range(10**12) — এক লাখ কোটি সংখ্যার range — তৈরি হয় চোখের পলকে, আর মেমরি নেয় ছোট্ট এক range-এর সমান।
• তবু এটি একটি পূর্ণ sequence: len(range(1, 13)) দেয় 12, range(1, 13)[0] দেয় 1, আর 100 in range(0, 10**12, 2) গুনে গুনে না দেখেই সঙ্গে সঙ্গে True বলে — কারণ এটি সূত্র দিয়ে হিসাব করে।
• সংখ্যাগুলো সত্যিই list হিসেবে চাইলে list(range(5)) লিখুন — তখন [0, 1, 2, 3, 4] তৈরি হবে।

৪ · enumerate, zip, reversed, sorted — index না গুনেই

C বা অন্য ভাষা থেকে আসা অনেকে (আর অনেক AI-ও) Python-এ এভাবে লেখেন: for i in range(len(names)):, তারপর ভেতরে names[i]. কাজ করে, কিন্তু এটি Python-এর ভাষায় “বিদেশি উচ্চারণ”। প্রায় সব ক্ষেত্রেই এর চেয়ে পরিষ্কার একটি উপায় আছে।

enumerate() — জিনিসের সাথে তার ক্রমিক নম্বর

রোল নম্বরসহ নাম ছাপতে চান? enumerate প্রতিটি জিনিসের সাথে একটি গণনা জুড়ে দেয়: for roll, name in enumerate(names, start=1):. start=1 না দিলে গণনা শুরু হয় 0 থেকে — মানুষের জন্য তালিকা ছাপতে start=1 প্রায় সবসময় ভালো।

zip() — দুটি সারি পাশাপাশি

একটি list-এ নাম, আরেকটিতে নম্বর। দুটিকে জোড়ায় জোড়ায় নিতে zip: for name, mark in zip(names, marks):. নামটা এসেছে জ্যাকেটের চেইন (zipper) থেকে — দুই পাশের দাঁত একটা একটা করে মিলে যায়।

দুটি একসাথে মেলালে কী হয়, ধাপে ধাপে দেখুন। (name, mark)-এর মতো বন্ধনী দিয়ে একটি জোড়াকে দুটি নামে ভাগ করাকে বলে unpacking — পর্ব ১৫-এ বিস্তারিত।

1names = ["রহিম", "সুমি", "করিম"]2marks = [78, 91, 29]3for roll, (name, mark) in enumerate(zip(names, marks), start=1):4    print(roll, name, mark)

reversed() আর sorted()

reversed(names) উল্টো দিক থেকে হাঁটে — নতুন list বানায় না, শুধু পেছন থেকে একটি একটি করে দেয়। sorted(marks) ছোট থেকে বড় সাজানো একটি নতুন list দেয়; মূল list যেমন ছিল তেমনই থাকে। সাজানোর আরও কৌশল (বড় থেকে ছোট, নিজের নিয়মে সাজানো) পর্ব ১৪-এ দেখবেন। এবার সব একসাথে চালিয়ে দেখুন:

names = ["রহিম", "সুমি", "করিম", "নাদিয়া"]
marks = [78, 91, 29, 65]

for roll, (name, mark) in enumerate(zip(names, marks), start=1):
    status = "পাস" if mark >= 33 else "ফেল"
    print(f"{roll}. {name}: {mark} ({status})")

print("মোট নম্বর:", sum(marks))
print("সর্বোচ্চ:", max(marks))
print("সবাই পাস?", all(m >= 33 for m in marks))
print("কেউ ৯০+ পেয়েছে?", any(m >= 90 for m in marks))

extra = ["তানভীর"]          # নম্বর নেই — zip একে বাদ দেবে
print(list(zip(names + extra, marks))[-1])
for name in reversed(names):
    print(name, end=" ")
print()
print(sorted(marks), marks)

৫ · while লুপ — শর্ত যতক্ষণ সত্য

while condition: — প্রতিটি ঘোরার আগে Python শর্তটি দেখে। সত্য হলে body চালায়, তারপর আবার শর্ত দেখে। মিথ্যা হলেই লুপ শেষ। শুরুতেই মিথ্যা হলে body একবারও চলে না।

একটি ছোট উদাহরণ — সংখ্যার অঙ্ক গোনা। কতবার ঘুরবে, তা সংখ্যার ওপর নির্ভর করে; আগে থেকে বলা যায় না:

n = 20261017
digits = 0
while n > 0:
    n //= 10          # শেষ অঙ্কটি ফেলে দাও
    digits += 1
print(digits)         # 8

while-এর একটি অলিখিত চুক্তি আছে: body-র ভেতরে এমন কিছু ঘটতেই হবে, যা একসময় শর্তটিকে মিথ্যা করবে। এখানে n //= 10 সেই কাজ করছে। এই লাইনটি ভুলে গেলে n কখনো ছোট হবে না, আর লুপ চিরকাল ঘুরবে — একে বলে infinite loop. প্রোগ্রাম আটকে গেলে টার্মিনালে Ctrl+C চাপুন; Python KeyboardInterrupt দিয়ে থেমে যাবে।

সেন্টিনেল লুপ — “done” না লেখা পর্যন্ত

একটি দোকানের দিনশেষের হিসাব ভাবুন। দোকানি একটি একটি করে বিক্রির টাকা লিখবেন, শেষ হলে লিখবেন done. কয়টি বিক্রি, কেউ আগে জানে না। এমন একটি বিশেষ “থামার সংকেত”-কে বলে sentinel (পাহারাদার)। Python-এ এর প্রচলিত গঠন হলো while True: দিয়ে চিরকালের লুপ শুরু করা, আর ভেতরে সংকেত পেলেই break দিয়ে বেরিয়ে যাওয়া:

total = 0
count = 0
biggest = 0

while True:
    entry = input()          # আসল প্রোগ্রামে: input("বিক্রি: ")
    if entry == "done":
        break                # সেন্টিনেল পেলেই লুপ শেষ
    if not entry.isdigit():
        print("সংখ্যা নয়, বাদ দিলাম:", entry)
        continue             # বাকি অংশ বাদ, পরের ইনপুটে যাও
    amount = int(entry)
    total += amount
    count += 1
    if amount > biggest:
        biggest = amount

print(f"মোট {count}টি বিক্রি, {total} টাকা")
print(f"সবচেয়ে বড় বিক্রি: {biggest} টাকা")

৬ · break, continue আর লুপের else

দুটি কীওয়ার্ড লুপের স্বাভাবিক চলার পথ বদলায়। দুটিই কাজ করে শুধু সবচেয়ে ভেতরের লুপে:

• break — “এখনই লুপ থেকে বের হও।” বাকি ঘোরাগুলো আর হবে না। খোঁজার কাজে উত্তর পেয়ে গেলে, বা সেন্টিনেল পেলে।
• continue — “এই ঘোরার বাকিটা বাদ, পরের ঘোরায় যাও।” ভুল ইনপুট বা অপ্রাসঙ্গিক জিনিস এড়াতে।

এবার Python-এর একটি বিরল বৈশিষ্ট্য — লুপের else. for বা while-এর পরে else: লিখলে সেই অংশ চলে শুধু তখন, যখন লুপ break ছাড়া স্বাভাবিকভাবে শেষ হয়। এর আসল ব্যবহার খোঁজার কাজে: “খুঁজে পেলে break; পুরো তালিকা দেখেও না পেলে else.” একজন শিক্ষার্থীর ফলাফলে প্রথম যে বিষয়ে ফেল, সেটি খোঁজা যাক — একবার ফেল আছে এমন ফলাফলে, একবার সব পাস এমন ফলাফলে:

1for subject, mark in results:2    if mark < 33:3        print("প্রথম ফেল:", subject)4        break5else:6    print("সব বিষয়ে পাস!")

for/else ছাড়া এই কাজ করতে সাধারণত একটি “পতাকা” ভ্যারিয়েবল লাগে — found = False, খুঁজে পেলে found = True, লুপের পরে if not found:. for/else সেই বাড়তি ভ্যারিয়েবল বাঁচায়। এটি আসলে linear search-এর একটি পরিষ্কার রূপ।

৭ · লুপের ভেতরে লুপ — নামতা আর loop variable-এর ফাঁদ

একটি লুপের body-তে আরেকটি লুপ থাকতে পারে — একে বলে nested loop. বাইরের লুপের প্রতিটি ঘোরায় ভেতরের লুপ পুরোটা ঘোরে। স্কুলের নামতার কথা ভাবুন: ১-এর ঘর, ২-এর ঘর, ৩-এর ঘর (বাইরের লুপ); প্রতিটি ঘরে ১ থেকে ৫ পর্যন্ত গুণ (ভেতরের লুপ)।

for i in range(1, 4):              # বাইরের লুপ: কোন ঘরের নামতা
    for j in range(1, 6):          # ভেতরের লুপ: কত দিয়ে গুণ
        print(f"{i}x{j}={i*j:<2}", end="  ")
    print()                        # এক ঘর শেষ, নতুন লাইন

1x1=1   1x2=2   1x3=3   1x4=4   1x5=5
2x1=2   2x2=4   2x3=6   2x4=8   2x5=10
3x1=3   3x2=6   3x3=9   3x4=12  3x5=15

print()-এর end=" " বলে দেয় — লাইন শেষে নতুন লাইন নয়, দুটি ফাঁকা জায়গা দাও। তাই একটি ঘরের পাঁচটি গুণ এক লাইনে আসে। বাইরের লুপের print() (ভেতরের লুপের বাইরে, কিন্তু বাইরের লুপের ভেতরে — indentation দেখুন) প্রতিটি ঘর শেষে নতুন লাইন দেয়।

মোট কতবার ভেতরের body চলল? ৩ × ৫ = ১৫ বার। এটাই nested loop-এর গুরুত্বপূর্ণ হিসাব: বাইরে n বার, ভেতরে m বার হলে মোট n × m. ১,০০০ শিক্ষার্থীর প্রত্যেককে প্রত্যেকের সাথে তুলনা করলে ১০ লাখ তুলনা — ছোট ডেটায় নিরীহ, বড় ডেটায় প্রোগ্রাম ধীর হয়ে যাওয়ার সবচেয়ে সাধারণ কারণ।

Loop variable লুপের পরেও বেঁচে থাকে

C বা Java-তে লুপের ভেতরে ঘোষণা করা ভ্যারিয়েবল লুপ শেষ হলেই হারিয়ে যায়। Python-এ তা নয়। for i in range(5): শেষ হওয়ার পর i-এর মান 4 — শেষ যে মান পেয়েছিল। প্রথম স্টেপারে letter-এর ক্ষেত্রেও তাই দেখেছেন। এর দুটি ফাঁদ:

• পুরোনো মান ভুল করে ব্যবহার: লুপের পরে একই নাম আবার ব্যবহার করলে আপনি ভাবতে পারেন এটি নতুন, অথচ এতে লুপের শেষ মান রয়ে গেছে। নামতার পরে i আর j-এর মান 3 আর 5.
• খালি লুপে নামই তৈরি হয় না: for x in []: একবারও ঘোরে না, তাই x কখনো তৈরি হয় না। লুপের পরে print(x) লিখলে NameError — কিন্তু শুধু তখনই, যখন তালিকা খালি ছিল। এমন বাগ পরীক্ষায় লুকিয়ে থাকে, আসল ডেটায় ফাটে।

পরামর্শ: loop variable-কে লুপের ভেতরেই ব্যবহার করুন। লুপের পরে কোনো মান লাগলে আলাদা, স্পষ্ট নামের একটি ভ্যারিয়েবলে রাখুন (যেমন last_month). পর্ব ১৮-এর comprehension-এ কিন্তু loop variable বাইরে আসে না — Python 3 থেকে সেখানে নিয়ম আলাদা।

৮ · লুপের তিনটি পরিচিত ভুল

ভুল ১: যে list-এর ওপর লুপ চলছে, তাকেই বদলানো

ধরুন নম্বরের list থেকে ফেল করা (৩৩-এর কম) নম্বরগুলো মুছে দিতে চান। সবচেয়ে স্বাভাবিক মনে হয় এটা: লুপ চালাও, ৩৩-এর কম পেলে remove করো। দেখুন কী ঘটে:

1for m in marks:2    if m < 33:3        marks.remove(m)4print(marks)

Dictionary-র ক্ষেত্রে Python আরও কড়া: লুপ চলার সময় dict-এ নতুন চাবি যোগ বা মোছা করলে সরাসরি RuntimeError আসে (পর্ব ১৬)। List-এ এমন কোনো সতর্কতা নেই — তাই নিয়মটি মনে রাখুন: যার ওপর হাঁটছেন, তার আকার বদলাবেন না।

ভুল ২: off-by-one

অংশ ৩-এ দেখেছেন — stop ভেতরে থাকে না। আরেকটি রূপ হলো for i in range(1, len(names)): — যা প্রথম জিনিসটিই (index 0) বাদ দেয়। “বেড়া আর খুঁটি”-র পুরোনো ধাঁধাও এই পরিবারের: ১০ মিটার বেড়ায় ১ মিটার পরপর খুঁটি দিলে খুঁটি লাগে ১১টি, ১০টি নয়। সন্দেহ হলে সবচেয়ে ছোট উদাহরণ (০টি, ১টি, ২টি জিনিস) হাতে dry run করে দেখুন।

ভুল ৩: থামতে না পারা while

তিনটি পরিচিত কারণ: (ক) শর্তের ভ্যারিয়েবল body-তে বদলানোই হয় না; (খ) বদলায়, কিন্তু ভুল দিকে (count += 1 লিখতে হতো count -= 1); (গ) শর্ত “ঠিক সমান” দিয়ে লেখা, অথচ মান লাফিয়ে পার হয়ে যায় — n = 5 থেকে প্রতিবার ২ কমালে while n != 0 কখনো মিথ্যা হয় না (5, 3, 1, −1, …)। নিরাপদ অভ্যাস: শর্তে !=-এর বদলে > বা < ব্যবহার করুন, আর while True লিখলে প্রথমেই ঠিক করুন break কোথায়।

৯ · যে লুপ লিখতেই হয় না — accumulator বনাম built-in

লুপে বারবার কয়েকটি প্যাটার্ন ফিরে আসে: যোগফল, গণনা, সর্বোচ্চ-সর্বনিম্ন, “কেউ কি…?”, “সবাই কি…?”. প্রতিটির জন্য Python-এ একটি তৈরি built-in function আছে:

Built-in কেন ভালো? তিনটি কারণ। পড়া সহজ: sum(marks) দেখেই উদ্দেশ্য বোঝা যায়; চার লাইনের লুপ পড়ে বুঝতে হয়। ভুলের সুযোগ কম: total = 0 ভুলে লুপের ভেতরে লিখে ফেলা, বা biggest = 0 দিয়ে শুরু করা (সব নম্বর ঋণাত্মক হলে ভুল উত্তর) — এমন বাগ built-in-এ হয় না। দ্রুত: পর্ব ০৫-এ দেখেছেন, বিশুদ্ধ Python লুপের প্রতিটি ঘোরায় virtual machine-কে কয়েকটি bytecode নির্দেশ চালাতে হয়। sum()-এর লুপটি চলে CPython-এর ভেতরে, C-তে লেখা — তাই একই কাজ সাধারণত কয়েক গুণ দ্রুত হয়।

any() আর all()-এর আরেকটি গুণ: উত্তর জানা মাত্র থেমে যায়। any() প্রথম সত্য পেলেই True দেয়, বাকিগুলো দেখে না; all() প্রথম মিথ্যা পেলেই False. একে বলে short-circuit — পর্ব ০৮-এর and/or-এর মতোই।

লাখ লাখ সংখ্যা নিয়ে হিসাব — যেমন ছবির পিক্সেল বা সেন্সরের ডেটা — সেখানে built-in-ও যথেষ্ট নয়। তখন NumPy পুরো array-এর ওপর একবারে কাজ করে, লুপটি পুরোপুরি C-তে চালিয়ে; পর্ব ৪৬-এ দেখবেন। তবে আগেভাগে চিন্তা করবেন না: ১২ মাস, ৬০ জন শিক্ষার্থী, একটি দোকানের দিনের বিক্রি — এমন কাজে সাধারণ for লুপই যথেষ্ট দ্রুত। গতির প্রশ্ন আসে মেপে দেখার পর (পর্ব ৪৩), অনুমানে নয়।

১০ · AI-এর যুগে — AI-এর লেখা লুপ যাচাই

লুপ লিখতে বললে AI প্রায় সবসময় এমন কোড দেয় যা চলে. সমস্যা হলো, AI শিখেছে কোটি কোটি লাইনের কোড থেকে, যার বড় অংশ C, Java বা পুরোনো Python ধাঁচে লেখা। তাই AI-এর লুপে প্রায়ই “বিদেশি উচ্চারণ” থাকে — আর মাঝে মাঝে লুকানো বাগ।

AI-এর লেখা লুপ পেলে — যাচাইয়ের চেকলিস্ট

• range(len(x)) আছে কি? থাকলে for item in x, enumerate বা zip দিয়ে লেখা যায় কি না দেখেছি
• হাতে লেখা যোগফল/গণনা/সর্বোচ্চ-এর জায়গায় sum, max, any, all ব্যবহার করা যায় কি না দেখেছি
• লুপের ভেতরে একই list-এ remove, append বা del হচ্ছে কি না খুঁজেছি
• প্রতিটি while-এর শর্ত কীভাবে মিথ্যা হবে, বা break কোথায় — নিশ্চিত হয়েছি
• খালি list, এক উপাদানের list আর দৈর্ঘ্য না মেলা দুটি list দিয়ে কোডটি নিজে চালিয়ে দেখেছি