ডেটার জন্য Python — list, dict, comprehension আর function-এর ঝালাই

এই পর্ব Python শেখানোর পর্ব নয়। Python ভাষাটি ধাপে ধাপে শেখানো হয়েছে ABCL TECH-এর Python প্রোগ্রামিং কোর্সে। এখানে শুধু সেই অংশগুলো ঝালাই করা হবে, যা পরের মডিউলে NumPy আর pandas ধরার আগে প্রতিদিন লাগবে, আর যে ফাঁদগুলোতে ডেটার কাজে সবচেয়ে বেশি মানুষ পড়েন। কোথাও অচেনা লাগলে পাশের লিংকে Python কোর্সের সেই পর্বটি দেখে আসুন। কাজের পরিবেশ (Python install, venv, package) এসেছে পর্ব ৭-এ, আর notebook এসেছে পর্ব ৮-এ; এই পর্বের কোড পাতাতেই চলবে, তাই কিছু install করতে হবে না।

১ · রেকর্ড আর টেবিল — dict, list of dict আর বাজারঘরের অর্ডার

চায়ের দোকানের হিসাব খাতার কথা ভাবুন। প্রতিটি লাইনে একজন খদ্দেরের হিসাব: নাম, কী নিলেন, কত টাকা। একটি লাইন হলো একটি record; অনেক লাইন মিলে পুরো খাতা, মানে একটি টেবিল। ডেটার প্রায় সব কাজ এই দুটি জিনিস দিয়ে শুরু হয়।

Python-এ একটি রেকর্ডের সবচেয়ে স্বাভাবিক রূপ হলো dict: প্রতিটি ঘরের একটি নাম (চাবি বা key) আর একটি মান। বাজারঘরের (এই কোর্সের কাল্পনিক অনলাইন দোকান) একটি অর্ডার:

order = {"order_id": 1001, "district": "ঢাকা", "amount_paisa": 30200}
order["district"]        # 'ঢাকা'  — অবস্থান নয়, নাম দিয়ে খোঁজা

খেয়াল করুন, টাকা রাখা হয়েছে পয়সায়: ৩০২ টাকা মানে 30200. কেন, তা অংশ ৮-এ দেখবেন। অনেকগুলো অর্ডার একসঙ্গে রাখলে পাওয়া যায় একটি list, যার প্রতিটি উপাদান একটি dict. একে বলে “list of dict”, আর এটি একটি টেবিলের সবচেয়ে সরল Python রূপ। প্রতিটি dict একটি সারি (row), আর সব dict-এর একই চাবি মিলে কলাম। dict কীভাবে কাজ করে (hashing, গড়ে দ্রুত খোঁজা), সেটি আছে Python কোর্সের dictionary পর্বে, আর list-এর খুঁটিনাটি list পর্বে।

কিন্তু একই টেবিল আরেকভাবেও রাখা যায়: প্রতিটি কলামের জন্য একটি list, আর সেই list-গুলো কলামের নাম দিয়ে একটি dict-এ। একে বলে “dict of list” বা কলামভিত্তিক রূপ। নিচের ছবিতে একই তিনটি অর্ডার দুই রূপে দেখুন।

দুই রূপের মধ্যে আসা-যাওয়া zip দিয়ে এক লাইনেই হয় (অংশ ৪-এ দেখবেন)। কোনটি কখন? একটি একটি করে অর্ডার আসছে, প্রতিটিকে আলাদা করে যাচাই বা পাঠাতে হবে, তখন সারিভিত্তিক রূপ স্বাভাবিক; JSON API-ও সাধারণত এই আকারে ডেটা দেয়। আর একটি কলামের ওপর হিসাব (মোট, গড়, সর্বোচ্চ) করতে হলে কলামভিত্তিক রূপ সুবিধার। পর্ব ২০-এ দেখবেন, pd.DataFrame(orders) লিখলে pandas ঠিক এই list of dict নিয়েই একটি কলামভিত্তিক টেবিল বানায়।

২ · Comprehension — ছাঁকা আর রূপ বদলানো এক বাক্যে

ডেটার সবচেয়ে সাধারণ দুটি কাজ হলো কিছু সারি বেছে নেওয়া (filter) আর প্রতিটি সারি থেকে একটি নতুন মান বানানো (map). Python-এ দুটি কাজ একসঙ্গে লেখার সবচেয়ে পরিচিত উপায় list comprehension:

[রূপ_বদল  for রেকর্ড in টেবিল  if শর্ত]

বাংলায় পড়লে: “টেবিলের প্রতিটি রেকর্ডের জন্য, শর্ত সত্যি হলে, রূপ বদলানো মানটি নিন।” নিচের ধাপে দেখুন, প্রথম পাঁচটি অর্ডার থেকে শুধু ঢাকার অর্ডারের টাকা (পয়সা বাদ দিয়ে পূর্ণ টাকা) কীভাবে বের হয়। “পরে” চাপুন।

1dhaka = [o["amount_paisa"] // 1002         for o in orders[:5]3         if o["district"] == "ঢাকা"]

একই ছাঁচে dict আর set-ও বানানো যায়: {o["order_id"]: o["district"] for o in orders} হলো অর্ডার নম্বর থেকে জেলার একটি lookup dict, আর {o["district"] for o in orders} হলো জেলাগুলোর set, মানে পুনরাবৃত্তি ছাড়া তালিকা। বর্গবন্ধনী [ ]-এর জায়গায় গোল বন্ধনী ( ) দিলে list তৈরি হয় না, একটি generator expression তৈরি হয়, যা অংশ ৬-এর বিষয়। সব রূপ, nested comprehension আর walrus (:=) আছে Python কোর্সের comprehension পর্বে।

৩ · দলে ভাগ আর গোনা — Counter আর defaultdict

বাজারঘরের ম্যানেজার জানতে চান: কোন জেলা থেকে কয়টি অর্ডার এসেছে, আর প্রতিটি জেলার মোট বিক্রি কত। এই কাজের নাম grouping: সারিগুলোকে একটি চাবি (এখানে জেলা) ধরে দলে ভাগ করে প্রতিটি দলের একটি সারাংশ বের করা। SQL-এ এটি GROUP BY, pandas-এ groupby (পর্ব ২৪)। খাঁটি Python-এ এর দুটি প্রধান হাতিয়ার আছে collections module-এ।

• Counter: কোন জিনিস কতবার এলো, গোনে। Counter(o["district"] for o in orders) লিখলেই প্রতিটি জেলার অর্ডার-সংখ্যা। .most_common(k) সবচেয়ে বেশি k-টি দেয়।
• defaultdict: একটি dict, যেখানে না থাকা চাবি চাইলে KeyError না দিয়ে একটি শুরুর মান বসিয়ে দেয়। defaultdict(int) শুরু করে 0 দিয়ে (যোগফলের জন্য), defaultdict(list) শুরু করে [] দিয়ে (দলের সব সারি জমানোর জন্য)।

সাধারণ dict দিয়েও কাজটি করা যায়: total[d] = total.get(d, 0) + p. কিন্তু প্রতিবার .get লিখতে হয়, আর ভুলে total[d] += p লিখলে প্রথম নতুন জেলাতেই KeyError. নিচের ধাপে প্রথম পাঁচটি অর্ডার দিয়ে একটি defaultdict ভরে উঠতে দেখুন।

1total = defaultdict(int)2for o in orders[:5]:3    total[o["district"]] += o["amount_paisa"]

এবার পুরো কাজটি চালিয়ে দেখি: seed দেওয়া random দিয়ে বাজারঘরের ২০টি অর্ডার বানানো, জেলাভিত্তিক গোনা আর যোগফল, তারপর মোট বিক্রি অনুযায়ী সাজিয়ে টাকায় ছাপা। হিসাব পুরোটাই পূর্ণসংখ্যার পয়সায়; টাকায় রূপ দেওয়া হয় শুধু ছাপার মুহূর্তে। প্রথমবার চালালে পাতায় Python নামতে কয়েক সেকেন্ড লাগতে পারে।

import random
from collections import Counter, defaultdict
from operator import itemgetter

rng = random.Random(42)                 # seed: সবার একই ডেটা
districts = ["ঢাকা", "চট্টগ্রাম", "রাজশাহী", "সিলেট", "খুলনা"]
orders = [
    {"order_id": 1001 + i,
     "district": rng.choice(districts),
     "amount_paisa": rng.randrange(20_000, 300_000, 50)}  # ২০০–৩০০০ টাকা
    for i in range(20)
]
print("প্রথম সারি:", orders[0])

def taka(paisa):                        # 125050 -> '৳1,250.50'
    t, p = divmod(paisa, 100)
    return f"৳{t:,}.{p:02d}"

count = Counter(o["district"] for o in orders)
total = defaultdict(int)                # নতুন চাবির শুরুর মান 0
for o in orders:
    total[o["district"]] += o["amount_paisa"]

rows = sorted(total.items(), key=itemgetter(1), reverse=True)
for name, paisa in rows:
    print(f"{name:<10}{count[name]:>3}টি {taka(paisa):>10}")
print("মোট:", taka(sum(total.values())))
print("সবচেয়ে বেশি অর্ডার:", count.most_common(2))

প্রথম সারি: {'order_id': 1001, 'district': 'ঢাকা', 'amount_paisa': 30200}
খুলনা       6টি  ৳7,063.50
চট্টগ্রাম   4টি  ৳6,659.00
ঢাকা        6টি  ৳6,124.00
সিলেট       2টি  ৳2,189.50
রাজশাহী     2টি  ৳2,039.50
মোট: ৳24,075.50
সবচেয়ে বেশি অর্ডার: [('ঢাকা', 6), ('খুলনা', 6)]

৪ · সাজানো, zip, enumerate আর unpacking

সাজানো — key= আসলে কী করে

ক্রিকেটের স্কোরকার্ডে ব্যাটারদের রান অনুযায়ী সাজাতে হলে প্রতিটি ব্যাটারের পুরো তথ্য নয়, শুধু “রান” ঘরটি তুলনা করতে হয়। sorted(rows, key=...)-এর key ঠিক এই কাজ করে: প্রতিটি সারি থেকে তুলনার একটি মান বের করার একটি function. Python প্রতিটি সারির জন্য key একবার হিসাব করে, তারপর শুধু সেই মানগুলো তুলনা করে।

from operator import itemgetter
by_amount = sorted(orders, key=itemgetter("amount_paisa"), reverse=True)
by_two    = sorted(orders, key=itemgetter("district", "amount_paisa"))
top3      = by_amount[:3]

itemgetter("amount_paisa") একটি তৈরি function, যা lambda o: o["amount_paisa"]-এর সমান কাজ করে, পড়তে একটু পরিষ্কার আর সামান্য দ্রুত। দুটি নাম দিলে সে একটি tuple ফেরত দেয়, তাই by_two আগে জেলা ধরে, জেলা সমান হলে টাকা ধরে সাজায়। মনে রাখার তিনটি কথা:

• sorted() নতুন list দেয়, list.sort() নিজের list বদলায় আর None ফেরত দেয়। x = rows.sort() লিখলে x-এ None থাকে; এটি খুব পরিচিত বাগ।
• Python-এর sort stable: সমান key-র সারিগুলো আগের ক্রমেই থাকে। তাই “জেলা ধরে, তার ভেতরে টাকা ধরে” চাইলে আগে টাকা ধরে সাজিয়ে তারপর জেলা ধরে সাজালেও একই ফল আসে।
• বাংলা শব্দ সাজালে ক্রম হয় Unicode code point ধরে, অভিধানের ক্রম নয়। ছোট তালিকায় প্রায়ই ঠিক দেখায়, কিন্তু যুক্তাক্ষর আর কার-চিহ্ন এলে অবাক করতে পারে। ভাষা মেনে সাজানোর (collation) জন্য আলাদা লাইব্রেরি লাগে।

zip, enumerate আর unpacking

zip(a, b) দুটি (বা বেশি) সংগ্রহকে চেইনের দাঁতের মতো জোড়ায় জোড়ায় মেলায়। কলামভিত্তিক ডেটা থেকে সারি বানাতে এটিই সবচেয়ে ছোট পথ, আর zip(*rows) উল্টো দিকে সারি থেকে কলাম বানায়:

cols = {"order_id": [1001, 1002, 1003],
        "district": ["ঢাকা", "রাজশাহী", "চট্টগ্রাম"],
        "amount_paisa": [30200, 120300, 77150]}
rows = [dict(zip(cols, vals)) for vals in zip(*cols.values())]
rows[1]   # {'order_id': 1002, 'district': 'রাজশাহী', 'amount_paisa': 120300}

for rank, (name, paisa) in enumerate(rows_sorted, start=1):
    print(rank, name, paisa)

শেষ লাইনে একসঙ্গে দুটি জিনিস: enumerate(..., start=1) প্রতিটি উপাদানের সঙ্গে ১ থেকে একটি ক্রমিক নম্বর দেয় (হাতে i = i + 1 লেখার দরকার নেই), আর (name, paisa) হলো unpacking: একটি জোড়ার দুই ঘরে আলাদা নাম বসানো। first, *rest = rows লিখলে প্রথমটি আলাদা, বাকি সব একটি list-এ। একটি সাবধানতা: zip সবচেয়ে ছোট সংগ্রহ শেষ হলেই থেমে যায়, কোনো সতর্কবার্তা ছাড়া। দুটি কলামের দৈর্ঘ্য না মিললে শেষের সারিগুলো চুপচাপ হারায়। Python 3.10 থেকে zip(a, b, strict=True) লিখলে দৈর্ঘ্য না মিললে ValueError হয়; ডেটার কাজে এটিই নিরাপদ। Unpacking-এর পুরো নিয়ম আছে tuple আর unpacking পর্বে।

৫ · Function — স্পষ্ট input-output, default আর mutable default-এর ফাঁদ

ডেটার কাজে একটি ভালো function দেখতে রান্নার রেসিপির মতো: কী কী উপকরণ লাগবে (input), শেষে কী পাবেন (output), আর রান্নাঘরের বাইরে কিছু বদলাবে না। যে function শুধু input দেখে output দেয়, বাইরের কোনো variable বদলায় না, তাকে বলে pure function. একই input-এ সবসময় একই output, তাই পরীক্ষা করা সহজ, notebook-এর cell আগে-পরে চালালেও ফল বদলায় না।

def district_totals(orders, key="district"):
    """প্রতিটি দলের মোট পয়সা; orders বদলায় না।"""
    total = defaultdict(int)
    for o in orders:
        total[o[key]] += o["amount_paisa"]
    return dict(total)

এখানে key="district" একটি default argument: না দিলে জেলা ধরে দল হয়, চাইলে district_totals(orders, key="payment") লিখে অন্য কলাম ধরেও দল করা যায়। ফেরত দেওয়ার আগে dict(total) করা হয়েছে, যাতে বাইরে কেউ ভুল চাবি পড়লে চুপচাপ নতুন 0 তৈরি না হয়। Function-এর ভেতরের যন্ত্র (call stack, keyword argument, docstring, type hint) আছে Python কোর্সের ফাংশন পর্বে; type hint আর ছোট test দিয়ে AI-এর কোড পরিচ্ছন্ন রাখা আসবে পর্ব ১১-এ।

যে ফাঁদে অভিজ্ঞরাও পড়েন — mutable default

Python-এ default মান তৈরি হয় একবার, যখন def লাইনটি চলে; প্রতিটি call-এ নতুন করে নয়। default যদি একটি সংখ্যা বা string হয়, তাতে সমস্যা নেই, কারণ এগুলো বদলানো যায় না। কিন্তু default যদি একটি list বা dict হয় (যা বদলানো যায়, অর্থাৎ mutable), তাহলে সব call একই list ভাগ করে নেয়। একে বলে mutable default argument-এর ফাঁদ। ধাপে ধাপে দেখুন।

1def add_item(item, basket=[]):2    basket.append(item)3    return basket4a = add_item("চাল")5b = add_item("ডাল")6c = add_item("তেল", [])7d = add_item("লবণ")

সমাধানটি ছোট আর প্রচলিত: default হিসেবে None দিন, আর function-এর ভেতরে None পেলে নতুন list বানান। নিচের কোডে ফাঁদ আর সমাধান পাশাপাশি চালিয়ে দেখুন; __defaults__ দেখায় function-এর গায়ে জমা থাকা default মান।

def add_item(item, basket=[]):          # ফাঁদ: default list একবারই তৈরি হয়
    basket.append(item)
    return basket

a = add_item("চাল")
b = add_item("ডাল")
print("a =", a)
print("b =", b, "| a is b:", a is b)
print("লুকানো default:", add_item.__defaults__)


def add_item_safe(item, basket=None):   # সমাধান: None, তারপর ভেতরে নতুন list
    if basket is None:
        basket = []
    basket.append(item)
    return basket

c = add_item_safe("চাল")
d = add_item_safe("ডাল")
print("c =", c, "| d =", d, "| c is d:", c is d)
print("নিরাপদ default:", add_item_safe.__defaults__)

a = ['চাল', 'ডাল']
b = ['চাল', 'ডাল'] | a is b: True
লুকানো default: (['চাল', 'ডাল'],)
c = ['চাল'] | d = ['ডাল'] | c is d: False
নিরাপদ default: (None,)

lambda — কখন হ্যাঁ, কখন না

lambda হলো নামহীন, এক expression-এর ছোট function: lambda o: o["amount_paisa"]. এর সবচেয়ে ভালো জায়গা হলো অন্য function-কে এক লাইনের নিয়ম দেওয়া, যেমন sorted(..., key=lambda o: (o["district"], -o["amount_paisa"])): জেলা ধরে ছোট থেকে বড়, তার ভেতরে টাকা বড় থেকে ছোট। কিন্তু তিন জায়গায় lambda এড়িয়ে চলুন:

• নাম দিয়ে রাখতে চাইলে: fee = lambda p: p * 2 // 100 না লিখে def fee(p): লিখুন। Error-এর বার্তায় তখন function-এর আসল নাম আসে, <lambda> নয়, আর docstring লেখা যায়। PEP 8 (Python-এর লেখার নিয়ম) নিজেই এটি বলে।
• নিয়ম একটি expression-এ ধরে না: lambda-তে শর্ত-শাখা, loop বা একাধিক লাইন চলে না। ঠেসে লিখলে কেউ পড়তে পারবে না।
• তৈরি function আছে: itemgetter, attrgetter, len, str.lower সরাসরি key হিসেবে দেওয়া যায়।

৬ · Generator — বড় ফাইল একটি একটি সারি করে

বাজারঘরের এক বছরের অর্ডারের ফাইল হতে পারে কয়েক কোটি সারির। পুরোটা একটি list-এ তুলে ফেললে ল্যাপটপের মেমরি ফুরিয়ে যেতে পারে। অথচ অনেক প্রশ্নের জন্য পুরো ফাইল একসঙ্গে লাগেই না; “ঢাকার মোট বিক্রি কত” জানতে একটি একটি সারি দেখে যোগ করে গেলেই হয়। টিকিট কাউন্টারের লাইনের মতো: সবাই একসঙ্গে নয়, একজন একজন করে জানালায় আসেন।

Generator হলো এমন একটি function, যা return-এর বদলে yield দিয়ে একটি একটি মান দেয়, আর প্রতিটি মান দেওয়ার পর থেমে থাকে যতক্ষণ না পরের মান চাওয়া হয়। একে বলে lazy evaluation: কাজ হয় শুধু দরকারের মুহূর্তে। Python-এর ফাইল object নিজেই lazy: for line in f একবারে একটি লাইন পড়ে। নিচের কোডে একটি বড় CSV ফাইলের বদলে মেমরিতে বানানো এক লাখ সারির লেখা ব্যবহার করা হয়েছে, আর io.StringIO সেই লেখাকে ঠিক একটি খোলা ফাইলের মতো আচরণ করায়।

import io, sys, random

# বড় CSV ফাইলের বদলে মেমরিতে বানানো লেখা: ১,০০,০০০ সারি
rng = random.Random(7)
districts = ["ঢাকা", "চট্টগ্রাম", "খুলনা"]
lines = ["order_id,district,amount_paisa"]
for i in range(100_000):
    lines.append(f"{i},{rng.choice(districts)},{rng.randrange(20_000, 300_000)}")
csv_text = "\n".join(lines) + "\n"

def read_all(f):                    # সব সারি একসঙ্গে list-এ
    next(f)                         # header বাদ
    return [line.rstrip("\n").split(",") for line in f]

def read_lazy(f):                   # generator: চাইলে তবেই পরের সারি
    next(f)
    for line in f:
        yield line.rstrip("\n").split(",")

all_rows = read_all(io.StringIO(csv_text))      # ফাইলের মতোই পড়া যায়
lazy_rows = read_lazy(io.StringIO(csv_text))
print("list:     ", sys.getsizeof(all_rows), "bytes,", len(all_rows), "সারি")
print("generator:", sys.getsizeof(lazy_rows), "bytes")
print("প্রথম সারি:", next(lazy_rows))
print("দ্বিতীয় সারি:", next(lazy_rows))

dhaka = sum(int(r[2]) for r in read_lazy(io.StringIO(csv_text))
            if r[1] == "ঢাকা")
print("ঢাকার মোট:", dhaka, "পয়সা")

list:      400492 bytes, 100000 সারি
generator: 108 bytes
প্রথম সারি: ['0', 'চট্টগ্রাম', '99088']
দ্বিতীয় সারি: ['1', 'চট্টগ্রাম', '45315']
ঢাকার মোট: 5371261249 পয়সা

৭ · dataclass — রেকর্ডের নাম-দেওয়া ছাঁচ

dict দিয়ে রেকর্ড রাখা সহজ, কিন্তু একটি দুর্বলতা আছে: বানান ভুল কেউ ধরে না। o["ammount_paisa"] লিখলে প্রোগ্রাম চলার সময় KeyError, আর o.get("ammount_paisa", 0) লিখলে আরও খারাপ: চুপচাপ 0. রেকর্ডের ধরন যখন স্থির (প্রতিটি অর্ডারে একই চারটি ঘর), তখন dataclass একটি পরিষ্কার ছাঁচ দেয়। ছাপানো ফর্মের মতো: কোন ঘরে কী লিখতে হবে, আগে থেকেই ছাপা।

from dataclasses import dataclass, field, asdict

@dataclass
class Order:
    order_id: int
    district: str
    amount_paisa: int
    items: list[str] = field(default_factory=list)

o = Order(101, "ঢাকা", 125050)
print(o)
print(o == Order(101, "ঢাকা", 125050))
print(asdict(o))

@dataclass
class Bad:
    items: list = []          # mutable default — dataclass নিজেই আটকায়

এই পর্বের লেখার সময় Python 3.14.4 দিয়ে নিজের যন্ত্রে সত্যিকারের run-এর আউটপুট (শেষ লাইনটি Bad class-এর সংজ্ঞা থেকে আসা error, try/except দিয়ে ধরে ছাপানো):

Order(order_id=101, district='ঢাকা', amount_paisa=125050, items=[])
True
{'order_id': 101, 'district': 'ঢাকা', 'amount_paisa': 125050, 'items': []}
ValueError: mutable default <class 'list'> for field items is not allowed: use default_factory

@dataclass চারটি ঘরের নাম আর type hint দেখে নিজেই __init__ (তৈরি করার function), পড়ার মতো ছাপা (__repr__) আর তুলনা (__eq__) লিখে দেয়। asdict আবার dict-এ ফেরায়, যাতে JSON বা pandas-এ পাঠানো যায়। আর অংশ ৫-এর ফাঁদটি এখানে আর ঘটতেই পারে না: list default দিলে dataclass class তৈরির মুহূর্তেই ValueError দিয়ে default_factory ব্যবহার করতে বলে, যা প্রতিটি নতুন অর্ডারের জন্য আলাদা নতুন list বানায়।

দুটি সতর্কতা। প্রথমত, type hint শুধু তথ্য; Order("১০১", 5, "অনেক") লিখলেও Python আপত্তি করে না। যাচাই চাইলে __post_init__-এ নিজে লিখতে হয়, বা mypy-এর মতো type checker চালাতে হয় (পর্ব ১১)। দ্বিতীয়ত, লক্ষ লক্ষ সারির সংখ্যার হিসাবে প্রতিটি সারিকে একটি Python object বানানো ধীর আর মেমরি-খরুচে; সেখানে কলামভিত্তিক NumPy বা pandas-ই ঠিক টুল। frozen=True (বদলানো যায় না এমন রেকর্ড), slots=True (কম মেমরি) আর property-র কথা আছে Python কোর্সের property আর dataclass পর্বে।

৮ · সংখ্যা আর লেখার ফাঁদ — float, পয়সা, Decimal আর বাংলা string

কেন 0.1 + 0.2 ঠিক 0.3 নয়

১ কে ৩ দিয়ে ভাগ করলে দশমিকে লিখতে হয় 0.3333…, কোথাও না কোথাও থামতে হয়, তাই একটু ভুল থেকেই যায়। কম্পিউটারের floating-point সংখ্যা (Python-এর float) দশমিকে নয়, দুইয়ের ভিত্তিতে (binary) লেখা। আর binary-তে 0.1 ঠিক তেমনই অসীম ভগ্নাংশ, যেমন দশমিকে ১/৩। তাই 0.1 আসলে জমা থাকে 0.1-এর খুব কাছের একটি সংখ্যা হিসেবে, আর দুটি কাছাকাছি সংখ্যা যোগ করলে ফলও শুধু “কাছাকাছি”।

import math
from decimal import Decimal, ROUND_HALF_UP

print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)
print(math.isclose(0.1 + 0.2, 0.3))
print(f"{0.1:.20f}")
print(round(2.675, 2))
print(Decimal("0.1") + Decimal("0.2"))
print(Decimal(0.1))
print(Decimal("2.675").quantize(Decimal("0.01"), rounding=ROUND_HALF_UP))

Python 3.14.4 দিয়ে সত্যিকারের run-এর আউটপুট:

0.30000000000000004
False
True
0.10000000000000000555
2.67
0.3
0.1000000000000000055511151231257827021181583404541015625
2.68

• দুটি float কখনো == দিয়ে তুলনা নয়। math.isclose(a, b) দেখে দুটি সংখ্যা আপেক্ষিকভাবে খুব কাছাকাছি কি না (default সহনশীলতা প্রায় ১০^−৯ ভাগ)। শূন্যের কাছের সংখ্যা তুলনা করলে abs_tol-ও দিতে হয়, কারণ আপেক্ষিক সহনশীলতা শূন্যের কাছে প্রায় কিছুই ছাড় দেয় না।
• round(2.675, 2) কেন 2.67? কারণ 2.675 আসলে জমা আছে 2.67499999…-এর মতো একটি সংখ্যা হিসেবে। তার ওপর Python-এর round ঠিক মাঝখানের মানে জোড় সংখ্যার দিকে যায় (round(2.5) হলো 2, round(3.5) হলো 4), যাকে banker's rounding বলে।
• Decimal(0.1) বনাম Decimal("0.1"): float থেকে বানালে float-এর ভুলটিই হুবহু চলে আসে, ৫৫ অঙ্ক পর্যন্ত। Decimal সবসময় string থেকে বানান।

টাকা রাখুন পূর্ণসংখ্যার পয়সায়

এ কারণেই এই কোর্সে বাজারঘরের সব দাম amount_paisa, একটি int. Python-এর int যত বড় চান তত বড় হয়, আর পূর্ণসংখ্যার যোগ-বিয়োগে কোনো গোলমাল নেই: ১৯.৯৯ + ২৫.৫০ + ০.১০ টাকা হলো 1999 + 2550 + 10 = 4559 পয়সা, ঠিক ৳45.59. ভাগ বা শতাংশ এলে (১৫% ছাড়, তিন কিস্তিতে ভাগ) কোথায় round করবেন তা আগে থেকে ঠিক করুন, আর ভাগশেষের পয়সা কার ভাগে যাবে তা-ও: ১০০০ পয়সা তিন ভাগে 333 + 333 + 334, মোট যেন ঠিক 1000 থাকে। হিসাবের নিয়ম আইন বা চুক্তিতে লেখা থাকলে (ভ্যাট, সুদ) Decimal আর তার rounding নিয়ম ব্যবহার করুন। মেশিন লার্নিং-এর feature হিসেবে অবশ্য float-ই স্বাভাবিক; সেখানে প্রশ্নটি হিসাবের পাই-পয়সা নয়, মডেলের অনুমান। পুরো আলোচনা আছে সংখ্যা ও হিসাব পর্বে।

বাংলা string — len() অক্ষর গোনে না

Python-এর string হলো Unicode code point-এর সারি। ইংরেজিতে একটি code point প্রায় সবসময় চোখে দেখা একটি অক্ষর। বাংলায় তা নয়: “বা” হলো দুটি code point (ব + া-কার), আর “ক্ষ” তিনটি (ক + হসন্ত + ষ)। চোখে যে একককে আমরা একটি অক্ষর বলি, Unicode-এর ভাষায় তা grapheme cluster. Python-এর standard library এটি গুনতে পারে না; তৃতীয় পক্ষের regex package-এর \X পারে।

import regex, unicodedata
for w in ["বাজারঘর", "ক্ষমা", "কৃষ্ণ", "রাজশাহী"]:
    print(w, len(w), len(regex.findall(r"\X", w)))

a = "ড়"            # ড় — একটি code point
b = "ড়"      # ড + নুক্তা — দুটি code point
print(a == b, len(a), len(b))
def nfc(s):
    return unicodedata.normalize("NFC", s)
print(nfc(a) == nfc(b))

Python 3.14.4 আর regex 2026.9.29 দিয়ে সত্যিকারের run-এর আউটপুট (প্রতিটি শব্দ, তারপর code point-এর সংখ্যা, তারপর grapheme-এর সংখ্যা):

বাজারঘর 7 5
ক্ষমা 5 2
কৃষ্ণ 5 2
রাজশাহী 7 4
False 1 2
True

“বাজারঘর” চোখে পাঁচটি অক্ষর (বা, জা, র, ঘ, র), কিন্তু len বলে ৭। এর ফল বাস্তবে: “নাম ২০ অক্ষরের বেশি হবে না” নিয়ম len দিয়ে লিখলে বাংলা নাম অকারণে আটকে যায়; লেখা মাঝখান থেকে কাটলে (name[:4]) একটি কার-চিহ্ন বা হসন্ত একা ঝুলে থাকতে পারে; আর অংশ ৩-এর ছাপায় সারি সমান দেখায় না। নতুন Unicode নিয়মে (সংস্করণ ১৫.১, ২০২৩ থেকে) বাংলার যুক্তাক্ষরও একটি grapheme ধরা হয়, তাই পুরোনো লাইব্রেরি “ক্ষমা”-কে ৩ বলতে পারে। আর শেষ দুই লাইন আরও বড় ফাঁদ দেখায়: “ড়” একটি code point দিয়েও লেখা যায়, দুটি দিয়েও; পর্দায় হুবহু এক, কিন্তু == বলে আলাদা। দুই জায়গা থেকে আসা ডেটায় একই জেলার নাম দুই রূপে থাকলে Counter সেটিকে দুটি জেলা গুনবে। সমাধান হলো তুলনার আগে Unicode normalization (সাধারণত NFC). ফাইলের encoding আর normalization পর্ব ১০-এর বিষয়, আর pandas-এ বাংলা লেখা পরিষ্কার পর্ব ২৩-এর; string-এর ভেতরের খুঁটিনাটি আছে Python কোর্সের string পর্বে।

৯ · কেন Python loop সংখ্যায় ধীর — আর NumPy কী বদলায়

এই পর্বের সব হাতিয়ার কয়েক হাজার, এমনকি কয়েক লাখ রেকর্ডে স্বচ্ছন্দে চলে। কিন্তু যখন কাজটি হলো লক্ষ লক্ষ সংখ্যার ওপর একই হিসাব (প্রতিটি দামকে বর্গ করা, প্রতিটি pixel-কে ২ দিয়ে গুণ করা), তখন Python-এর for loop ধীর হয়ে পড়ে। কারণটি বুঝতে নিচের ছবি দেখুন।

Python-এর loop-এ প্রতিটি s += x * x-এর জন্য interpreter-কে কয়েকটি কাজ করতে হয়: x কোন type-এর তা দেখা, সেই type-এর গুণের নিয়ম খোঁজা, ফলের জন্য নতুন একটি int object বানানো, পুরোনোটি ফেলে দেওয়া। আসল গুণটি এক মুহূর্তের; বাকিটা হিসাবনিকাশের খরচ। NumPy-তে পুরো array-এর জন্য এই যাচাই একবার হয়, তারপর C-এর একটি টানা loop সংখ্যাগুলোর ওপর চলে। একে বলে vectorization. চলুন সত্যিই মাপি, time.perf_counter() দিয়ে, যা ছোট সময় মাপার জন্য সবচেয়ে সূক্ষ্ম ঘড়ি। প্রথমবার NumPy নামাতে কয়েক সেকেন্ড লাগতে পারে।

import time
import numpy as np

n = 1_000_000
data = list(range(n))                     # Python list: ১০ লাখ int object
arr = np.arange(n, dtype=np.int64)        # NumPy array: এক টানা মেমরি

t0 = time.perf_counter()
s_loop = 0
for x in data:                            # প্রতিটি ধাপে Python নিজে কাজ করে
    s_loop += x * x
t1 = time.perf_counter()
s_np = int(np.dot(arr, arr))              # পুরো লুপ C-এর ভেতরে
t2 = time.perf_counter()

print("ফল মিলেছে:", s_loop == s_np, s_np)
print(f"Python loop: {(t1 - t0) * 1000:8.1f} ms")
print(f"NumPy dot  : {(t2 - t1) * 1000:8.1f} ms")
print(f"অনুপাত প্রায় {(t1 - t0) / (t2 - t1):.0f} গুণ")
print("dtype না বললে:", np.arange(3).dtype)

ফল মিলেছে: True 333332833333500000
Python loop:    126.0 ms
NumPy dot  :      2.6 ms
অনুপাত প্রায় 48 গুণ
dtype না বললে: int32

এখান থেকে তিনটি শিক্ষা পরের মডিউলে বারবার কাজে লাগবে। এক, সংখ্যার বড় কলামের ওপর হিসাব হলে list আর loop নয়, array. দুই, NumPy-তে dtype নিজে বেছে নেওয়া একটি সিদ্ধান্ত: int64-এর সীমা প্রায় ৯.২ × ১০^১৮, তার বেশি হলে NumPy Python-এর মতো বড় হয় না, চুপচাপ উপচে পড়ে (overflow). তিন, সব কাজ vectorize করা যায় না, আর সবসময় করার দরকারও নেই; ১০০টি অর্ডারের জন্য সাধারণ loop-ই যথেষ্ট আর পরিষ্কার। Array-এর shape আর dtype আসবে পর্ব ১৩-এ, vectorization আর broadcasting পর্ব ১৫-এ, আর কখন loop-ই ঠিক তা পর্ব ১৯-এ। মাপজোকের সাধারণ নিয়ম আছে Python কোর্সের পারফরম্যান্স পর্বে।

১০ · AI-এর যুগে — AI সহকারীর লেখা ডেটা-কোড যাচাই

“এই অর্ডারগুলো জেলা ধরে যোগ করো” লিখলে একটি AI সহকারী কয়েক সেকেন্ডে কোড দেবে, আর বেশির ভাগ সময় তা চলবেও। সমস্যা হলো, এমন কোড চলেও ভুল ফল দিতে পারে, আর ভুলগুলো প্রায়ই এই পর্বের বিষয়গুলোতেই। AI সহকারীরা প্রায়ই যা করে:

• টাকা float-এ রাখে আর == দিয়ে তুলনা করে; default হিসেবে [] বা {} বসায়; zip-এ দৈর্ঘ্য না মেলার কথা ভাবে না।
• পুরোনো বা বানানো API লেখে: pandas-এ সরিয়ে দেওয়া DataFrame.append, NumPy 2-এ সরানো np.float বা np.int, বা এমন parameter যা আপনার version-এ নেই।
• বাংলা নামের দৈর্ঘ্য len দিয়ে মাপে, normalization ছাড়াই নাম মেলায়, আর except: pass বা warnings.filterwarnings("ignore") দিয়ে error আর সতর্কবার্তা চাপা দেয়।
• বিশ্বাসযোগ্য শোনায় এমন কিন্তু না-মাপা দাবি করে (“এটি ১০ গুণ দ্রুত”), আর পরে মডেল বানানোর সময় test ডেটা train-এ মিশিয়ে ফেলে বা train ডেটাতেই মাপা ফল দেখায়।

AI-এর কোড হাতে পেলে — যাচাইয়ের চেকলিস্ট

• নিজে চালিয়েছি, আর ৩–৫টি সারির ফল হাতে হিসাব করে মিলিয়েছি
• টাকা পূর্ণসংখ্যার পয়সায় বা Decimal-এ; কোথাও দুটি float == দিয়ে তুলনা হয়নি
• কোনো default argument-এ [], {} বা set() নেই; function-টি input-এর list বদলায় না
• সমান মানের (tie) ক্ষেত্রে আর খালি ডেটায় কী হয়, দেখেছি; zip-এ strict=True বা দৈর্ঘ্যের যাচাই আছে
• নিজের Python, NumPy আর pandas version-এর অফিসিয়াল docs-এ প্রতিটি অচেনা function আর parameter মিলিয়েছি
• গতির দাবি নিজে time.perf_counter দিয়ে মেপেছি; কোনো warning লুকানো হয়নি; ক্রেতার নাম-ফোন-ঠিকানার মতো আসল ডেটা AI-তে পেস্ট করিনি