class ও object — ডেটা, আচরণ আর একটি নিয়ম একসাথে

১ · class কেন — ডেটা, আচরণ আর একটি নিয়ম একসাথে

মডিউল ৩-এ আপনি ডেটা রাখতে শিখেছেন list, tuple আর dict দিয়ে, আর মডিউল ২-এ কাজ করতে শিখেছেন ফাংশন দিয়ে। এতদিন এই দুটি আলাদা ছিল: ডেটা এক জায়গায়, ফাংশন আরেক জায়গায়। একটি বিকাশ-ধাঁচের মোবাইল wallet ভাবুন। পর্ব ১৬-এর মতো dict দিয়ে লিখলে:

wallet = {"owner": "Rahim", "balance": 500}

def withdraw(w, amount):
    if amount > w["balance"]:
        raise ValueError("ব্যালান্স কম")
    w["balance"] -= amount

withdraw(wallet, 200)          # নিয়ম মেনে তোলা
wallet["balance"] = -9000      # কেউ সরাসরি লিখে দিল — কেউ আটকাল না!

শেষ লাইনটিই সমস্যা। withdraw ফাংশনটি যত্ন করে নিয়ম মানে — ব্যালান্সের বেশি তোলা যাবে না। কিন্তু dict-টি সবার জন্য খোলা; প্রোগ্রামের যেকোনো জায়গা থেকে যে কেউ wallet["balance"]-এ যা খুশি লিখতে পারে। নিয়মটি থাকে ফাংশনে, আর ডেটা থাকে বাইরে — দুটির মধ্যে কোনো বাঁধন নেই। বানান ভুল করে wallet["balence"] লিখলে নতুন একটি চাবিও চুপচাপ তৈরি হয়ে যায়।

class এই বাঁধনটিই তৈরি করে। একটি class তিনটি জিনিস একসাথে রাখে:

• ডেটা — wallet-এর মালিক, ব্যালান্স, লেনদেনের ইতিহাস। এগুলোকে বলে attribute.
• আচরণ — জমা, তোলা, ইতিহাস দেখা। এগুলো ফাংশন, কিন্তু class-এর ভেতরে লেখা; এদের বলে method.
• একটি নিয়ম — “ব্যালান্স কখনো ঋণাত্মক হবে না”। যে শর্ত object-এর পুরো জীবনে সবসময় সত্য থাকার কথা, তাকে বলে invariant. Method-গুলোর আসল দায়িত্ব এই নিয়ম রক্ষা করা।

এই নকশা থেকে বানানো প্রতিটি জিনিসকে বলে object বা instance — দুটি শব্দ প্রায় একই অর্থে চলে। “instance” শব্দটি সম্পর্ক বোঝায়: acc হলো Account class-এর একটি instance. আর class থেকে object বানানোর কাজটিকে বলে instantiation.

এভাবে ডেটা আর তার নিয়ম একসাথে বেঁধে ভেতরের খুঁটিনাটি বাইরে থেকে আড়াল রাখার ভাবনাকে বলে encapsulation. আর পুরো প্রোগ্রামকে এমন object-এর মেলামেশা হিসেবে সাজানোর পদ্ধতির নাম object-oriented programming (OOP). মডিউল ৫-এর সাতটি পর্ব এই নিয়েই।

Python-এ class নিজেও একটি object

পর্ব ০৫-এ বলেছিলাম, Python-এ সবকিছুই object. class-ও তার ব্যতিক্রম নয়। class Account: লাইনটি চললে মেমরিতে একটি class object তৈরি হয়, আর Account নামটি তার গায়ে লাগে — ঠিক যেমন def একটি function object বানায়। তাই class-কে ভ্যারিয়েবলে রাখা যায়, ফাংশনে পাঠানো যায়, list-এ রাখা যায়। আর class object-টি নিজেও একটি namespace — তার ভেতরে থাকে method আর class attribute-গুলো। type(acc) দেয় Account, আর type(Account) দেয় type — অর্থাৎ class-ও কোনো এক “class-এর class”-এর instance. এর গল্প ভাবনার প্রশ্ন ৪-এ।

২ · প্রথম class — class, __init__ আর একটি object-এর জন্ম

একটি ছোট ব্যাংক হিসাব দিয়ে শুরু করি। প্রথমে শুধু দুটি জিনিস: object তৈরির সময় মালিক আর ব্যালান্স বসানো, আর টাকা তোলা।

class Account:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance

    def withdraw(self, amount):
        if amount > self.balance:
            raise ValueError(f"ব্যালান্স কম: {self.balance}")
        self.balance -= amount

acc = Account("Rahim", 500)

কয়েকটি নতুন জিনিস:

• class Account: — নতুন class-এর শুরু। নাম PEP 8 অনুযায়ী CapWords ধাঁচে (প্রতিটি শব্দের প্রথম অক্ষর বড়: Account, LibraryBook), ফাংশনের snake_case থেকে আলাদা — যাতে নাম দেখেই বোঝা যায় এটি class.
• ভেতরের def — class-এর ভেতরে লেখা ফাংশনই method. প্রতিটির প্রথম parameter self.
• __init__ — দুই পাশে দুটি করে আন্ডারস্কোর, পর্ব ১৯-এ দেখা সেই dunder method-এর পরিবারের সদস্য। নতুন object তৈরি হওয়ামাত্র Python নিজে এটি ডাকে।
• self.owner = owner — নতুন object-এর গায়ে owner নামের একটি attribute লাগানো। বাঁ দিকের self.owner হলো object-এর attribute, ডান দিকের owner হলো parameter — একই নাম হলেও দুটি আলাদা জিনিস।

এবার শেষ লাইন acc = Account("Rahim", 500)-এর ভেতরে ঠিক কী ঘটে, ধাপে ধাপে দেখুন। লক্ষ করুন, class-কে ফাংশনের মতো বন্ধনী দিয়ে ডাকা হচ্ছে — class object “callable”:

1class Account:2    def __init__(self, owner, balance=0):3        self.owner = owner4        self.balance = balance56    def withdraw(self, amount): ...78acc = Account("Rahim", 500)

প্রতিটি ডাকে নতুন object — identity আর isinstance

a = Account("Rina", 100) আর b = Account("Rina", 100) — দুটির মালিক আর ব্যালান্স হুবহু এক। তবু a is b হলো False: প্রতিটি ডাক মেমরিতে নতুন একটি object বানায়, যার নিজের identity. a.balance বদলালে b-এর কিছু হয় না। আর মজার কথা, a == b-ও False, কারণ নিজের class-এ ==-এর অর্থ আপনি এখনো বলে দেননি; Python তখন ==-কে is-এর মতোই বিচার করে। দুটি হিসাব কখন “সমান” — সেটি পর্ব ৩০-এর __eq__-এর কাজ।

কোনো object কোন class-এর, তা জানতে type(acc) দেয় Account. তবে “এটি কি একটি Account?” প্রশ্নের জন্য isinstance() ভালো: isinstance(acc, Account) দেয় True, আর পর্ব ৩১-এর inheritance এলে এটি subclass-কেও ঠিকঠাক চেনে।

৩ · self — method কীভাবে জানে কোন object-এর কাজ

নতুনদের কাছে সবচেয়ে রহস্যময় হলো self. def withdraw(self, amount)-এ দুটি parameter, অথচ ডাকার সময় দেন একটি: acc.withdraw(200). বাকিটা কোথা থেকে আসে?

উত্তর একটি লাইনে: acc.withdraw(200) আর Account.withdraw(acc, 200) হুবহু একই কাজ. method আসলে class-এ রাখা একটি সাধারণ ফাংশন। বিন্দুর বাঁ দিকের object-টিকে Python নিজে থেকে প্রথম argument হিসেবে বসিয়ে দেয়। সেই parameter-এর নাম self রাখা শুধু একটি দৃঢ় প্রচলন — me বা this লিখলেও চলবে, কিন্তু কেউ লেখেন না, আর লিখলে অন্যদের পড়তে কষ্ট হবে।

নিচের ধাপগুলোতে একই অনুবাদ দেখুন, সঙ্গে invariant রক্ষার দুই পরিণতি — অনুমতি পাওয়া আর বাতিল হওয়া:

1def withdraw(self, amount):2    if amount > self.balance:3        raise ValueError(...)4    self.balance -= amount56acc.withdraw(200)7acc.withdraw(1000)

এখানে একটি গভীর কথা আছে। invariant রক্ষা করা যায় কারণ অবস্থা বদলানোর সব পথ method-এর ভেতর দিয়ে যায়. method হলো দরজার পাহারাদার: deposit দেখে পরিমাণ ধনাত্মক কি না, withdraw দেখে ব্যালান্সে কুলায় কি না। __init__-ও একটি পাহারাদার — Account("Rahim", -50) ডাকলে সেখানেই ValueError তোলা উচিত, যাতে জন্ম থেকেই কোনো object ভুল অবস্থায় না থাকে। কিন্তু কেউ যদি method এড়িয়ে সরাসরি acc.balance = -9000 লেখে? Python সেটি আটকায় না। এর উত্তর অংশ ৬-এ, আর পূর্ণ সমাধান (property) পর্ব ৩২-এ।

এবার প্রথম runnable প্রোগ্রাম। এতে আছে class attribute (bank), দুই রকম ডাক একই কাজ করে তার প্রমাণ, object-এর ভেতরের খাতা দেখার vars(), আর বাতিল হওয়া উত্তোলন। চালানোর আগে প্রথম লাইনের ব্যালান্স অনুমান করুন:

class Account:
    bank = "ABCL Bank"                     # class attribute

    def __init__(self, owner, balance=0):
        self.owner = owner                 # instance attribute
        self.balance = balance

    def withdraw(self, amount):
        if amount > self.balance:
            raise ValueError(f"ব্যালান্স কম: {self.balance}")
        self.balance -= amount

acc = Account("Rahim", 500)
acc.withdraw(200)                          # = Account.withdraw(acc, 200)
Account.withdraw(acc, 100)
print(vars(acc), acc.bank)
try:
    acc.withdraw(1000)
except ValueError as e:
    print("বাতিল:", e)
print(acc.balance, type(acc).__name__, isinstance(acc, Account))

৪ · instance attribute বনাম class attribute — খোঁজার ক্রম আর ভাগ করা list-এর ফাঁদ

প্রথম প্রোগ্রামে দুই জায়গায় attribute ছিল। self.owner-এর মতো যেগুলো __init__-এ (বা অন্য method-এ) self-এর গায়ে লাগানো হয়, সেগুলো instance attribute — প্রতিটি object-এর নিজস্ব। আর bank = "ABCL Bank"-এর মতো যেগুলো সরাসরি class-এর ভেতরে, কোনো method-এর বাইরে লেখা, সেগুলো class attribute — class object-এ একবার রাখা, সব instance ভাগ করে।

Python যখন acc.bank পড়ে, সে একটি নির্দিষ্ট ক্রমে খোঁজে — পর্ব ২০-এর LEGB-এর মতোই একটি ছোট নিয়ম:

(পর্ব ৩১-এ inheritance এলে class-এর পরে parent class-গুলোও খোঁজা হবে, আর পর্ব ৩২-এ property-র মতো কিছু ব্যতিক্রম দেখবেন।) কিন্তু লেখার নিয়ম আলাদা: acc.bank = "X" লিখলে Python class-এ যায় না — সোজা acc-এর নিজের খাতায় নতুন bank লেখে, যা class-এর bank-কে শুধু এই object-এর জন্য ঢেকে দেয়। আর acc.history.append(...)-এর মতো কাজ কোনো নামে assign করে না, শুধু পড়ে-পাওয়া object-টিকে ভেতর থেকে বদলায় (পর্ব ১৯) — ফাঁদের শুরু এখানেই। ধাপে ধাপে দেখুন:

1class Student:2    school = "Collegiate"3    marks = []                 # ফাঁদ4    def __init__(self, name):5        self.name = name67a, b = Student("Rina"), Student("Jamil")8print(a.school)9a.school = "Govt. Lab"10a.marks.append(85)11print(b.marks)

class attribute-এর সঠিক ব্যবহার — একটি ভাগ করা counter

class attribute-এর সবচেয়ে ভালো ব্যবহার হলো সবার জন্য একটি সাধারণ মান — একটি ধ্রুবক (যেমন সর্বোচ্চ দৈনিক লেনদেনের সীমা), বা একটি হিসাব যা পুরো class-এর, কোনো একটি object-এর নয়। যেমন মোট কতটি wallet খোলা হলো: __init__-এ Wallet.count += 1. এখানে ঠিক Wallet.count লিখতে হবে, self.count += 1 নয়! কারণ self.count += 1 মানে self.count = self.count + 1 — ডান দিক class থেকে পড়ে (0), কিন্তু বাঁ দিকের assign হয় object-এর নিজের খাতায়। ফলে প্রতিটি object-এর নিজের count = 1, আর class-এর count চিরকাল 0. পড়া আর লেখার এই অসমতা বুঝলে class attribute-এর সব রহস্য খুলে যায়।

৫ · object-এর ভেতরটা — __dict__, dynamic attribute আর __slots__

“object-এর নিজের খাতা” কথাটি উপমা নয়, আক্ষরিক। সাধারণ Python object তার instance attribute-গুলো রাখে একটি সাধারণ dict-এ, যার নাম __dict__. acc.__dict__ বা আরও পরিষ্কারভাবে vars(acc) লিখলে সেটি দেখা যায় — প্রথম প্রোগ্রামে যেমন দেখেছেন। class-এরও একটি __dict__ আছে (একটু বিশেষ ধরনের, শুধু পড়া যায়), যেখানে method আর class attribute থাকে। তাই acc.balance পড়া মোটামুটি এমন: “acc.__dict__-এ 'balance' চাবি আছে? থাকলে সেটি; না থাকলে Account.__dict__-এ দেখো”। পর্ব ১৬-এর dict-ই OOP-এর নিচে বসে আছে।

এর একটি সরাসরি ফল: যেকোনো সময় নতুন attribute যোগ করা যায়. acc.nickname = "রহিম ভাই" লিখলে কোনো error নেই — খাতায় নতুন একটি চাবি। একে বলে dynamic attribute. এটি কখনো কাজের (পরীক্ষার সময় দ্রুত কিছু জুড়ে দেওয়া), কিন্তু বেশিরভাগ সময় বাগের উৎস: acc.balence = 0 (বানান ভুল) লিখলে Python খুশিমনে নতুন attribute বানায়, আর আসল balance অপরিবর্তিত থাকে। এই কারণে ভালো অভ্যাস: সব instance attribute __init__-এ তৈরি করুন, শুরুর মান None হলেও। তাহলে __init__ পড়েই বোঝা যায় object-এ কী কী থাকে, আর editor ও linter বানান ভুল ধরতে পারে।

অন্যদিকে, যে attribute কখনো তৈরি হয়নি তা পড়তে গেলে আসে AttributeError: 'Account' object has no attribute 'nickname' — dict-এর KeyError-এর OOP সংস্করণ। getattr(acc, "nickname", None) দিয়ে নিরাপদে পড়া যায়, যেমন dict-এ .get().

__slots__ — খাতা বাদ, নির্দিষ্ট ঘর

প্রতিটি object-এর জন্য একটি আলাদা dict রাখতে মেমরি লাগে। দশটি object-এ কিছু যায় আসে না, কিন্তু কয়েক লাখ ছোট object (যেমন একটি মানচিত্রের লাখো বিন্দু) হলে পার্থক্য চোখে পড়ে। এর জন্য Python দেয় __slots__: class-এ __slots__ = ("owner", "balance") লিখলে object আর __dict__ রাখে না; শুধু ওই নামগুলোর জন্য নির্দিষ্ট ঘর থাকে। দুটি ফল: মেমরি কম লাগে আর attribute পড়া একটু দ্রুত হয়; এবং তালিকার বাইরের কোনো নাম (acc.balence = 0) দিলে সঙ্গে সঙ্গে AttributeError — বানান ভুল ধরা পড়ে। দাম হলো নমনীয়তা হারানো। বেশিরভাগ class-এ __slots__ লাগে না; Python 3.10 থেকে @dataclass(slots=True) লিখে এটি সহজে পাওয়া যায় (পর্ব ৩২)।

৬ · “private” — _balance, __balance আর “আমরা সবাই প্রাপ্তবয়স্ক”

C++ বা Java-তে private কিওয়ার্ড দিলে class-এর বাইরে থেকে সেই ডেটায় হাত দেওয়া যায় না — compiler আটকে দেয়। Python-এ এমন কোনো কিওয়ার্ড নেই। তার বদলে আছে দুটি প্রচলন।

name mangling-এর আসল উদ্দেশ্য গোপনীয়তা নয় — নামের সংঘর্ষ এড়ানো. পর্ব ৩১-এ দেখবেন, একটি class থেকে আরেকটি class বানানো যায় (inheritance). parent class-এর ভেতরের একটি সহায়ক নাম, ধরুন __cache, যদি child class-এর লেখক না জেনে একই নামে আরেকটি attribute বানান, দুটি মিশে যেত। mangling-এর পরে একটি হয় _Parent__cache, আরেকটি _Child__cache — আলাদা থাকে। Python-এর অফিসিয়াল tutorial-ও এই উদ্দেশ্যই বলে। (নিয়মটি খাটে নামের শুরুতে অন্তত দুটি আন্ডারস্কোর আর শেষে একটির বেশি না থাকলে; তাই __init__-এর মতো dunder নামে mangling হয় না।)

এর মানে কি invariant রক্ষা অর্থহীন? না। invariant রক্ষা মানে সঠিক পথটিকে সহজ আর স্পষ্ট করা, ভুল পথকে অসম্ভব করা নয়। acc.withdraw(200) লেখা সহজ, আর পরিষ্কার; acc._balance -= 200 লেখা দেখতেই সন্দেহজনক — কোড রিভিউতে, linter-এ, এমনকি লেখকের নিজের চোখে। আর যে ভাষায় সত্যিকারের private আছে, সেখানেও reflection বা pointer-এর কৌশলে তা ভাঙা যায়; সেখানেও শেষ রক্ষাকবচ হলো শৃঙ্খলা।

Tell, don't ask — জিজ্ঞেস না করে বলুন

ছোট, ভালো class নকশার একটি পুরোনো সূত্র হলো tell, don't ask. খারাপ ধাঁচ: বাইরের কোড object-এর ডেটা জিজ্ঞেস করে, নিজে সিদ্ধান্ত নেয়, তারপর ডেটা বদলায় —

# ask — নিয়মটি বাইরে ছড়িয়ে আছে
if book.borrower is None:
    book.borrower = "Rina"

# tell — নিয়মটি class-এর ভেতরে, এক জায়গায়
book.borrow("Rina")        # ইতিমধ্যে কারও কাছে থাকলে ValueError

প্রথম ধাঁচে “একই বই দুজনের কাছে থাকতে পারে না” নিয়মটি প্রতিটি জায়গায় আলাদা করে লিখতে হয়; একজন ভুলে গেলেই নিয়ম ভাঙে। দ্বিতীয় ধাঁচে লাইব্রেরির Book class নিজের নিয়ম নিজে জানে: borrow পরীক্ষা করে, give_back খালি করে। বাইরের কোড শুধু বলে “ধার দাও” — কীভাবে, সেটি বইয়ের দায়িত্ব। একই ভাবনায় রিকশার ভাড়া-মিটার: বাইরে থেকে meter.km += 2 নয়, বরং meter.add_trip(2), যা ঋণাত্মক দূরত্ব ফিরিয়ে দেয়; আর ভাড়া জানতে meter.fare(), যা নিজের নিয়মে (ধরুন প্রথম কিলোমিটার ৩০ টাকা, পরের প্রতি কিলোমিটার ২০ টাকা — শুধু উদাহরণ) হিসাব করে।

৭ · @classmethod আর @staticmethod — বিকল্প constructor

সাধারণ method-এর প্রথম argument হলো object (self). কিন্তু কখনো এমন কাজ লাগে যা কোনো একটি object-এর নয়, পুরো class-এর। Python এর জন্য দুটি বিশেষ ধরন দেয়, দুটিই @ দিয়ে লেখা decorator (পর্ব ৩৫-এ decorator-এর ভেতরের গল্প)।

@classmethod-এর প্রথম argument object নয়, class নিজে — প্রচলিত নাম cls. এর সবচেয়ে বড় ব্যবহার হলো alternative constructor: object বানানোর আরেকটি পথ। ধরুন wallet-এর তথ্য আসে একটি ফাইল থেকে "Karim:300" আকারে। প্রতিবার বাইরে ভেঙে Wallet(name, int(amount)) লেখার বদলে class নিজেই একটি পথ দেয়: Wallet.from_string("Karim:300"). Python-এর নিজের লাইব্রেরিতে এর অনেক উদাহরণ আছে — dict.fromkeys(...), datetime.fromisoformat(...), int.from_bytes(...). নাম সাধারণত from_... দিয়ে শুরু। ধাপে ধাপে দেখুন:

1@classmethod2def from_string(cls, text):3    owner, amount = text.split(":")4    return cls(owner, int(amount))56w = Wallet.from_string("Karim:300")

@staticmethod আরও সরল: এটি কোনো স্বয়ংক্রিয় প্রথম argument পায় না — না self, না cls. এটি আসলে class-এর ভেতরে রাখা একটি সাধারণ ফাংশন, শুধু বিষয়ের মিল আছে বলে সেখানে রাখা। যেমন Wallet.is_valid_amount(amount), যা দেখে পরিমাণটি সীমার মধ্যে কি না। তবে সত্যি বলতে, Python-এ module-স্তরের একটি সাধারণ ফাংশনও প্রায় সবসময় একই কাজ করে, আর অনেক অভিজ্ঞ Python প্রোগ্রামার @staticmethod খুব কম ব্যবহার করেন। তিনটির তুলনা:

দ্বিতীয় runnable প্রোগ্রামে অংশ ৪-এর list-এর ফাঁদ, তার সঠিক রূপ, class-স্তরের counter, from_string, আর object সুন্দর করে ছাপার জন্য একটি ছোট __repr__ — পর্ব ৩০-এর ঝলক:

class Student:
    marks = []                       # ফাঁদ: class-এ একটি list, সবার জন্য
a, b = Student(), Student()
a.marks.append(85)                   # শুধু a-এর জন্য নম্বর যোগ?
print(b.marks, a.marks is b.marks)

class Wallet:
    count = 0                        # class attribute: মোট কতটি wallet
    def __init__(self, owner, balance=0):
        self.owner, self._balance = owner, balance
        self.history = []            # ঠিক: প্রতিটি wallet-এর নিজের list
        Wallet.count += 1
    @classmethod
    def from_string(cls, text):      # "Karim:300" থেকে wallet
        owner, amount = text.split(":")
        return cls(owner, int(amount))
    def __repr__(self):
        return f"Wallet({self.owner!r}, {self._balance})"
w1, w2 = Wallet("Rahim", 500), Wallet.from_string("Karim:300")
w1.count = 99                        # w1-এর নিজের নতুন attribute
print(w1, w2, Wallet.count, w1.count, w2.count)

৮ · কখন class, কখন নয় — dict, closure, ফাংশন আর object ছাপা

class শেখার পর সবকিছুকে class বানানোর একটি প্রবল টান আসে। Java-র মতো ভাষায় সব কোড class-এর ভেতরেই লিখতে হয়, তাই সেখান থেকে আসা প্রোগ্রামার আর অনেক AI-ও সেই অভ্যাস Python-এ নিয়ে আসেন। কিন্তু Python-এ ফাংশন, dict আর closure-ও প্রথম শ্রেণির হাতিয়ার। ২০১২ সালের PyCon US সম্মেলনে Jack Diederich-এর বিখ্যাত বক্তৃতা “Stop Writing Classes”-এর মূল কথা ছিল এটাই: যে class-এ মাত্র দুটি method, আর তার একটি __init__, সেটি সম্ভবত একটি ফাংশন হওয়া উচিত।

একটি উদাহরণে পার্থক্যটি স্পষ্ট। ছাত্রের GPA হিসাবের জন্য class GPACalculator বানিয়ে GPACalculator(marks).calculate() লেখা অপ্রয়োজনীয় — calculate_gpa(marks) ফাংশনটিই যথেষ্ট। কিন্তু যদি একজন Student-এর নাম, রোল, বিষয়ভিত্তিক নম্বর থাকে, নতুন নম্বর যোগের সময় ০–১০০ সীমা পরীক্ষা করতে হয়, আর GPA বারবার নম্বর থেকে হিসাব হয় — তখন class যুক্তিসঙ্গত: student.add_mark("Physics", 78) আর student.gpa(). লক্ষ করুন, GPA-কে একটি attribute হিসেবে জমা না রেখে প্রতিবার নম্বর থেকে হিসাব করা ভালো; জমা রাখলে নতুন নম্বর যোগের পর সেটি পুরোনো হয়ে যেতে পারে — আরেকটি invariant ভাঙার পথ।

object ছাপলে কেন অদ্ভুত লেখা আসে — __repr__-এর ঝলক

__repr__ ছাড়া একটি class-এর object ছাপলে এমন কিছু দেখবেন:

<__main__.Account object at 0x7f3a2c1b9d50>

অর্থাৎ: __main__ module-এর Account class-এর একটি object, মেমরির এই ঠিকানায়। ঠিকানাটি প্রতিবার চালালে বদলায় আর কোনো কাজের তথ্য দেয় না। তাই ডিবাগ করার জন্য প্রায় প্রতিটি class-এ একটি __repr__ লেখা ভালো অভ্যাস — দ্বিতীয় প্রোগ্রামের মতো এক লাইনের, যা object-কে পরিচিত রূপে দেখায়: Wallet('Rahim', 500). __repr__ আর তার ভাই __str__-এর পার্থক্য, ==-এর জন্য __eq__, len()-এর জন্য __len__ — এসব নিয়েই পরের পর্ব।

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

AI-কে “একটি wallet সিস্টেম লিখে দাও” বললে প্রায় সবসময় একগাদা class আসে। কোড চলে, দেখতেও “পেশাদার” লাগে — কিন্তু প্রায়ই সেগুলো অন্য ভাষার অভ্যাসে লেখা, বা invariant রক্ষার কোনো ব্যবস্থাই থাকে না। AI-এর প্রশিক্ষণের ডেটায় Java-ধাঁচের কোড প্রচুর, তাই এই ভুলগুলো বারবার দেখা যায়:

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

• class-এর শরীরে (method-এর বাইরে) কোনো [], {} বা set() নেই
• প্রতিটি instance attribute __init__-এ তৈরি হয়েছে; অন্য method-এ প্রথমবার self.x = ... নেই
• invariant কোনটি, তা এক বাক্যে বলতে পারি, আর অবস্থা বদলানো প্রতিটি method (আর __init__) সেটি পরীক্ষা করে
• কোনো অর্থহীন get_x()/set_x() নেই; ভেতরের ডেটায় একটি আন্ডারস্কোর আছে
• প্রতিটি class-এ __init__ ছাড়াও অন্তত দুটি অর্থপূর্ণ আচরণ বা একটি রক্ষা করার মতো নিয়ম আছে; না থাকলে ফাংশন বা dict চেয়েছি
• দুটি object বানিয়ে একটিকে বদলে দেখেছি — অন্যটিতে কোনো প্রভাব পড়ে না