dunder method — Python-এর data model

১ · len(x), x + y, print(x) — আসলে object-এর কাছে অনুরোধ

পর্ব ২৯-এ আপনি নিজের class বানিয়েছেন — __init__ দিয়ে object তৈরি, self দিয়ে তার নিজের ডেটা। সেখানে __repr__-এর এক ঝলকও দেখেছেন। কিন্তু বেশিরভাগ ক্ষেত্রে নিজের object এখনো “পর” লাগে। __repr__ না লিখলে print করলে একটি অস্পষ্ট লেখা আসে, যাতে class-এর নাম আর একটি মেমরি-ঠিকানা থাকে — ব্যবহারকারীর কোনো কাজে আসে না। দুটি object যোগ করতে চাইলে TypeError. দুটি একই রকম object-কে == দিয়ে তুলনা করলে False. অথচ Python-এর নিজের int, str, list এসব কাজ অনায়াসে করে। পার্থক্যটা কোথায়?

পার্থক্যটা কোনো জাদু নয়। Python-এর প্রতিটি বিশেষ syntax আসলে একটি নির্দিষ্ট নামের method-এর ডাক। আপনি যখন লেখেন len(playlist), Python আসলে করে type(playlist).__len__(playlist). a + b লিখলে করে type(a).__add__(a, b). print(x) লিখলে x-এর __str__ ডেকে লেখাটি আনে। এই বিশেষ method-গুলোর নামের দুই পাশে দুটি করে আন্ডারস্কোর থাকে, তাই এদের ডাকনাম dunder method — “double underscore”-এর সংক্ষেপ। অফিসিয়াল নাম special method; কেউ কেউ “magic method”-ও বলেন। পর্ব ১৯-এ +=-এর আচরণ বোঝাতে __iadd__-এর নাম এসেছিল, আর পর্ব ২৯-এ __init__ তো আপনি নিজেই লিখেছেন — দুটিই dunder.

এই অনুবাদের একটি ছোট তালিকা দেখুন। পুরো তালিকা অনেক বড় — Python-এর অফিসিয়াল Language Reference-এ “Data model” নামের একটি গোটা অধ্যায় এর জন্য — কিন্তু প্রতিদিনের কাজে এগুলোই লাগে:

একটি জরুরি সতর্কতা: dunder method আপনি নিজে সাধারণত ডাকবেন না. লিখবেন len(x), x.__len__() নয়; লিখবেন a + b, a.__add__(b) নয়। কারণ built-in ফাংশন আর operator শুধু dunder ডাকে না, তার চারপাশে বাড়তি কাজও করে — যেমন len() নিশ্চিত করে যে ফল অঋণাত্মক পূর্ণসংখ্যা, আর + দরকার হলে অন্য পক্ষের __radd__ চেষ্টা করে (অংশ ৫)। Dunder method হলো Python-এর জন্য লেখা, আপনার ডাকার জন্য নয়। আরেকটি নিয়ম: নিজে নতুন dunder নাম (__mything__) বানাবেন না — এই নামগুলো Python-এর নিজের জন্য সংরক্ষিত।

২ · নিজের চেহারা — __repr__ আর __str__

এই পর্বজুড়ে একটি বাস্তব class গড়ে তুলব: টাকার হিসাব রাখার Money. পর্ব ০৭-এ দেখেছিলেন, 0.1 + 0.2 ঠিক 0.3 হয় না — তাই টাকা float-এ রাখা বিপজ্জনক। bKash, ব্যাংক বা যেকোনো হিসাবের সফটওয়্যার সাধারণত সবচেয়ে ছোট একক — পয়সা — পূর্ণসংখ্যায় রাখে। Money(125050) মানে ১,২৫০ টাকা ৫০ পয়সা।

এমন একটি object-এর দুটি আলাদা “চেহারা” দরকার, কারণ দুই রকম মানুষ তাকে দেখে:

• __repr__ — ডেভেলপারের জন্য। ডিবাগ করার সময়, লগে, REPL-এ। লক্ষ্য: দ্ব্যর্থহীন — দেখেই বোঝা যাবে এটি কোন type, ভেতরে ঠিক কী। সম্ভব হলে এমনভাবে লিখুন যাতে লেখাটি কপি করে Python-এ বসালে একই object তৈরি হয়: Money(125050). একে বলে “eval-যোগ্য” repr, কারণ eval() সেটিকে আবার object বানাতে পারত (যদিও বাস্তবে আমরা eval ব্যবহার করি না)।
• __str__ — ব্যবহারকারীর জন্য। রসিদে, স্ক্রিনে, মেসেজে। লক্ষ্য: পড়তে সুন্দর — ৳1,250.50. এখানে type-এর নাম দরকার নেই।

class Money:
    def __init__(self, poisha: int):
        self.poisha = poisha

    def __repr__(self):                      # ডেভেলপারের জন্য
        return f"Money({self.poisha})"

    def __str__(self):                       # ব্যবহারকারীর জন্য
        return f"৳{self.poisha // 100:,}.{self.poisha % 100:02d}"

__str__-এ পর্ব ১০-এর format spec কাজে লেগেছে: :, হাজারের কমা বসায়, :02d পয়সাকে দুই অঙ্কে রাখে (৫ পয়সা হলে .05). এবার দেখুন কোন পরিস্থিতিতে Python কোনটি ডাকে। “পরে” চাপুন:

1m = Money(125050)2print(m)3m                     # REPL-এ লিখলে4print([m, Money(99)])5print(f"{m} / {m!r}")6# __str__ মুছে দিলে: print(m)

৩ · সমান মানে কী? — __eq__ আর __hash__-এর চুক্তি

পর্ব ০৮-এ দেখেছিলেন is আর == আলাদা: is জিজ্ঞেস করে “একই object?” (identity), == জিজ্ঞেস করে “একই মান?” (equality). কিন্তু “একই মান” মানে কী, তা Python জানবে কীভাবে? আপনার Money-র কোন অংশ মিললে দুটি object সমান? এই প্রশ্নের উত্তর দেয় __eq__. আপনি না লিখলে object-এর ডিফল্ট __eq__ কাজ করে, যা শুধু identity দেখে — অর্থাৎ Money(500) == Money(500) হয় False, কারণ দুটি আলাদা object.

    def __eq__(self, other):
        if not isinstance(other, Money):
            return NotImplemented            # “আমি জানি না” — error নয়
        return self.poisha == other.poisha

লক্ষ করুন, অচেনা type পেলে আমরা False ফেরত দিইনি, NotImplemented দিয়েছি। এর রহস্য অংশ ৪-এ। আপাতত আরেকটি অদ্ভুত ঘটনা — যা AI-এর লেখা কোডে সবচেয়ে বেশি দেখা যায়। __eq__ লেখার সাথে সাথে আপনার object set-এ রাখা যায় না! কেন, তা ধাপে ধাপে দেখুন:

1a, b = Money(500), Money(500)2print(a == b, len({a, b}))3# class-এ __eq__ যোগ করা হলো4print(Money.__hash__)5s = {a, b}6# __hash__ যোগ: hash(self.poisha)7print(a == b, len({a, b}))8s = {a}; a.poisha = 7009print(a in s)

৪ · ছোট-বড় — __lt__, total_ordering আর NotImplemented

== ছাড়াও তুলনার আরও পাঁচটি operator আছে: !=, <, <=, >, >=. এদের dunder যথাক্রমে __ne__, __lt__ (less than), __le__, __gt__, __ge__. এই ছয়টিকে একসাথে বলে rich comparison. sorted(), min(), max(), list.sort() — সবাই ভেতরে < ব্যবহার করে। তাই __lt__ লিখলেই আপনার object সাজানো যায়।

একটি তাপমাত্রার class দেখুন — আবহাওয়া অ্যাপের জন্য, যেখানে বিভিন্ন জেলার তাপমাত্রা সাজাতে হবে। ছয়টি method হাতে লেখা ক্লান্তিকর আর ভুলপ্রবণ। functools module-এর total_ordering decorator এই কাজ সহজ করে: আপনি শুধু __eq__ আর একটি (যেমন __lt__) লিখুন, বাকি তিনটি সে নিজে বানিয়ে দেবে (__ne__ তো Python এমনিতেই __eq__ থেকে বের করে):

from functools import total_ordering

@total_ordering
class Temperature:
    def __init__(self, celsius: float):
        self.celsius = celsius
    def __repr__(self):
        return f"Temperature({self.celsius})"
    def __eq__(self, other):
        if not isinstance(other, Temperature):
            return NotImplemented
        return self.celsius == other.celsius
    def __lt__(self, other):
        if not isinstance(other, Temperature):
            return NotImplemented
        return self.celsius < other.celsius

days = [Temperature(30), Temperature(-2), Temperature(18)]
print(sorted(days), max(days), Temperature(5) >= Temperature(5))
# [Temperature(-2), Temperature(18), Temperature(30)] Temperature(30) True

এখানে __ge__ আমরা লিখিনি, তবু >= কাজ করল — total_ordering সেটি __lt__ আর __eq__ থেকে বানিয়েছে। functools.total_ordering Python 3.2 থেকে আছে। একটি ছোট দাম আছে: বানানো method-গুলো এক ধাপ ঘুরে কাজ করে, তাই হাতে লেখা method-এর চেয়ে সামান্য ধীর — লাখো তুলনার সময়ই শুধু চোখে পড়ে।

NotImplemented — “আমি জানি না, অন্যজনকে জিজ্ঞেস করো”

এবার সেই রহস্য। Temperature(30) < 25 লিখলে কী হওয়া উচিত? ২৫ কি সেলসিয়াস, নাকি ফারেনহাইট? আমাদের class জানে না। তিনটি সম্ভাব্য উত্তর:

• False ফেরত দেওয়া — মিথ্যা কথা। ভুল তুলনা নিঃশব্দে পার হয়ে যায়।
• নিজে raise TypeError — অন্য পক্ষকে সুযোগই দেওয়া হলো না। হয়তো অন্য type-টি আপনার class চেনে আর তুলনা করতে জানে।
• NotImplemented ফেরত দেওয়া — সঠিক পথ। এটি একটি বিশেষ built-in মান (একটি singleton, None-এর মতো), যার মানে: “এই type-এর সাথে কাজটা আমি জানি না।” Python তখন অন্য পক্ষের উল্টো method চেষ্টা করে — a < b-এর জন্য b.__gt__(a). দুজনেই NotImplemented দিলে তবেই Python নিজে TypeError: '<' not supported between instances of 'Temperature' and 'int' তোলে — পরিষ্কার, সৎ বার্তা।

আরেকটি সূক্ষ্ম ফাঁদ: NotImplemented-কে কখনো if-এ সত্য-মিথ্যা হিসেবে ব্যবহার করবেন না। Python 3.9 থেকে এতে সতর্কবার্তা আসত, আর Python 3.14-এ এটি সরাসরি TypeError. তাই if self.__eq__(other): জাতীয় কোড — যা NotImplemented ফেরত পেতে পারে — এখন ভেঙে যায়। আবারও সেই নিয়ম: dunder নিজে না ডেকে == লিখুন।

৫ · অঙ্কের operator — __add__, __radd__, __iadd__, __mul__

নিজের class-এ +, -, *-এর মতো operator-এর অর্থ দেওয়াকে বলে operator overloading. Money + Money এর আদর্শ উদাহরণ: দুটি টাকা যোগ করলে টাকা — অর্থ স্বতঃস্পষ্ট। __add__ একটি নতুন object ফেরত দেয়, কোনো পক্ষকে বদলায় না — ঠিক যেমন 3 + 4 লিখলে 3 বদলে যায় না।

কিন্তু a + b-এ যদি a আপনার object না হয়? যেমন 0 + m. বাঁ পাশে int, যে Money-র নামও শোনেনি। এখানেই NotImplemented আর reflected method-এর খেলা। __radd__-এর r মানে reflected বা right — “আমি ডান পাশে আছি, বাঁ পাশের জন যোগ করতে পারেনি”। Python-এর সিদ্ধান্তের পথ ধাপে ধাপে দেখুন:

1m = Money(2000)2m + Money(99)30 + m4"৳" + m

একটি বিশেষ নিয়ম জেনে রাখুন: ডান পাশের object যদি বাঁ পাশের type-এর subclass হয় আর নিজের __radd__ দেয়, তাহলে Python তার __radd__-কে আগে সুযোগ দেয়। এতে subclass তার parent-এর আচরণ ঠিক করে নিতে পারে (পর্ব ৩১-এ inheritance).

sum() কেন __radd__ চায়

বাস্তবে 0 + m কেউ লেখে না। কিন্তু sum(bill) সবাই লেখে — আর sum() ভেতরে ঠিক এটাই করে। পর্ব ১২-এর accumulator ধাঁচ মনে করুন: sum() একটি শুরুর মান নেয়, যার ডিফল্ট 0, তারপর একে একে যোগ করে:

1bill = [Money(125050), Money(2000), Money(99)]2total = 0                  # sum()-এর start3for m in bill:4    total = total + m5print(total)

এবার এ পর্যন্ত সব একসাথে — একটি সম্পূর্ণ Money. চালানোর আগে অনুমান করুন: দ্বিতীয় লাইনে set-এর দৈর্ঘ্য কত হবে?

class Money:
    def __init__(self, poisha: int):
        self.poisha = poisha              # পয়সায় int, float নয়
    def __repr__(self):
        return f"Money({self.poisha})"
    def __str__(self):
        return f"৳{self.poisha // 100:,}.{self.poisha % 100:02d}"
    def __eq__(self, other):
        if not isinstance(other, Money):
            return NotImplemented
        return self.poisha == other.poisha
    def __hash__(self):                   # == হলে hash-ও সমান
        return hash(self.poisha)
    def __add__(self, other):
        if not isinstance(other, Money):
            return NotImplemented
        return Money(self.poisha + other.poisha)
    def __radd__(self, other):            # sum() শুরু করে 0 দিয়ে
        return self if other == 0 else NotImplemented
bill = [Money(125050), Money(2000), Money(99)]
print(bill, sum(bill), f"{sum(bill)!r}")
print(Money(500) == Money(500), len({Money(500), Money(500)}))

__iadd__ বনাম __add__, আর সংখ্যা দিয়ে গুণ

total += m লিখলে Python প্রথমে খোঁজে __iadd__ (in-place add). এটি থাকলে object-টিকে নিজের জায়গায় বদলাতে পারে, তারপর নিজেকেই ফেরত দেয়। না থাকলে Python total = total + m-এ ফিরে যায় — নতুন object তৈরি, তারপর নামটি নতুন object-এ লাগানো। পর্ব ১৯-এ ঠিক এটাই দেখেছিলেন: list-এর __iadd__ আছে, তাই a += [2] একই list বদলায় আর তার সব alias সেই বদল দেখে; tuple-এর নেই, তাই t += (2,) নতুন tuple বানায়। আমাদের Money একটি value object — তাই এতে __iadd__ লিখব না. += তখন __add__ ব্যবহার করে নতুন object দেবে, আর কোথাও কারও হাতে থাকা পুরোনো Money চুপচাপ বদলে যাবে না। set-এ রাখা object-এর ক্ষেত্রে এটা জীবন বাঁচায় (অংশ ৩-এর শেষ ধাপ মনে করুন)।

এবার একটি সহজ 2D গেমের কথা ভাবুন — একটি চরিত্র মাঠে দৌড়ায়, তার অবস্থান আর বেগ দুটোই (x, y) জোড়া। গণিতে vector যোগ আর সংখ্যা দিয়ে গুণ সবার চেনা, তাই এখানে operator overloading পুরোপুরি স্বাভাবিক:

class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y
    def __repr__(self):
        return f"Vector({self.x}, {self.y})"
    def __add__(self, other):
        if not isinstance(other, Vector):
            return NotImplemented
        return Vector(self.x + other.x, self.y + other.y)
    def __mul__(self, k):                    # vector × সংখ্যা
        if not isinstance(k, (int, float)):
            return NotImplemented
        return Vector(self.x * k, self.y * k)
    __rmul__ = __mul__                       # সংখ্যা × vector একই
    def __abs__(self):                       # abs(v) = দৈর্ঘ্য
        return (self.x ** 2 + self.y ** 2) ** 0.5
    def __bool__(self):                      # (0, 0) হলে False
        return bool(self.x or self.y)

pos, speed = Vector(3, 4), Vector(1, 1)
print(pos + speed, speed * 2, 2 * speed, abs(pos), bool(Vector(0, 0)))
# Vector(4, 5) Vector(2, 2) Vector(2, 2) 5.0 False

__rmul__ = __mul__ লাইনটি খেয়াল করুন: সংখ্যা দিয়ে গুণ দুই দিক থেকেই একই, তাই একই ফাংশনকে দুটি নাম দিলাম। কিন্তু __add__-এ এমনটা সবসময় চলে না — যেমন string জোড়া লাগানোয় "a" + "b" আর "b" + "a" আলাদা। আর Vector * Vector-এর জন্য আমরা ইচ্ছা করে কিছু দিইনি: dot product না cross product — অর্থ অস্পষ্ট, তাই NotImplemented আর শেষে TypeError. অস্পষ্ট হলে নাম দেওয়া method (v.dot(w)) অনেক ভালো। (NumPy এই কারণেই matrix গুণের জন্য আলাদা @ operator ব্যবহার করে, যার dunder __matmul__ — Python 3.5 থেকে।)

৬ · সত্য-মিথ্যা আর container — __bool__, __len__, __getitem__, __contains__

পর্ব ০৬-এ truthiness দেখেছিলেন: খালি list, 0, "" হলো falsy. আপনার object if obj:-এ কী হবে? Python এই ক্রমে খোঁজে:

1. class-এ __bool__ থাকলে সেটি ডাকে — True বা False ফেরত দিতে হবে।
2. না থাকলে __len__ খোঁজে — দৈর্ঘ্য 0 হলে False, নইলে True.
3. কোনোটিই না থাকলে object সবসময় True.

তাই container-ধর্মী class-এ আলাদা __bool__ সাধারণত লাগে না — __len__-ই যথেষ্ট, খালি হলে নিজে থেকেই falsy.

এবার একটি গানের Playlist. আমরা চাই এটি list-এর মতো ব্যবহার করা যাক — len, ইনডেক্স, slicing, in, for — কিন্তু নিজস্ব নিয়মসহ: গান খোঁজা হবে বড়-ছোট হাতের অক্ষর না মেনে। কোন কোন অনুরোধে সাড়া দিলে কোন কোন আচরণ পাওয়া যায়, তার একটি পরিচিত নাম আছে: protocol. Container protocol-এর মূল method তিনটি — __len__, __getitem__ আর __contains__:

class Playlist:
    def __init__(self, name, songs):
        self.name = name
        self._songs = list(songs)
    def __repr__(self):
        return f"<Playlist {self.name!r}: {len(self)} songs>"
    def __len__(self):
        return len(self._songs)
    def __getitem__(self, index):         # road[0], road[-1], road[1:]
        return self._songs[index]
    def __contains__(self, title):        # "..." in road
        return title.casefold() in (s.casefold() for s in self._songs)

road = Playlist("Road trip", ["Ekla Cholo Re", "Purano Sei Diner Kotha", "Tumi Robe Nirobe"])
print(road, len(road), road[0], road[-1], sep=" | ")
print(road[1:], "EKLA CHOLO RE" in road, "Shada" in road)
for i, song in enumerate(road, start=1):
    print(i, song)
print(bool(road), bool(Playlist("খালি", [])))

for কীভাবে চলল? Python-এর একটি পুরোনো নিয়ম: class-এ __iter__ না থাকলে কিন্তু __getitem__ থাকলে, for লুপ obj[0], obj[1], obj[2]… ডাকতে থাকে, যতক্ষণ না IndexError আসে — সেটাই “শেষ” সংকেত। একে বলে পুরোনো sequence protocol. __contains__ না থাকলে in-ও একইভাবে একে একে ঘুরে == দিয়ে খুঁজত। আধুনিক কোডে iterable বানানোর মূল পথ __iter__ আর __next__ — সেটা পর্ব ৩৪-এর বিষয়। এখানে শুধু জেনে রাখুন, __getitem__ একাই অনেক দূর নিয়ে যায়।

Playlist-এ গান বদলাতে চাইলে __setitem__ যোগ করুন: road[0] = "Amar Shonar Bangla" তখন type(road).__setitem__(road, 0, "Amar Shonar Bangla") ডাকবে। এর ভাই __delitem__ চালায় del road[0]. কিন্তু খেয়াল করুন: এগুলো যোগ করলে Playlist mutable হয়ে যায় — তখন অংশ ৩-এর নিয়ম অনুযায়ী এর জন্য সমতাভিত্তিক __hash__ লেখা চলবে না।

৭ · __call__, __format__ — আর Python dunder খোঁজে কোথায়

__call__ — ফাংশনের মতো ডাকা যায় এমন object

পর্ব ২০-এ closure দিয়ে VAT-এর factory বানিয়েছিলেন — একটি ফাংশন যা হার মনে রাখে। একই কাজ object দিয়েও হয়: class-এ __call__ লিখলে তার object-কে ফাংশনের মতো বন্ধনী দিয়ে ডাকা যায়। এমন যেকোনো কিছুকে Python বলে callable; callable(x) দিয়ে যাচাই করা যায়।

class Tax:
    def __init__(self, rate):
        self.rate = rate
    def __call__(self, amount):
        return round(amount * (1 + self.rate))

vat = Tax(0.15)
print(vat(1000), callable(vat), vat.rate)    # 1150 True 0.15

Closure-এর তুলনায় সুবিধা: vat.rate বাইরে থেকে দেখা ও পরীক্ষা করা যায়, আর পরে আরও method যোগ করা যায়। আসলে Python-এ ফাংশনও একটি object, যার type-এ __call__ আছে — আর class নিজেও callable: Money(500) লেখাটাই একটি ডাক, যা নতুন object বানায়। পর্ব ৩৫-এ decorator-এ এই ধারণা আবার কাজে লাগবে।

__format__ — f-string-এর কোলনের পরের অংশ

f"{x:,.2f}" লিখলে Python ডাকে type(x).__format__(x, ",.2f") — কোলনের পরের লেখাটি argument হিসেবে যায়। ডিফল্ট __format__ খালি spec পেলে str(x) দেয়, অন্য কিছু পেলে TypeError. চাইলে নিজের spec বানাতে পারেন — যেমন Money-তে f"{m:bn}" দিলে 1,250 টাকা 50 পয়সা, আর অন্য spec হলে টাকার সংখ্যাটির ওপর format() চালিয়ে দেওয়া। খুব দরকার না হলে এটি লিখবেন না; __str__-ই বেশিরভাগ কাজ সারে।

Python dunder খোঁজে type-এ, object-এর গায়ে নয়

একটি সূক্ষ্ম কিন্তু গুরুত্বপূর্ণ নিয়ম। সাধারণ attribute (m.poisha) খোঁজার সময় Python আগে object-এর নিজের ডেটা দেখে, তারপর class. কিন্তু syntax যখন নিজে থেকে dunder ডাকে (len(x), x + y), Python সরাসরি type-এ খোঁজে — object-এর গায়ে লাগানো কিছু দেখে না। পরীক্ষা করে দেখুন:

class Box:
    def __len__(self):
        return 5

b = Box()
b.__len__ = lambda: 99         # object-এর গায়ে আলাদা __len__
print(len(b), b.__len__())     # 5 99

len(b) দিল 5 — class-এর method; b.__len__() সাধারণ attribute হিসেবে খোঁজায় পেল object-এর গায়ের lambda, তাই 99. কেন এই নিয়ম? প্রথম কারণ গতি: CPython-এ প্রতিটি type-এর ভেতরে C ভাষার একটি কাঠামো আছে, যার নির্দিষ্ট ঘরে (slot) সরাসরি “যোগের ফাংশন”, “দৈর্ঘ্যের ফাংশন” বসানো থাকে। a + b চালাতে Python শুধু সেই ঘরটি দেখে — কোনো dict খোঁজা নেই। দ্বিতীয় কারণ সঠিকতা: class নিজেও একটি object; hash(Money) ডাকলে Python যদি Money.__hash__ খুঁজত, তাহলে পেত instance-এর জন্য লেখা method — ভুল জিনিস। Type-এ খুঁজলে Money-র type (type) থেকে সঠিক উত্তর আসে। ব্যবহারিক শিক্ষা: dunder সবসময় class-এর ভেতরে def দিয়ে লিখুন, চালানোর সময় object-এ বসাবেন না।

৮ · Operator overloading-এর আদব — কখন হ্যাঁ, কখন না

Dunder method শক্তিশালী, আর শক্তির অপব্যবহারও সহজ। একটি সোজা পরীক্ষা: কোড পড়ে একজন নতুন সহকর্মী কি operator-এর অর্থ না জেনেই সঠিক অনুমান করতে পারবেন? পারলে overload করুন; না পারলে নাম দেওয়া method লিখুন।

আরও কয়েকটি আদব:

• প্রত্যাশিত নিয়ম মানুন। যোগ থাকলে a + b == b + a আশা করা হয় (string ছাড়া); == থাকলে a == a সবসময় সত্য; __lt__ থাকলে a < b আর b < a একসাথে সত্য হবে না। এগুলো ভাঙলে sorted বা set নিঃশব্দে ভুল ফল দিতে পারে।
• __add__ কোনো পক্ষ বদলাবে না। নতুন object ফেরত দিন। বদলানোর কাজ __iadd__-এর, তাও শুধু mutable object-এ।
• অচেনা type → NotImplemented. নিজে error তুলবেন না, False দেবেন না।
• ফেরত type ঠিক রাখুন। __len__ অঋণাত্মক int, __bool__ bool, __repr__ ও __str__ str ফেরত দেবে — নইলে TypeError.

৯ · AI-এর যুগে — dunder method-এর ভুল ধরা

AI-কে “একটি Money class লিখে দাও” বললে সাধারণত চলনসই কোড আসে, আর সাধারণ পরীক্ষায় সব ঠিক দেখায়। এই পর্বের ভুলগুলো ধরা পড়ে পরে — যখন object-কে set-এ রাখতে যান, sum() চালান, বা অন্য type-এর সাথে তুলনা হয়। AI-এর প্রশিক্ষণের কোডে এই ধাঁচগুলো প্রচুর, তাই AI-ও সেগুলো নকল করে:

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

• __eq__ খুঁজেছি; থাকলে __hash__-ও আছে, আর দুটি একই ফিল্ড ব্যবহার করে
• object-কে একটি set-এ রেখে আর dict-এর চাবি বানিয়ে দেখেছি
• প্রতিটি binary dunder-এ অচেনা type-এর জন্য return NotImplemented আছে, raise বা False নয়
• sum() আর sorted() চালিয়ে দেখেছি
• REPL-এ object, আর একটি list-এর ভেতরে object ছাপিয়ে দেখেছি — repr পড়া যায়, মেমরি-ঠিকানা নেই
• প্রতিটি overload করা operator-এর অর্থ এক বাক্যে বলতে পেরেছি; না পারলে নাম দেওয়া method চেয়েছি