মাঝপথের প্রজেক্ট — পরীক্ষার ফলের একটি CLI টুল

১ · একটি আসল প্রোগ্রাম — অনেক ছোট ফাংশন আর একটি লুপ

বিশটি পর্বে আপনি Python-এর মূল সব হাতিয়ার হাতে নিয়েছেন: ভ্যারিয়েবল, string, শর্ত, লুপ, ফাংশন, list, tuple, dict, set, comprehension, আর মেমরিতে object কীভাবে ভাগাভাগি হয় তার ছবি। কিন্তু হাতিয়ার চেনা আর হাতিয়ার দিয়ে কিছু বানানো আলাদা দক্ষতা — রান্নার সব মসলা চিনলেই বিয়েবাড়ির বিরিয়ানি রাঁধা যায় না। মডিউল ৩-এর এই শেষ পর্বে আমরা সব মিলিয়ে একটি সত্যিকারের ছোট টুল বানাব।

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

আমাদের প্রোগ্রামটি হবে একটি CLI টুল — terminal-এ চলে, প্রতিটি লাইনে একটি কমান্ড পড়ে, উত্তর লেখে, আবার পরের কমান্ডের জন্য অপেক্ষা করে। শেষে এর সাথে কথোপকথন হবে এমন:

> add Rahim 78 85 90
  ok: Rahim added, GPA 4.67
> add Sumi 85 88 80
  ok: Sumi added, GPA 5.00
> add Tania 95 abc 70
  usage: add NAME bangla english math (each 0-100)
> show
  1. Rahim  253  GPA 4.67
  2. Sumi   253  GPA 5.00
> quit

এই পর্বের আসল বিষয় ফলাফলের প্রোগ্রাম নয়, পদ্ধতি: চাহিদা লেখা → কাজকে ফাংশনে ভাগ করা → ডেটার আকার ঠিক করা → ছোট ছোট ধাপে (milestone) বানানো → প্রতিটি ধাপ পরীক্ষা করা। একই পদ্ধতি চলে দোকানের হিসাব, লাইব্রেরির বইয়ের তালিকা বা হাসপাতালের রোগীর খাতায়। C++ কোর্সের মাঝপথের প্রজেক্টে একই পদ্ধতিতে একটি দোকানের হিসাবের টুল বানানো হয়েছে; এখানে বিষয় আলাদা, আর Python-এর নিজস্ব হাতিয়ারগুলো (dict, comprehension, sorted) কাজে লাগবে।

২ · চাহিদা — কমান্ডের টেবিল আর গ্রেডিং স্কেল

নতুনদের সবচেয়ে সাধারণ ভুল হলো সমস্যা না বুঝেই কোড লিখতে বসা। দর্জি মাপ না নিয়ে জামা সেলাই করলে যত সুন্দর সেলাই-ই হোক, গায়ে লাগবে না। সফটওয়্যারে মাপ নেওয়ার নাম requirement বা চাহিদা লেখা। নাসরিন আপার সাথে কথা বলে আমরা ঠিক করলাম টুলটি কী কী কমান্ড বুঝবে, আর প্রতিটির ফল কী হবে:

লক্ষ করুন, এই টেবিলটিই একটি ছোট specification. এতে কীভাবে বানানো হবে তার একটি শব্দও নেই — list না dict, কোন ফাংশন — শুধু কী করবে। তাই পরে ভেতরের কোড পুরো বদলে গেলেও টেবিলটি একই থাকে, আর এই টেবিল থেকেই টেস্ট লেখা যায়। প্রতিটি সারির শেষ কলামটি আসলে একটি টেস্টের বর্ণনা।

গ্রেডিং স্কেল — উদাহরণ হিসেবে

GPA বের করতে একটি নিয়ম লাগবে। আমরা বাংলাদেশের মাধ্যমিক পর্যায়ে প্রচলিত স্কেলটি উদাহরণ হিসেবে নিলাম। প্রতিটি বিষয়ের নম্বর থেকে একটি grade point, আর সব বিষয়ের grade point-এর গড় হলো GPA. কোনো এক বিষয়ে F পেলে GPA শূন্য।

যা এখন বানাব না — MVP-র সীমারেখা

নাসরিন আপা আরও চাইলেন: ফলাফল ফাইলে রেখে দেওয়া, Excel-এ পাঠানো, অভিভাবককে SMS, প্রতিটি ছাত্রের রিপোর্ট কার্ড ছাপা। সবই যৌক্তিক, কিন্তু সব একসাথে বানাতে গেলে কয়েক সপ্তাহেও শেষ হবে না। তাই প্রথমে একটি MVP — সবচেয়ে ছোট সংস্করণ, যা তাঁর সবচেয়ে বড় কষ্ট দূর করে: হাতে যোগ আর মেধাতালিকা সাজানো।

৩ · পরিকল্পনা — কাজকে এক-কাজের ফাংশনে ভাগ করা

পর্ব ০২-এ শিখেছিলেন decomposition — বড় সমস্যাকে ছোট, আলাদাভাবে সমাধানযোগ্য টুকরোয় ভাগ করা। আর পর্ব ১৩-এ দেখেছেন, Python-এ প্রতিটি টুকরো সাধারণত একটি function. কমান্ডের টেবিলের দিকে তাকিয়ে প্রশ্ন করুন: “এখানে কোন কোন আলাদা কাজ আছে, যার প্রত্যেকটিকে এক বাক্যে বলা যায়?” উত্তরগুলোই আমাদের ফাংশনের তালিকা:

সবচেয়ে গুরুত্বপূর্ণ নিয়মটি ছবির নিচে লেখা: হিসাবের ফাংশন কিছু পড়ে না, কিছু ছাপে না — শুধু মান নেয় আর মান ফেরত দেয়। পর্ব ১৩-এর print বনাম return-এর শিক্ষা এখানে নকশার নীতি হয়ে দাঁড়াল। এই নীতির নাম separation of concerns — আলাদা দায়িত্ব আলাদা জায়গায়। লাভ তিনটি:

• পরীক্ষা সহজ: gpa([78, 85, 90]) কীবোর্ড ছাড়াই ডেকে ফল মেলানো যায় — অংশ ৯-এ ঠিক তাই করব।
• বদল সহজ: কাল যদি নাসরিন আপা চান বার্তাগুলো বাংলায় হোক, বা টুলটি একটি ওয়েবপেজে চলুক, শুধু বাঁয়ের স্তর বদলাবে; gpa-র একটি লাইনও না।
• বোঝা সহজ: প্রতিটি ফাংশন এক স্ক্রিনে আঁটে, নাম পড়েই কাজ বোঝা যায়।

লক্ষ করুন, ফাংশনগুলোর বেশিরভাগই pure function — একই ইনপুটে সবসময় একই ফল, বাইরের কিছু বদলায় না। শুধু add_student জেনেশুনে একটি side effect ঘটায়: db-তে নতুন ছাত্র যোগ করে। আর db সে পায় parameter হিসেবে, কোনো global ভ্যারিয়েবল থেকে নয় — তাই টেস্টে একটি খালি dict দিয়েই তাকে পরীক্ষা করা যায়।

৪ · ডেটা মডেল — list of dicts, নাকি dict of dicts?

ফাংশন লেখার আগে ঠিক করতে হবে ডেটা কোন আকারে থাকবে। একে বলে data model. একজন ছাত্রের তথ্য হলো একটি নাম আর তিনটি নম্বর। পর্ব ১৬-এর dict এখানে স্বাভাবিক পছন্দ: {"name": "Rahim", "marks": [78, 85, 90]}. নম্বরগুলো ক্রম মেনে চলে (বাংলা, ইংরেজি, গণিত), তাই সেগুলো একটি list-এ (পর্ব ১৪)। প্রশ্ন হলো, অনেক ছাত্রকে একসাথে কীভাবে রাখব? দুটি প্রার্থী:

# মডেল ক — list of dicts: যোগ করার ক্রমে সারি
students = [
    {"name": "Rahim", "marks": [78, 85, 90]},
    {"name": "Karim", "marks": [92, 66, 71]},
]

# মডেল খ — dict of dicts: ছোট হাতের নাম দিয়ে চাবি
db = {
    "rahim": {"name": "Rahim", "marks": [78, 85, 90]},
    "karim": {"name": "Karim", "marks": [92, 66, 71]},
}

আমরা বেছে নিলাম মডেল খ, কারণ আমাদের দুটি কমান্ড — add-এ ডুপ্লিকেট পরীক্ষা আর ভবিষ্যতের নম্বর সংশোধন — নাম দিয়ে খোঁজার ওপর দাঁড়িয়ে। চাবিটি নামের casefold() করা রূপ (পর্ব ০৯), যাতে “Rahim” আর “rahim” একই ছাত্র ধরা হয়, অথচ দেখানোর জন্য আসল বানান "name"-এ থেকে যায়। চাবি হিসেবে string চলে, কারণ string hashable; list চাবি হতে পারত না।

দামটাও লিখে রাখুন: একই নামের দুজন ছাত্র রাখা যাবে না। আসল স্কুলে তাই নাম নয়, রোল নম্বর হয় চাবি। MVP-তে আমরা এই সীমা জেনেশুনে মেনে নিলাম; পরের সংস্করণে চাবি বদলে রোল করলে শুধু add_student বদলাবে। এভাবে প্রতিটি সিদ্ধান্তের কারণ আর দাম লিখে রাখলে ছয় মাস পরে “এটা এমন কেন?” প্রশ্নের উত্তর খুঁজতে হয় না।

এবার দেখুন, কমান্ড আসার সাথে সাথে db কীভাবে বড় হয় — আর বাতিল হওয়া কমান্ডে কেন একটুও বদলায় না:

{}
len(db) == 0 · show লিখলে: (no students yet)

{
  "rahim": {"name": "Rahim", "marks": [78, 85, 90]}
}

{
  "rahim": {"name": "Rahim", "marks": [78, 85, 90]},
  "karim": {"name": "Karim", "marks": [92, 66, 71]}
}

{
  "rahim": {"name": "Rahim", "marks": [78, 85, 90]},
  "karim": {"name": "Karim", "marks": [92, 66, 71]},
  "sumi":  {"name": "Sumi",  "marks": [85, 88, 80]}
}

"rahim".casefold() == "rahim"  → "rahim" in db → True
error: rahim already exists
db অপরিবর্তিত — এখনো ৩ জন

"abc".isdecimal() → False  → parse_marks() ফেরত দিল None
usage: add NAME bangla english math (each 0-100)
add_student() ডাকাই হয়নি — db এখনো ৩ জন

৫ · একটি কমান্ডের যাত্রা — আর exception ছাড়া ইনপুট যাচাই

প্রতিটি CLI টুলের হৃদয় একটি লুপ: একটি লাইন পড়া → বুঝে নেওয়া → কাজ করা → ফল জানানো → আবার পড়া। আমাদের লুপে input() পুরো একটি লাইন একটি string হিসেবে দেয় (পর্ব ১০), আর str.split() সেটিকে space ধরে শব্দের list বানায়। তারপর cmd, *args = ... — পর্ব ১৫-এর star unpacking — প্রথম শব্দটি cmd-এ, বাকি সব args list-এ রাখে। কোন কমান্ড, তা বাছাই করে পর্ব ১১-এর match statement. “পরে” চেপে add Rahim 78 85 90 লাইনটির পুরো যাত্রা দেখুন:

1line = input().strip()2cmd, *args = line.split()3match cmd:  case "add":4    marks = parse_marks(args[1:])5    if name.casefold() in db: ...6    db[key] = {"name": name, "marks": list(marks)}7    return f"ok: {name} added, GPA ..."8print("  " + out)

exception ছাড়া যাচাই — শর্ত আর string method দিয়ে

“78” থেকে সংখ্যা পেতে int("78") লিখতে হয়। কিন্তু int("abc") চালালে Python থেমে যায় একটি ValueError দিয়ে। এই ধরনের ভুল ধরে সামলানোর যন্ত্র try/except আসবে পর্ব ২৪-এ। এখন আমরা অন্য পথ নেব: int() ডাকার আগেই পরীক্ষা করব লেখাটি সত্যিই একটি অ-ঋণাত্মক পূর্ণসংখ্যা কি না। এই পুরো কাজকে বলে input validation — বাইরের ডেটা বিশ্বাস করার আগে পরীক্ষা।

শেষ সারিটিই কারণ যে আমরা isdigit() নয়, isdecimal() ব্যবহার করেছি। isdigit() কিছু Unicode চিহ্নকেও “অঙ্ক” মানে, যেগুলো int() পড়তে পারে না; isdecimal() শুধু দশমিক পদ্ধতির অঙ্ক মানে — যেগুলো int() নিশ্চিতভাবে পড়তে পারে। আর সুখবর: বাংলা অঙ্ক দশমিক অঙ্ক, তাই নাসরিন আপা বাংলা কীবোর্ডে “৭৮” লিখলেও টুলটি ঠিকঠাক 78 পড়বে। এরপর সীমা পরীক্ষা — int(r) <= 100. ঋণাত্মক সংখ্যা আগেই বাদ, কারণ “-” চিহ্ন অঙ্ক নয়।

def parse_marks(raw):
    """['78', '85', '90'] → [78, 85, 90]; কোনো সমস্যা থাকলে None"""
    if len(raw) != len(SUBJECTS):                      # শব্দের সংখ্যা
        return None
    if not all(r.isdecimal() and int(r) <= 100 for r in raw):   # ধরন + সীমা
        return None
    return [int(r) for r in raw]                       # সব ঠিক — এবার রূপান্তর

দুটি সূক্ষ্ম বিষয় লক্ষ করুন। r.isdecimal() and int(r) <= 100-এ পর্ব ০৮-এর short-circuit কাজ করছে: isdecimal() মিথ্যা হলে int(r) ডাকাই হয় না, তাই “abc”-তে কোনো error ওঠে না। আর প্রতিটি সমস্যায় ফাংশন শুরুতেই None ফেরত দেয় — পর্ব ১১-এর guard clause. ফেরত None মানে “বৈধ নয়”; কী বার্তা দেখাবে, তা ঠিক করে ডাকা জায়গা। None পরীক্ষা হয় is None দিয়ে।

৬ · রিপোর্ট — sorted, key আর comprehension

ডেটা জমা হলো; এবার তা থেকে উত্তর বের করার পালা। show, top, fail, avg, find — পাঁচটি কমান্ডই আসলে একই কাজের রূপভেদ: ছাত্রদের তালিকা হেঁটে কিছু বেছে নেওয়া বা কিছু হিসাব করা। পর্ব ১৮-এর list comprehension ঠিক এই কাজের জন্য:

rows = sorted(db.values(), key=sheet_key)              # মেধাক্রমে সাজানো list

failed  = [s["name"] for s in rows if gpa(s["marks"]) == 0.0]
matches = [s["name"] for s in rows if text.casefold() in s["name"].casefold()]
bangla_avg = sum(s["marks"][0] for s in rows) / len(rows)   # len(rows) > 0 আগেই নিশ্চিত

প্রতিটি comprehension এক বাক্যে পড়া যায়: “প্রতিটি ছাত্রের নাম নাও, যদি তার GPA শূন্য হয়।” কিন্তু সবচেয়ে মজার অংশ প্রথম লাইনে — মেধাতালিকা সাজানো। পর্ব ১৩-এ দেখেছিলেন, sorted-কে একটি ফাংশন দেওয়া যায় (first-class function), যা প্রতিটি উপাদান থেকে একটি “তুলনার চাবি” বানায়। একে বলে key function. আমাদের চাবি একটি tuple:

def sheet_key(s):
    return (-sum(s["marks"]), s["name"])     # মোট বেশি থেকে কম, তারপর নাম A→Z

tuple তুলনা হয় অভিধানের মতো (lexicographic): প্রথম উপাদান আগে, সমান হলে দ্বিতীয়টি। আমরা চাই মোট নম্বর বেশি থেকে কম, কিন্তু নাম A থেকে Z — দুটি উল্টো দিক। reverse=True দিলে দুটোই উল্টে যেত। কৌশল: সংখ্যাটির আগে মাইনাস। −২৫৩ < −২২৯, তাই বড় মোট আগে আসে, আর নাম স্বাভাবিক ক্রমেই থাকে। “পরে” চেপে দেখুন:

Rahim  [78, 85, 90]  মোট 253
Karim  [92, 66, 71]  মোট 229
Sumi   [85, 88, 80]  মোট 253
Joy    [45, 30, 60]  মোট 135
Rina   [92, 66, 71]  মোট 229

Rahim  → (-253, 'Rahim')
Karim  → (-229, 'Karim')
Sumi   → (-253, 'Sumi')
Joy    → (-135, 'Joy')
Rina   → (-229, 'Rina')

-253  Rahim, Sumi      ← এখনো সমান
-229  Karim, Rina      ← এখনো সমান
-135  Joy

(-253, 'Rahim') < (-253, 'Sumi')    'R' < 'S'
(-229, 'Karim') < (-229, 'Rina')    'K' < 'R'
ফল: Rahim, Sumi, Karim, Rina, Joy

1. Rahim  253  GPA 4.67
2. Sumi   253  GPA 5.00
3. Karim  229  GPA 4.17
4. Rina   229  GPA 4.17
5. Joy    135  GPA 0.00

৭ · দুটি লুকানো ফাঁদ — alias আর mutable default

পর্ব ১৯ আর ২০-এ যে দুটি ফাঁদ দেখেছেন, বাস্তব প্রজেক্টে ঠিক সেগুলোই সবচেয়ে বেশি ধরা পড়ে — কারণ ছোট উদাহরণে এরা চুপচাপ থাকে, বড় প্রোগ্রামে হঠাৎ জেগে ওঠে।

ফাঁদ ১ — নম্বরের list-এর alias

ধরুন add_student-এ লেখা হলো {"name": name, "marks": marks}, কপি ছাড়া। তখন db-র ভেতরের list আর ডাকা জায়গার marks — দুটি নাম, একটিই list object. এটাই alias. পরে কেউ সেই marks list আবার ব্যবহার করলে — যেমন পরের ছাত্রের জন্য একই list বদলে নিলে — আগের ছাত্রের নম্বরও নিঃশব্দে বদলে যাবে। কোনো error নেই, শুধু ভুল মেধাতালিকা।

marks = [78, 85, 90]
db["rahim"] = {"name": "Rahim", "marks": marks}         # ✗ alias
marks[0] = 40                                           # অন্য কাজে list-টি বদলালাম…
print(db["rahim"]["marks"])                             # [40, 85, 90] — রহিমের নম্বর বদলে গেল!

db["rahim"] = {"name": "Rahim", "marks": list(marks)}   # ✓ নতুন list, নিজস্ব কপি

নিয়ম: বাইরে থেকে আসা mutable object নিজের দীর্ঘস্থায়ী ডেটায় রাখার আগে কপি করুন। এখানে list-এর ভেতরে শুধু int (যা immutable), তাই list(marks)-এর মতো একটি shallow copy-ই যথেষ্ট। ভেতরে আরও list থাকলে লাগত copy.deepcopy (পর্ব ১৯)। parse_marks অবশ্য প্রতিবার comprehension দিয়ে নতুন list বানায়, তাই আজকের প্রোগ্রামে বিপদ ঘটত না — কিন্তু add_student জানে না কে তাকে ডাকবে। টেস্ট থেকে, ভবিষ্যতের ফাইল-পড়ার কোড থেকে, বা অন্য কারও লেখা ফাংশন থেকে — তাই সে নিজেই নিজেকে রক্ষা করে।

ফাঁদ ২ — default-এ list

প্রজেক্টে একটি “ইতিহাস” রাখতে চাইলেন — কোন কমান্ড কখন এল। প্রথম চিন্তায় আসে:

def log_command(line, history=[]):        # ✗ default list একবারই তৈরি হয়
    history.append(line)
    return history

def log_command(line, history=None):      # ✓ প্রতিবার নতুন, যদি না দেওয়া হয়
    if history is None:
        history = []
    history.append(line)
    return history

পর্ব ২০-এ দেখেছেন কেন প্রথমটি ভুল: default argument-এর মান তৈরি হয় def চলার সময় একবার, প্রতি ডাকে নয়। ফলে সব ডাক একই list ভাগ করে, আর দুটি আলাদা “সেশন”-এর ইতিহাস মিশে যায়। এই mutable default-এর ফাঁদ এড়ানোর প্রচলিত পথ None default আর ভেতরে নতুন list. আমাদের মূল নকশা আরও সরল পথ নিয়েছে: db কোনো default বা global নয়, প্রতিটি ফাংশন তাকে স্পষ্টভাবে parameter হিসেবে পায়। যে ডেটা বদলায়, তা কোথা থেকে আসছে — কোড পড়েই দেখা যায়।

৮ · মাইলস্টোনে বানানো — আর পুরো টুল চালিয়ে দেখা

নতুনরা প্রায়ই ২০০ লাইন একবারে লিখে প্রথমবার চালান, আর পান একের পর এক error — কোনটি কোথা থেকে, বোঝার উপায় নেই। অভিজ্ঞরা আগে ছোট কিছু বানান যা চলে, তারপর একটু একটু যোগ করেন, আর প্রতিটি যোগের পর প্রোগ্রাম আবার চলে। কিছু ভাঙলে দোষী শেষ যোগ করা অংশটুকুই। প্রতিটি ধাপকে বলে একটি milestone:

> add Rahim 78 85 90
  [add: coming soon]
> dance
  error: unknown command 'dance'
> quit
টেস্ট: quit-এ বের হয় · অজানা কমান্ডে বার্তা · খালি লাইনে crash নয়

> add Rahim 78 85 90
  ok: Rahim added, GPA 4.67
> show
  1. Rahim  253  GPA 4.67
এখনো যাচাই নেই — "add Tania abc" দিলে ValueError-এ প্রোগ্রাম থামে
টেস্ট: হাতে হিসাব করা GPA মেলানো · খালি show

> add Tania 95 abc 70
  usage: add NAME bangla english math (each 0-100)
> add rahim 50 50 50
  error: rahim already exists
টেস্ট: কম/বেশি নম্বর · অক্ষর · -5 · 8.5 · 101 · ডুপ্লিকেট নাম

> top
  top 253: Rahim, Sumi
> fail
  Joy
> avg
  bangla: 78.4
টেস্ট: সমান নম্বরে দুজন top · কেউ ফেল না হলে বার্তা · গড় হাতে মেলানো

PASS grade_point: every boundary of the scale
PASS parse_marks: 5 kinds of bad input rejected
PASS stored marks are a copy, not an alias
প্রতিটি নতুন বাগের জন্য একটি নতুন assert — চিরকাল থাকে

পুরো টুল — একটি স্ক্রিপ্ট করা সেশনসহ

এবার M4 পর্যন্ত পুরো প্রোগ্রাম, এক ফাইলে। প্রজেক্ট বলে এটি অন্য উদাহরণের চেয়ে লম্বা — প্রায় ৬০ লাইন — কিন্তু প্রতিটি ফাংশন এই পর্বে আলাদা করে দেখেছেন। ইনপুট আগে থেকেই দেওয়া: একটি সেশন, যাতে ইচ্ছা করে কয়েকটি ভুল কমান্ডও রাখা আছে। চালানোর আগে অনুমান করুন show কী ছাপবে, তারপর “Run” চাপুন:

SUBJECTS = ("bangla", "english", "math")
SCALE = ((80, 5.0), (70, 4.0), (60, 3.5), (50, 3.0), (40, 2.0), (33, 1.0))

def grade_point(mark):
    for low, point in SCALE:
        if mark >= low:
            return point
    return 0.0                                   # 0-32 = F

def gpa(marks):
    points = [grade_point(m) for m in marks]
    return 0.0 if 0.0 in points else round(sum(points) / len(points), 2)

def parse_marks(raw):
    if len(raw) != len(SUBJECTS) or not all(r.isdecimal() and int(r) <= 100 for r in raw):
        return None                              # invalid: caller shows usage
    return [int(r) for r in raw]

def add_student(db, name, marks):
    if name.casefold() in db:
        return f"error: {name} already exists"
    db[name.casefold()] = {"name": name, "marks": list(marks)}   # a copy
    return f"ok: {name} added, GPA {gpa(marks):.2f}"

def sheet_key(s):
    return (-sum(s["marks"]), s["name"])         # total high->low, then name A->Z

def handle(db, cmd, args):
    if cmd in ("show", "top", "fail", "avg", "find") and not db:
        return ["(no students yet)"]
    rows = sorted(db.values(), key=sheet_key)
    match cmd:
        case "add":
            marks = parse_marks(args[1:]) if args else None
            if marks is None:
                return [f"usage: add NAME {' '.join(SUBJECTS)} (each 0-100)"]
            return [add_student(db, args[0], marks)]
        case "show":
            return [f"{i}. {s['name']:<6}{sum(s['marks']):>4}  GPA {gpa(s['marks']):.2f}"
                    for i, s in enumerate(rows, 1)]
        case "top":
            best = sum(rows[0]["marks"])
            return [f"top {best}: " + ", ".join(s["name"] for s in rows if sum(s["marks"]) == best)]
        case "fail":
            return [s["name"] for s in rows if gpa(s["marks"]) == 0.0] or ["nobody failed"]
        case "avg":
            return [f"{sub}: {sum(s['marks'][i] for s in rows) / len(rows):.1f}"
                    for i, sub in enumerate(SUBJECTS)]
        case "find" if args:
            return [s["name"] for s in rows if args[0].casefold() in s["name"].casefold()] or ["no match"]
        case _:
            return [f"error: unknown command '{cmd}' (try: add show top fail avg find quit)"]

db = {}
while (line := input().strip()) != "quit":
    print(">", line)
    cmd, *args = line.split() or [""]
    for out in handle(db, cmd, args):
        print("  " + out)
print(f"> quit\n  bye: {len(db)} students (kept in memory only)")

৯ · টেস্ট — assert দিয়ে প্রমাণ, আর পরের ধাপ

“চালিয়ে দেখেছি, চলছে” — এটি টেস্ট নয়; আপনি চালিয়েছেন শুধু নিজের মাথার ইনপুট দিয়ে। নাসরিন আপা টাইপ করবেন এমন জিনিস, যা আপনি কল্পনাও করেননি। সবচেয়ে বেশি বাগ লুকিয়ে থাকে সীমানায়: ৭৯ আর ৮০, ৩২ আর ৩৩, ০ আর ১০০. তাই প্রতিটি মূল ফাংশনের জন্য ছোট ছোট পরীক্ষা লিখুন — একেকটি unit test. পর্ব ১৩-এর assert এর সবচেয়ে সরল যন্ত্র: শর্ত সত্য হলে নিঃশব্দে এগোয়, মিথ্যা হলে প্রোগ্রাম থামিয়ে জানায়।

SCALE = ((80, 5.0), (70, 4.0), (60, 3.5), (50, 3.0), (40, 2.0), (33, 1.0))

def grade_point(mark):
    for low, point in SCALE:
        if mark >= low:
            return point
    return 0.0

def parse_marks(raw, n=3):
    if len(raw) != n or not all(r.isdecimal() and int(r) <= 100 for r in raw):
        return None
    return [int(r) for r in raw]

assert [grade_point(m) for m in (100, 80, 79, 33, 32, 0)] == [5.0, 5.0, 4.0, 1.0, 0.0, 0.0]
print("PASS grade_point: every boundary of the scale")
assert parse_marks(["78", "85", "90"]) == [78, 85, 90]
assert parse_marks(["৭৮", "৮৫", "৯০"]) == [78, 85, 90]      # Bangla digits work too
for bad in (["78", "85"], ["78", "-5", "90"], ["8.5", "1", "1"], ["101", "0", "0"], ["78", "²", "90"]):
    assert parse_marks(bad) is None, bad
print("PASS parse_marks: 5 kinds of bad input rejected")
marks = [78, 85, 90]
db = {"rahim": {"name": "Rahim", "marks": list(marks)}}
marks[0] = 0                                       # caller reuses its list
assert db["rahim"]["marks"] == [78, 85, 90]
print("PASS stored marks are a copy, not an alias")

একটি নিয়ম মনে রাখুন: প্রতিটি ধরা পড়া বাগের জন্য একটি নতুন টেস্ট, আর সেটি চিরকাল রেখে দিন। একবার ঠিক করা বাগ পরে কোনো পরিবর্তনে ফিরে আসাকে বলে regression; এই টেস্টগুলো তার পাহারাদার। assert শেখার জন্য চমৎকার, কিন্তু Python -O অপশনে চালালে assert বাদ পড়ে যায় — তাই আসল প্রজেক্টে টেস্ট থাকে আলাদা ফাইলে, pytest দিয়ে চালানো (পর্ব ৩৯)।

পরের সংস্করণ — কোন পর্ব কোন দরজা খুলবে

লক্ষ করুন, তিন স্তরে ভাগ করা নকশার লাভ এখানে চোখে পড়ে: ফাইলে সংরক্ষণ যোগ হলে নতুন দুটি ফাংশন আসবে (save, load), কিন্তু gpa, parse_marks বা sheet_key-এর একটি লাইনও বদলাবে না। আর এখনকার টেস্টগুলো তখনও হুবহু পাস করতে হবে — সেটাই প্রমাণ যে নতুন কাজ পুরোনোটা ভাঙেনি।

১০ · AI-এর যুগে — AI-কে দায়িত্বশীল pair-programmer বানানো

এই পুরো প্রজেক্ট AI-কে এক লাইনে বললে কয়েক সেকেন্ডে একটি চলা কোড পাওয়া যায়। তাহলে এত পরিকল্পনা কেন? কারণ AI সাধারণত দেয় একটি ৮০–১৫০ লাইনের বিশাল স্ক্রিপ্ট: সব কাজ এক লুপে, যাচাই আর হিসাব আর ছাপা মেশানো, global ভ্যারিয়েবল, আর এমন কিছু যা আপনি এখনো শেখেননি (class, try/except, lambda). কোডটি চলে — যতক্ষণ না নাসরিন আপা এমন কিছু টাইপ করেন যা AI ভাবেনি। তখন আপনি এমন কোড ঠিক করতে বসেছেন, যা আপনি বোঝেন না।

ভালো ব্যবহার হলো AI-কে pair programming-এর সঙ্গীর মতো দেখা: সে প্রস্তাব দেয়, আপনি সিদ্ধান্ত নেন। কোড চাওয়ার আগে চান পরিকল্পনা আর টেস্ট; তারপর একবারে একটি ফাংশন; প্রতিটি পড়ে বুঝে, টেস্ট চালিয়ে, তবেই পরেরটি।

AI-এর দেওয়া প্রতিটি ফাংশন গ্রহণের আগে — চেকলিস্ট

• ফাংশনটি লাইন ধরে কাউকে মুখে ব্যাখ্যা করতে পারি — না পারলে সেটি গ্রহণ করি না
• এটি একটি কাজ করে, মান return করে, আর ভেতরে কোনো print/input নেই
• শুধু শেখা জিনিস ব্যবহার করেছে; অচেনা কিছু থাকলে আগে সেটি শিখে নিয়েছি
• ভুল ইনপুট (int()-এর আগে যাচাই) আর খালি অবস্থা (শূন্য ছাত্র) সামলানো হয়েছে
• বাইরের list/dict কপি করে রাখা হয়েছে; কোনো default-এ [] বা {} নেই
• নিজের লেখা অন্তত একটি assert চালিয়ে PASS দেখেছি, আর AI-এর টেস্টের প্রত্যাশিত মান হাতে হিসাব করে মিলিয়েছি