Python OOP Basics — Classes, Objects, init and Instance Variables

The Story That Explains Classes and Objects 🍪Classes और Objects समझाने वाली कहानी 🍪一个讲清类与对象的故事 🍪

Class vs Object — The Basic Difference 📐Class बनाम Object — बुनियादी फ़र्क़ 📐类与对象 — 根本区别 📐

Your First Class — the Absolute Minimumआपकी पहली Class — बिल्कुल न्यूनतम你的第一个类 — 最简形式

class Dog:
    pass                       # an empty body: no data, no methods, no __init__

d1 = Dog()                     # object 1 - a bare, empty Dog
d2 = Dog()                     # object 2 - another bare, empty Dog

print(d1)                      # the address changes on every run
print(d2)
print(d1 is d2)                # two separate objects
print(type(d1), isinstance(d1, Dog))

The number after at is a memory address. It changes on every run, so yours will differ. d1 is d2 is False: two calls, two separate objects. isinstance(d1, Dog) confirms that d1 was built from Dog.

at के बाद का नंबर memory address है। यह हर run पर बदलता है, इसलिए आपका अलग होगा। d1 is d2 False है: दो calls, दो अलग objects। isinstance(d1, Dog) पुष्टि करता है कि d1 Dog से बना है।

at 后面的数字是内存地址，每次运行都会变，所以你看到的会不同。d1 is d2 为 False：调用两次，得到两个独立对象。isinstance(d1, Dog) 确认 d1 是由 Dog 造出来的。

Adding Data From Outside — The Manual Way ✍️बाहर से Data जोड़ना — Manual तरीक़ा ✍️从外部添加数据 — 手动方式 ✍️

Python lets you attach an attribute to almost any object from outside the class. Reach in with a dot and assign: d1.name = "Buddy". These are instance variables — made in the most manual way possible.

Python आपको class के बाहर से लगभग किसी भी object पर attribute जोड़ने देता है। Dot से अंदर पहुँचें और assign करें: d1.name = "Buddy"। ये instance variables हैं — सबसे manual तरीक़े से बने।

Python 允许你从类的外部给几乎任何对象附加属性。用点号伸进去赋值即可：d1.name = "Buddy"。这些就是 实例变量 — 只是用最手动的方式创建的。

class Dog:
    pass

d1 = Dog()
d2 = Dog()
d3 = Dog()

d1.name  = "Buddy"
d1.breed = "Labrador"
d1.age   = 3

d2.name  = "Milo"
d2.breed = "Beagle"
d2.age   = 5

d3.name  = "Luna"
d3.breed = "Poodle"
d3.age   = 2

print(d1.name, d1.breed, d1.age)
print(d2.name, d2.breed, d2.age)
print(d3.name, d3.breed, d3.age)
print(d1.__dict__)             # every object keeps its data in its own dict

The last line shows where the data really lives: every object keeps its attributes in its own dictionary, __dict__.

आख़िरी line दिखाती है कि data असल में कहाँ रहता है: हर object अपने attributes अपनी dictionary __dict__ में रखता है।

最后一行显示数据真正存放的位置：每个对象把属性保存在自己的字典 __dict__ 里。

Why the Manual Way Is Painful 😖Manual तरीक़ा तकलीफ़देह क्यों है 😖为什么手动方式很痛苦 😖

The code above works. Every object ends up with the right data. But this style breaks down as soon as a program has more than a handful of objects. Here is exactly why.

ऊपर का code चलता है। हर object को सही data मिलता है। पर जैसे ही program में कुछ से ज़्यादा objects होते हैं, यह तरीक़ा टूट जाता है। ठीक-ठीक कारण ये हैं।

上面的代码能运行，每个对象都拿到了正确的数据。但只要程序里的对象多于几个，这种写法就撑不住了。具体原因如下。

Three of these problems in one real run:

इनमें से तीन समस्याएँ एक असली run में:

一次真实运行里就能看到其中三个问题：

class Dog:
    pass

d1 = Dog()
d1.nmae = "Buddy"              # typo: Python happily creates a NEW attribute
d1.breed = "Labrador"          # ... and we forgot age completely
print(d1.__dict__)

try:
    print(d1.name)
except AttributeError as e:
    print("AttributeError:", e)
try:
    print(d1.age)
except AttributeError as e:
    print("AttributeError:", e)

d1.age = "hello"               # nothing checks the value either
print(d1.age)

🏭 Simulator: The Object Factory🏭 Simulator: Object Factory🏭 模拟器：对象工厂

Build 1 to 6 dogs the manual way or with __init__. Then set a trap: a typo, a forgotten attribute, or a bad value. Each of the 48 combinations was run in real Python — the objects, the output and the error line are exactly what Python produced.

1 से 6 dogs manual तरीक़े से या __init__ से बनाएँ। फिर एक जाल लगाएँ: typo, भूला हुआ attribute, या ग़लत value। सभी 48 combinations असली Python में चलाए गए — objects, output और error line ठीक वही हैं जो Python ने दिए।

用手动方式或 __init__ 创建 1 到 6 只狗。然后设个陷阱：拼写错误、漏掉属性或坏值。全部 48 种组合都在真实 Python 中运行过 — 对象、输出和出错行都与 Python 的结果完全一致。

The Fix — __init__ Runs the Setup Automatically 🏗️हल — __init__ Setup अपने आप चलाता है 🏗️解决办法 — __init__ 自动完成设置 🏗️

__init__ (say "dunder init" — double underscore) is a special method. Python calls it automatically the moment you create an object. You write the setup once, inside the class, and Python runs it for every new object.

__init__ (बोलें "dunder init" — double underscore) एक ख़ास method है। Object बनाते ही Python इसे अपने आप बुलाता है। आप setup एक बार, class के अंदर लिखते हैं, और Python उसे हर नए object के लिए चलाता है।

__init__（读作 "dunder init"，即 double underscore，双下划线）是一个特殊方法。你创建对象的那一刻，Python 会 自动 调用它。设置代码只需在类里写一次，Python 会为每个新对象运行它。

class Dog:
    def __init__(self, name, breed, age):
        # runs automatically every time you write Dog(...)
        self.name  = name
        self.breed = breed
        self.age   = age

d1 = Dog("Buddy", "Labrador", 3)
d2 = Dog("Milo", "Beagle", 5)
d3 = Dog("Luna", "Poodle", 2)

print(d1.name, d1.breed, d1.age)
print(d2.name, d2.breed, d2.age)
print(d3.name, d3.breed, d3.age)

try:
    Dog("Rex", "Boxer")            # forgot age -> an error right away
except TypeError as e:
    print("TypeError:", e)

Anatomy of __init__ 🔬__init__ की बनावट 🔬__init__ 的剖析 🔬

class Student:
    def __init__(self, name, age, course):
    # self comes first, then your own parameters
        self.name   = name          # attach name to this object
        self.age    = age           # attach age to this object
        self.course = course        # attach course to this object

s1 = Student("Alice",   20, "Physics")
s2 = Student("Bob",     22, "Chemistry")
s3 = Student("Chandra", 19, "Math")

print(s1.name, s1.age, s1.course)
print(s3.name, s3.age, s3.course)

Want proof that __init__ runs by itself? Put a print inside it:

सबूत चाहिए कि __init__ अपने आप चलता है? उसके अंदर print रखें:

想证明 __init__ 会自动运行？在里面放一个 print：

class Student:
    def __init__(self, name, age, course):
        print(f"  __init__ runs: self is {type(self).__name__}, data so far = {self.__dict__}")
        self.name   = name
        self.age    = age
        self.course = course
        print(f"  __init__ ends: data = {self.__dict__}")

print("calling Student(...)")
s1 = Student("Alice", 20, "Physics")
print("back outside:", s1.name, s1.age, s1.course)

s2 = Student("Chandra", 19, "Math")
print(s1 is s2, s2.__dict__)

🎞️ Simulator: __init__ Step by Step🎞️ Simulator: __init__ क़दम-दर-क़दम🎞️ 模拟器：逐步运行 __init__

Press Next or Play. Watch the empty object appear, the __init__ frame open with self pointing at it, the slots fill one by one, and the frame vanish while the object stays. Every step was recorded from real Python with sys.settrace.

अगला या चलाएँ दबाएँ। देखें: ख़ाली object आता है, __init__ का frame खुलता है और self उसकी ओर इशारा करता है, खाँचे एक-एक कर भरते हैं, और frame ग़ायब होता है जबकि object बना रहता है। हर step असली Python से sys.settrace द्वारा रिकॉर्ड किया गया।

按 下一步 或 播放。观察：空对象出现，__init__ 的帧打开且 self 指向它，格子逐个填满，然后帧消失而对象留下。每一步都是用 sys.settrace 从真实 Python 中记录的。

class Student:
    def __init__(self, name, age, course):
        self.name, self.age, self.course = name, age, course

try:
    Student.__init__("Alice", 20, "Physics")      # don't call __init__ yourself
except TypeError as e:
    print("TypeError:", e)

s = Student("Alice", 20, "Physics")                # the class name is the front door
print(s.__dict__)

What Is self? 🪞self क्या है? 🪞self 是什么？🪞

Every method inside a class takes self as its first parameter. It is simply a name for "the object this method was called on". When you write buddy.bark(), Python quietly turns it into Dog.bark(buddy) and puts buddy into self.

Class के अंदर हर method पहले parameter के रूप में self लेता है। यह बस एक नाम है — "वह object जिस पर यह method बुलाया गया"। जब आप buddy.bark() लिखते हैं, Python चुपचाप इसे Dog.bark(buddy) बना देता है और buddy को self में रखता है।

类里的每个方法都把 self 作为第一个参数。它只是一个名字，意思是"调用这个方法的那个对象"。当你写 buddy.bark() 时，Python 悄悄把它变成 Dog.bark(buddy)，并把 buddy 放进 self。

class Dog:
    def __init__(self, name, breed):
        self.name  = name
        self.breed = breed

    def bark(self):
        # self is whichever dog .bark() was called on
        print(f"{self.name} says: Woof!")

buddy = Dog("Buddy", "Labrador")
milo  = Dog("Milo", "Beagle")

buddy.bark()                   # Python turns this into Dog.bark(buddy)
milo.bark()
Dog.bark(milo)                 # the same call, written the long way

🪞 Simulator: Who Is self?🪞 Simulator: self कौन है?🪞 模拟器：self 是谁？

Step through the program. Watch the purple self in each method frame: in the first bark() call it points to Dog #1 (Buddy), in the second to Dog #2 (Milo). Same method, different object.

Program को step करें। हर method frame में बैंगनी self देखें: पहली bark() call में यह Dog #1 (Buddy) की ओर इशारा करता है, दूसरी में Dog #2 (Milo) की ओर। वही method, अलग object।

逐步运行程序。注意每个方法帧里紫色的 self：第一次调用 bark() 时它指向 Dog #1（Buddy），第二次指向 Dog #2（Milo）。同一个方法，不同的对象。

Instance Variables — Where Each Object's Data Lives 🗄️Instance Variables — हर Object का Data कहाँ रहता है 🗄️实例变量 — 每个对象的数据存放在哪里 🗄️

An instance variable is a piece of data attached to one specific object. It is created the moment you write self.something = value inside a method (usually __init__). Every object gets its own copy.

Instance variable data का वह टुकड़ा है जो किसी एक ख़ास object से जुड़ा है। यह उसी पल बनता है जब आप method (आमतौर पर __init__) के अंदर self.something = value लिखते हैं। हर object को अपनी copy मिलती है।

实例变量 是附着在某一个特定对象上的一份数据。你在方法里（通常是 __init__）写下 self.something = value 的那一刻，它就被创建了。每个对象都有自己的一份。

Inside vs Outside the Class 🚪Class के अंदर बनाम बाहर 🚪类的内部与外部 🚪

The same instance variable is reached two ways, depending on where you are. Inside a method you write self.balance. Outside the class you write acc.balance. Both land on the same box in memory.

एक ही instance variable तक दो तरीक़ों से पहुँचते हैं, इस पर निर्भर कि आप कहाँ हैं। Method के अंदर आप self.balance लिखते हैं। Class के बाहर acc.balance। दोनों memory के एक ही डिब्बे पर पहुँचते हैं।

同一个实例变量有两种访问方式，取决于你所在的位置。在方法内部写 self.balance，在类外部写 acc.balance。两者都落在内存中的同一个格子上。

class BankAccount:
    def __init__(self, holder, balance):
        self.holder  = holder
        self.balance = balance

    def deposit(self, amount):
        # INSIDE the class -> use self.
        self.balance += amount

acc = BankAccount("Alice", 1000)

# OUTSIDE the class -> use the object's name
print(acc.balance)             # read from outside
acc.deposit(200)               # the method uses self inside
print(acc.balance)

Instance Variables vs Local Variables 🫧Instance Variables बनाम Local Variables 🫧实例变量与局部变量 🫧

Inside a method, self.count and count are completely different things. One survives after the method ends. The other is thrown away the moment the method returns.

Method के अंदर self.count और count बिल्कुल अलग चीज़ें हैं। एक method ख़त्म होने के बाद भी बचा रहता है। दूसरा method के return होते ही फेंक दिया जाता है।

在方法内部，self.count 和 count 是完全不同的东西。一个在方法结束后依然存在，另一个在方法返回的瞬间就被丢弃。

class Counter:
    def __init__(self):
        self.count = 0              # instance variable - kept on the object

    def bad_increment(self):
        count = self.count + 1      # local variable - gone when the method returns

    def good_increment(self):
        self.count += 1             # changes the object

c = Counter()
c.bad_increment()
c.bad_increment()
print(c.count)

c.good_increment()
c.good_increment()
print(c.count)

🫧 Simulator: Local vs Instance🫧 Simulator: Local बनाम Instance🫧 模拟器：局部变量与实例变量

Step through four calls. In bad_increment() a local count = 1 appears in the method frame — then the frame disappears and takes it along. The object still says count: 0. In good_increment() the change lands on the object itself.

चार calls को step करें। bad_increment() में method frame में एक local count = 1 आता है — फिर frame ग़ायब होता है और उसे साथ ले जाता है। Object अब भी count: 0 कहता है। good_increment() में बदलाव सीधे object पर होता है।

逐步运行四次调用。在 bad_increment() 中，方法帧里出现了局部的 count = 1 — 然后帧消失并把它一起带走，对象仍显示 count: 0。在 good_increment() 中，修改直接落在对象本身上。

Practical Example 1 — A Rectangle ▭व्यावहारिक उदाहरण 1 — एक Rectangle ▭实例 1 — 矩形 ▭

Two instance variables, three methods. Every method reads the data of its own object through self.

दो instance variables, तीन methods। हर method self के ज़रिए अपने object का data पढ़ता है।

两个实例变量，三个方法。每个方法都通过 self 读取 自己 那个对象的数据。

class Rectangle:
    def __init__(self, width, height):
        self.width  = width
        self.height = height

    def area(self):
        return self.width * self.height

    def perimeter(self):
        return 2 * (self.width + self.height)

    def describe(self):
        print(f"Rectangle {self.width}x{self.height}: "
              f"area={self.area()}, perimeter={self.perimeter()}")

r1 = Rectangle(4, 5)
r2 = Rectangle(10, 3)
r1.describe()
r2.describe()

r1.width = 100
r1.describe()           # r1 changed
r2.describe()           # r2 is exactly as before

Practical Example 2 — A Student Record System 🎓व्यावहारिक उदाहरण 2 — Student Record System 🎓实例 2 — 学生成绩系统 🎓

Each Student object carries its own marks list and computes its own average and grade.

हर Student object अपनी marks list रखता है और अपना average और grade ख़ुद निकालता है।

每个 Student 对象都带着自己的 marks 列表，并自己计算平均分和等级。

class Student:
    def __init__(self, roll_no, name, marks):
        self.roll_no = roll_no
        self.name    = name
        self.marks   = marks

    def average(self):
        return sum(self.marks) / len(self.marks)

    def grade(self):
        avg = self.average()
        if avg >= 90: return "A"
        if avg >= 75: return "B"
        if avg >= 60: return "C"
        return "F"

    def report(self):
        print(f"{self.roll_no:3d} {self.name:15s} "
              f"Avg: {self.average():5.1f}   Grade: {self.grade()}")

classroom = [
    Student(1, "Alice",   [92, 88, 95, 90]),
    Student(2, "Bob",     [70, 75, 80, 72]),
    Student(3, "Chandra", [55, 62, 58, 65]),
    Student(4, "Deepa",   [40, 45, 50, 42]),
]
for student in classroom:
    student.report()
print(classroom[1].average())     # 74.25 is printed as 74.2 - see the note below

🎓 Simulator: The Grade Card🎓 Simulator: Grade Card🎓 模拟器：成绩卡

Pick a student and drag the marks. Only that object's marks list changes — watch the other report lines stay put. The formatting matches Python's :5.1f exactly (checked on all 401 possible totals).

एक student चुनें और marks खिसकाएँ। सिर्फ़ उसी object की marks list बदलती है — देखें कि बाक़ी report lines वैसी ही रहती हैं। Formatting Python के :5.1f से हूबहू मिलती है (सभी 401 संभव totals पर जाँची गई)।

选一个学生，拖动分数。只有 那个 对象的 marks 列表会变 — 看看其他报告行保持不变。格式与 Python 的 :5.1f 完全一致（已在全部 401 种可能的总分上核对）。

Practical Example 3 — A Bank Account With Rules 🏦व्यावहारिक उदाहरण 3 — नियमों वाला Bank Account 🏦实例 3 — 带规则的银行账户 🏦

class BankAccount:
    def __init__(self, holder, opening_balance=0):
        if opening_balance < 0:
            raise ValueError("Opening balance cannot be negative")
        self.holder  = holder
        self.balance = opening_balance
        self.history = []                  # each account gets its own list

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("Deposit must be positive")
        self.balance += amount
        self.history.append(("deposit", amount))

    def withdraw(self, amount):
        if amount > self.balance:
            raise ValueError("Insufficient funds")
        self.balance -= amount
        self.history.append(("withdraw", amount))

    def statement(self):
        print(f"\n--- {self.holder} ---")
        for action, amount in self.history:
            print(f"  {action:9s}  ${amount}")
        print(f"  Current balance: ${self.balance}")

alice = BankAccount("Alice", 1000)
bob   = BankAccount("Bob")

alice.deposit(500)
alice.withdraw(200)
bob.deposit(100)
bob.deposit(300)
bob.withdraw(50)

alice.statement()
bob.statement()

for bad in [lambda: BankAccount("Eve", -5), lambda: bob.withdraw(10_000), lambda: alice.deposit(0)]:
    try:
        bad()
    except ValueError as e:
        print("ValueError:", e)

The blank line before each --- header is real: statement() prints "\n--- ...". The last three lines show the rules at work.

हर --- header से पहले की ख़ाली line असली है: statement() "\n--- ..." print करता है। आख़िरी तीन lines नियमों को काम करते दिखाती हैं।

每个 --- 标题前的空行是真实存在的：statement() 打印的是 "\n--- ..."。最后三行展示了规则在起作用。

🏦 Simulator: Bank Account Lab🏦 Simulator: Bank Account Lab🏦 模拟器：银行账户实验室

Two objects from the class above. Choose an account, an action and an amount, then press Run. Try to overdraw, deposit 0, or create Eve with −5. Then press the ⚠️ button and see what writing balance from outside does. The JavaScript model was checked against the real class on 300 random sequences.

ऊपर की class से दो objects। Account, action और amount चुनें, फिर Run दबाएँ। Overdraw करें, 0 जमा करें, या −5 से Eve बनाएँ। फिर ⚠️ button दबाएँ और देखें कि बाहर से balance लिखने पर क्या होता है। JavaScript model को असली class से 300 random sequences पर जाँचा गया।

来自上面那个类的两个对象。选择账户、操作和金额，然后按 Run。试试透支、存 0 元，或用 −5 创建 Eve。再按 ⚠️ 按钮，看看从外部写 balance 会怎样。这个 JavaScript 模型已在 300 个随机操作序列上与真实类核对过。

Common Mistakes (and Fixes) 🩹आम ग़लतियाँ (और उनके हल) 🩹常见错误（及修正）🩹

The first three mistakes, run for real — note how the mutable default gives Ravi Asha's book:

पहली तीन ग़लतियाँ, असली run में — देखें कि mutable default से Ravi को Asha की book कैसे मिल जाती है:

前三个错误的真实运行 — 注意可变默认值如何让 Ravi 拿到了 Asha 的书：

class Dog:
    def __init__(name):              # forgot self
        name = name

try:
    Dog("Buddy")
except TypeError as e:
    print("TypeError:", e)

class Bag:
    def __init__(self, owner, items=[]):    # mutable default - a trap
        self.owner = owner
        self.items = items

a = Bag("Asha")
b = Bag("Ravi")
a.items.append("book")
print(b.items, a.items is b.items)          # Ravi got Asha's book!

class SafeBag:
    def __init__(self, owner, items=None):
        self.owner = owner
        self.items = [] if items is None else items   # a fresh list each time

a = SafeBag("Asha")
b = SafeBag("Ravi")
a.items.append("book")
print(b.items, a.items is b.items)

In the first error, "Buddy" has nowhere to go: the only parameter, name, already received the object. The missing-self. bug is the bad_increment() you stepped through in Section 10. And here is __repr__:

पहले error में "Buddy" के लिए कोई जगह नहीं: इकलौते parameter name को पहले ही object मिल चुका है। self. छूटने वाला bug वही bad_increment() है जिसे आपने Section 10 में step किया। और यह रहा __repr__:

第一个错误里，"Buddy" 无处可去：唯一的参数 name 已经接收了对象本身。漏掉 self. 的 bug 就是你在第 10 节逐步运行过的 bad_increment()。再看 __repr__：

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age  = age

    def __repr__(self):
        return f"Student(name={self.name!r}, age={self.age})"

s = Student("Alice", 20)
print(s)
print([Student("Bob", 22), Student("Chandra", 19)])

Quick Reference Table 📋Quick Reference Table 📋速查表 📋

Golden Rules and Quiz 🏆सुनहरे नियम और Quiz 🏆黄金法则与小测验 🏆

Quick Quiz — 8 Questionsछोटा Quiz — 8 सवाल小测验 — 8 道题