Python OOP — Instance Methods, Class Variables & Class Methods

The Story That Explains These Three Tools ☕इन तीन Tools को समझाने वाली कहानी ☕一个讲清这三个工具的故事 ☕

Where We Are — What You Already Know 🧭हम कहाँ हैं — जो आप पहले से जानते हैं 🧭我们在哪里 — 你已经掌握的内容 🧭

You already know how to write a class with __init__ and instance variables:

आप पहले से जानते हैं कि __init__ और instance variables वाली class कैसे लिखते हैं:

你已经会写带有 __init__ 和实例变量的类了：

class CoffeeShop:
    def __init__(self, city, staff_count):
        self.city          = city          # instance variable - per store
        self.staff_count   = staff_count   # instance variable - per store
        self.daily_revenue = 0.0           # instance variable - per store

store1 = CoffeeShop("Mumbai", 8)
store2 = CoffeeShop("London", 12)
print(store1.__dict__)
print(store2.__dict__)

This gives you objects that hold data. Next we need three more things: objects that can also do things (instance methods), data that every object shares (class variables), and methods that belong to the class itself (class methods). One at a time.

इससे ऐसे objects मिलते हैं जो data रखते हैं। अब हमें तीन और चीज़ें चाहिए: ऐसे objects जो काम भी कर सकें (instance methods), ऐसा data जो हर object साझा करे (class variables), और ऐसे methods जो ख़ुद class के हों (class methods)। एक-एक करके।

这样得到的对象能 保存数据。接下来还需要三样东西：能 做事 的对象（实例方法）、所有 对象共享的数据（类变量），以及属于 类本身 的方法（类方法）。我们一个一个来。

Normal Methods (Instance Methods) — Behaviour of Each Object 🛠️सामान्य Methods (Instance Methods) — हर Object का व्यवहार 🛠️普通方法（实例方法）— 每个对象的行为 🛠️

A normal method — also called an instance method — is a function written inside a class whose first parameter is self. When you call obj.method(), Python passes obj in as self, so the method knows which object it is working on.

सामान्य method — जिसे instance method भी कहते हैं — class के अंदर लिखा ऐसा function है जिसका पहला parameter self है। जब आप obj.method() बुलाते हैं, Python obj को self के रूप में भेजता है, ताकि method को पता रहे कि वह किस object पर काम कर रहा है।

普通方法（也叫 实例方法）是写在类里、第一个参数为 self 的函数。调用 obj.method() 时，Python 把 obj 作为 self 传进去，于是方法知道自己在处理哪个对象。

class CoffeeShop:
    def __init__(self, city):
        self.city          = city
        self.daily_revenue = 0.0
        self.orders        = []

    # -- Normal (instance) method: acts on THIS store --
    def serve(self, item, price):
        self.daily_revenue += price
        self.orders.append(item)
        print(f"[{self.city}] Served {item} for ${price}")

    # -- Another instance method that reports state --
    def summary(self):
        print(f"{self.city}: {len(self.orders)} orders, ${self.daily_revenue}")

mumbai = CoffeeShop("Mumbai")
london = CoffeeShop("London")

mumbai.serve("latte", 4.5)         # self = mumbai
mumbai.serve("muffin", 3.5)        # self = mumbai
london.serve("espresso", 3.0)      # self = london

mumbai.summary()                   # uses Mumbai's data only
london.summary()                   # uses London's data only

Notice $4.5 and $8.0: an f-string prints a float as it is, without a fixed number of decimals. Section 09 uses :.2f to always show two.

$4.5 और $8.0 देखें: f-string float को जैसा है वैसा print करती है, तय decimals के बिना। Section 09 हमेशा दो decimals दिखाने के लिए :.2f इस्तेमाल करता है।

注意 $4.5 和 $8.0：f-string 按原样打印浮点数，不固定小数位。第 09 节用 :.2f 来始终显示两位小数。

Class Variables — One Copy, Shared by Every Object 📋Class Variables — एक Copy, हर Object साझा करता है 📋类变量 — 只有一份，所有对象共享 📋

A class variable is written at the class level, not inside __init__. There is exactly one copy, and every instance can see it. Think of it as "facts about the idea of a coffee shop, not about any one shop".

Class variable class के स्तर पर लिखा जाता है, __init__ के अंदर नहीं। इसकी ठीक एक copy होती है, और हर instance इसे देख सकता है। इसे ऐसे सोचें: "coffee shop के विचार से जुड़े तथ्य, किसी एक shop के नहीं"।

类变量 写在类的层级上，而不是 __init__ 里。它只有一份，所有实例都能看到。可以把它理解为"属于咖啡店这个概念的事实，而不是某一家店的"。

class CoffeeShop:
    # -- Class variables: declared at the class level, ONE copy total --
    company_name = "Bean There"
    menu         = {"latte": 4.50, "espresso": 3.00, "muffin": 3.50}
    total_stores = 0

    def __init__(self, city):
        # -- Instance variables: one copy per object --
        self.city          = city
        self.daily_revenue = 0.0
        CoffeeShop.total_stores += 1     # bump the shared counter

mumbai = CoffeeShop("Mumbai")
london = CoffeeShop("London")
tokyo  = CoffeeShop("Tokyo")

# Read class variables through the class itself
print(CoffeeShop.company_name)
print(CoffeeShop.total_stores)
print(CoffeeShop.menu["latte"])

# You CAN also read them through any instance - they are shared
print(mumbai.company_name)
print(london.menu["latte"])
print(london.menu is CoffeeShop.menu)    # the very same dict object

print(mumbai.__dict__)                   # the class variables are NOT in here

The last line is the key: mumbai.__dict__ holds only city and daily_revenue. When you read mumbai.company_name, Python does not find it on the object, so it looks on the class. That is why one copy is enough.

आख़िरी line सबसे अहम है: mumbai.__dict__ में सिर्फ़ city और daily_revenue हैं। जब आप mumbai.company_name पढ़ते हैं, Python को यह object पर नहीं मिलता, तो वह class पर देखता है। इसीलिए एक copy काफ़ी है।

最后一行是关键：mumbai.__dict__ 里只有 city 和 daily_revenue。读取 mumbai.company_name 时，Python 在对象上找不到，就去类上找。所以一份就够了。

The Two Gotchas of Class Variables ⚠️Class Variables के दो जाल ⚠️类变量的两个陷阱 ⚠️

Class variables are simple — until you change them the wrong way. Two traps catch almost every beginner. Both come from one rule: reading falls back to the class, but writing through an object creates an instance variable.

Class variables आसान हैं — जब तक आप उन्हें ग़लत तरीक़े से न बदलें। दो जाल लगभग हर beginner को पकड़ते हैं। दोनों एक ही नियम से आते हैं: पढ़ते समय Python class पर जाता है, पर object के ज़रिए लिखने से instance variable बनता है।

类变量很简单 — 直到你用错误的方式修改它们。有两个陷阱几乎每个初学者都会踩。它们都来自同一条规则：读取时会退回到类上找，但通过对象写入会创建实例变量。

Gotcha #1 — Writing Through an Instance Creates a Shadowजाल #1 — Instance के ज़रिए लिखने से Shadow बनता है陷阱 #1 — 通过实例写入会产生遮蔽

class CoffeeShop:
    total_stores = 0              # class variable

s1 = CoffeeShop()
s2 = CoffeeShop()

# WRONG: this does NOT update the shared counter
s1.total_stores = 99              # creates a NEW instance variable on s1
print(s1.total_stores)            # s1's own attribute (the shadow)
print(s2.total_stores)            # s2 still reads the class variable
print(CoffeeShop.total_stores)    # the class variable is untouched
print(s1.__dict__, s2.__dict__)

# RIGHT: update through the class itself
CoffeeShop.total_stores = 50
print(s2.total_stores)            # s2 sees the new value
print(s1.total_stores)            # s1 still sees its own shadow!

Gotcha #2 — Mutable Class Variables Are Shared Stateजाल #2 — Mutable Class Variables साझा State हैं陷阱 #2 — 可变类变量是共享状态

class CoffeeShop:
    orders = []                   # class variable - a list (mutable!)

    def __init__(self, city):
        self.city = city

s1 = CoffeeShop("Mumbai")
s2 = CoffeeShop("London")

s1.orders.append("latte")         # changes the SHARED list in place
print(s1.orders)
print(s2.orders)                  # London "has" Mumbai's order!
print(s1.orders is s2.orders)     # the same list object

No = was used, so no shadow was made. .append() changed the one list that lives on the class. The fix is to create the list in __init__:

कोई = इस्तेमाल नहीं हुआ, इसलिए shadow नहीं बना। .append() ने class पर रहने वाली एक ही list बदल दी। हल है list को __init__ में बनाना:

这里没有用 =，所以没有产生遮蔽。.append() 修改了类上那唯一的列表。修正方法是在 __init__ 里创建列表：

class CoffeeShop:
    def __init__(self, city):
        self.city   = city
        self.orders = []          # FIX: a fresh list for every store

s1 = CoffeeShop("Mumbai")
s2 = CoffeeShop("London")
s1.orders.append("latte")
print(s1.orders, s2.orders, s1.orders is s2.orders)

🔬 Simulator: Attribute Lookup Lab🔬 Simulator: Attribute Lookup Lab🔬 模拟器：属性查找实验室

Click lines to run them, in any order. Each store card shows its own __dict__ (shadows in orange) and what reading each name finds — from the object itself, or from the class. The coloured tags show which list or dict is the same object. The model was checked against real Python on 400 random sequences.

Lines पर click करके उन्हें किसी भी क्रम में चलाएँ। हर store card उसका अपना __dict__ (shadows नारंगी में) और हर नाम पढ़ने पर क्या मिलता है, दिखाता है — object से या class से। रंगीन tags बताते हैं कि कौन-सी list या dict एक ही object है। Model को 400 random sequences पर असली Python से जाँचा गया।

点击代码行即可运行，顺序随意。每张店铺卡片显示它 自己的 __dict__（遮蔽以橙色显示），以及 读取 每个名字时找到的值 — 来自对象本身还是来自类。彩色标签表示哪些列表或字典是同一个对象。该模型已在 400 个随机序列上与真实 Python 核对过。

Class Methods — Methods That Belong to the Class 🏛️Class Methods — Class के अपने Methods 🏛️类方法 — 属于类本身的方法 🏛️

A class method is a method whose first parameter is the class itself — named cls by convention — not an object. You mark it with the @classmethod decorator on the line above def. You usually call it on the class: CoffeeShop.from_csv(...).

Class method ऐसा method है जिसका पहला parameter ख़ुद class होती है — परंपरा से cls नाम — कोई object नहीं। इसे def के ऊपर वाली line पर @classmethod decorator से चिह्नित करते हैं। आमतौर पर इसे class पर बुलाते हैं: CoffeeShop.from_csv(...)।

类方法 的第一个参数是类本身 — 按惯例命名为 cls — 而不是对象。在 def 上一行加 @classmethod 装饰器来标记它。通常在类上调用它：CoffeeShop.from_csv(...)。

Three very common uses:

तीन बहुत आम इस्तेमाल:

三种非常常见的用途：

class CoffeeShop:
    company_name = "Bean There"
    menu         = {"latte": 4.50, "espresso": 3.00}
    total_stores = 0

    def __init__(self, city, staff_count):
        self.city          = city
        self.staff_count   = staff_count
        self.daily_revenue = 0.0
        CoffeeShop.total_stores += 1

    # -- Class method as an ALTERNATE CONSTRUCTOR --
    @classmethod
    def from_csv(cls, row: str):
        """Build a CoffeeShop from a CSV row like 'Mumbai,8'."""
        city, staff = row.split(",")
        return cls(city, int(staff))       # cls(...) is CoffeeShop(...) here

    # -- Class method for a CLASS-WIDE OPERATION --
    @classmethod
    def update_price(cls, item, new_price):
        """HQ raises a price everywhere at once."""
        cls.menu[item] = new_price
        print(f"HQ: {item} is now ${new_price} at every store")

    # -- Class method for an AGGREGATE QUERY --
    @classmethod
    def how_many_open(cls):
        return cls.total_stores

mumbai = CoffeeShop("Mumbai", 8)                 # regular constructor
london = CoffeeShop.from_csv("London,12")        # alternate constructor
tokyo  = CoffeeShop.from_csv("Tokyo,20")

CoffeeShop.update_price("latte", 5.00)           # class-wide operation

print(CoffeeShop.how_many_open())                # aggregate query
print(mumbai.menu["latte"])                      # Mumbai sees the update
print(london.city, london.staff_count, type(london).__name__)
print(mumbai.how_many_open())                    # also works through an object

The last line shows that a class method can also be called through an object. Python still passes the class as cls.

आख़िरी line दिखाती है कि class method को object के ज़रिए भी बुला सकते हैं। Python फिर भी cls के रूप में class ही भेजता है।

最后一行表明，类方法也可以通过对象调用。Python 仍然把 类 作为 cls 传入。

🎯 Simulator: Who Receives What?🎯 Simulator: किसे क्या मिलता है?🎯 模拟器：谁接收了什么？

Pick a call. The card that lands in the first parameter lights up with a self or cls badge, and the method's def line is highlighted. Each call starts from the same three stores and was recorded from a real Python run. (The PremiumCoffeeShop call is explained in Section 07.)

कोई call चुनें। पहले parameter में पहुँचने वाला card self या cls badge के साथ चमकता है, और method की def line हाइलाइट होती है। हर call उन्हीं तीन stores से शुरू होती है और असली Python run से रिकॉर्ड की गई। (PremiumCoffeeShop वाली call Section 07 में समझाई गई है।)

选一个调用。进入第一个参数的那张卡片会亮起 self 或 cls 标记，方法的 def 行也会高亮。每个调用都从同样的三家店开始，并由真实 Python 运行记录。（PremiumCoffeeShop 的调用在第 07 节解释。）

Why cls and Not Just CoffeeShop? 🧬cls क्यों, सीधे CoffeeShop क्यों नहीं? 🧬为什么用 cls 而不直接写 CoffeeShop？🧬

Inside a class method you could type the class name directly. But cls always means the class the method was actually called on. That matters when another class is built from this one (a subclass — a topic of its own, coming later). Here is the difference in one run:

Class method के अंदर आप class का नाम सीधे लिख सकते हैं। पर cls का मतलब हमेशा वह class है जिस पर method असल में बुलाया गया। यह तब मायने रखता है जब इस class से कोई दूसरी class बनाई जाए (subclass — यह अपना अलग topic है, आगे आएगा)। एक run में फ़र्क़ देखें:

在类方法里，你 可以 直接写类名。但 cls 永远表示方法 实际被调用 的那个类。当另一个类由这个类派生出来时（子类 — 这是单独的主题，以后会讲），这一点就很重要。看一次运行就明白了：

class CoffeeShop:
    company_name = "Bean There"

    def __init__(self, city, staff_count):
        self.city        = city
        self.staff_count = staff_count

    @classmethod
    def from_csv(cls, row):
        city, staff = row.split(",")
        return cls(city, int(staff))    # uses cls, not CoffeeShop

class PremiumCoffeeShop(CoffeeShop):    # a subclass
    company_name = "Bean There Premium"

# Because from_csv uses cls, this returns a PremiumCoffeeShop
p = PremiumCoffeeShop.from_csv("Milan,10")
print(type(p).__name__)
print(p.company_name)
print(p.city, p.staff_count)

Now the same code with the class name typed in by hand:

अब वही code, class का नाम हाथ से लिखा हुआ:

再看同样的代码，但手动写死类名：

class CoffeeShop:
    company_name = "Bean There"

    def __init__(self, city, staff_count):
        self.city        = city
        self.staff_count = staff_count

    @classmethod
    def from_csv(cls, row):
        city, staff = row.split(",")
        return CoffeeShop(city, int(staff))    # hard-coded class name

class PremiumCoffeeShop(CoffeeShop):
    company_name = "Bean There Premium"

p = PremiumCoffeeShop.from_csv("Milan,10")
print(type(p).__name__)                         # the wrong type!
print(p.company_name)

Instance Method vs Class Method — At a Glance 👀Instance Method बनाम Class Method — एक नज़र में 👀实例方法与类方法 — 一览对比 👀

Complete Practical Example — All Three Together ☕पूरा व्यावहारिक उदाहरण — तीनों एक साथ ☕完整实例 — 三者合一 ☕

One class that uses instance methods, class variables and class methods in a small, realistic example. Paste it, run it, and read it line by line.

एक class जो instance methods, class variables और class methods को एक छोटे, असली उदाहरण में इस्तेमाल करती है। Paste करें, चलाएँ, और line-by-line पढ़ें।

一个在小而真实的例子里同时使用实例方法、类变量和类方法的类。粘贴、运行，然后逐行阅读。

class CoffeeShop:
    # == CLASS VARIABLES - shared across every store ==
    company_name = "Bean There"
    menu         = {"latte": 4.50, "espresso": 3.00, "muffin": 3.50}
    tax_rate     = 0.10
    total_stores = 0

    def __init__(self, city, staff_count):
        # == INSTANCE VARIABLES - one copy per store ==
        self.city          = city
        self.staff_count   = staff_count
        self.daily_revenue = 0.0
        self.orders        = []               # a fresh list per store
        CoffeeShop.total_stores += 1

    # == INSTANCE METHOD - acts on THIS store ==
    def serve(self, item):
        if item not in CoffeeShop.menu:
            raise ValueError(f"{item} not on menu")
        price = CoffeeShop.menu[item] * (1 + CoffeeShop.tax_rate)
        self.daily_revenue += price
        self.orders.append(item)
        print(f"[{self.city}] Served {item} for ${price:.2f}")

    # == INSTANCE METHOD - reports THIS store's state ==
    def report(self):
        print(f"{self.city:8s}  orders={len(self.orders):2d}  "
              f"revenue=${self.daily_revenue:7.2f}")

    # == CLASS METHOD - alternate constructor ==
    @classmethod
    def from_csv(cls, row: str):
        city, staff = row.split(",")
        return cls(city.strip(), int(staff))

    # == CLASS METHOD - HQ changes shared state ==
    @classmethod
    def update_price(cls, item, new_price):
        cls.menu[item] = new_price
        print(f"HQ: {item} is now ${new_price:.2f} everywhere")

    # == CLASS METHOD - aggregate query ==
    @classmethod
    def chain_stats(cls):
        return f"{cls.company_name}: {cls.total_stores} stores open"

# -- Open three stores - two ways --
mumbai = CoffeeShop("Mumbai", 8)                # normal constructor
london = CoffeeShop.from_csv("London, 12")      # class-method constructor
tokyo  = CoffeeShop.from_csv("Tokyo, 20")

# -- Serve some drinks (instance methods on each store) --
mumbai.serve("latte")
mumbai.serve("muffin")
london.serve("espresso")
tokyo.serve("latte")

# -- HQ raises the latte price (class method -> class variable) --
CoffeeShop.update_price("latte", 5.00)
tokyo.serve("latte")    # now costs $5.00 + tax

print()
for store in (mumbai, london, tokyo):
    store.report()
print()
print(CoffeeShop.chain_stats())

The two empty lines in the output come from the two bare print() calls. Note the prices: 4.50 × 1.1 = 4.95, and after the price change 5.00 × 1.1 = 5.50.

Output की दो ख़ाली lines दो ख़ाली print() calls से आती हैं। Prices देखें: 4.50 × 1.1 = 4.95, और price बदलने के बाद 5.00 × 1.1 = 5.50।

输出中的两个空行来自两次空的 print() 调用。看看价格：4.50 × 1.1 = 4.95，调价后 5.00 × 1.1 = 5.50。

☕ Simulator: Run the Coffee Chain☕ Simulator: Coffee Chain चलाएँ☕ 模拟器：经营咖啡连锁

This is the class above, live. Serve drinks at any store, change a price at HQ, open a new store from a CSV row, then print the reports. Watch which card lights up: a store (self) or the class (cls). Every output line matches real Python — checked on 300 random sequences.

यह ऊपर वाली class है, live। किसी भी store पर drinks serve करें, HQ पर price बदलें, CSV row से नया store खोलें, फिर reports print करें। देखें कौन-सा card चमकता है: कोई store (self) या class (cls)। हर output line असली Python से मिलती है — 300 random sequences पर जाँची गई।

这就是上面那个类，实时运行。在任意门店出售饮品，在总部改价，用 CSV 行开新店，然后打印报告。留意哪张卡片亮起：某家店（self）还是类（cls）。每一行输出都与真实 Python 一致 — 已在 300 个随机序列上核对。

When to Use Which — Decision Grid 🧭कब कौन-सा — Decision Grid 🧭何时用哪个 — 决策表 🧭

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

class Shop:
    total = 0
    def hello():                      # forgot self
        print("hi")

try:
    Shop().hello()
except TypeError as e:
    print("1. TypeError:", e)

class Shop2:
    def __init__(self, city):
        self.city = city
    def from_csv(cls, row):           # forgot @classmethod
        return cls(row)

try:
    Shop2.from_csv("Mumbai")
except TypeError as e:
    print("2. TypeError:", e)

class Shop3:
    def __init__(self, city):
        self.city = city
    def label(self):
        return self.city.upper()

s = Shop3("Pune")
print("3.", s.label)                  # forgot the ()
print("3. fixed:", s.label())

🩺 Simulator: Bug Doctor🩺 Simulator: Bug Doctor🩺 模拟器：Bug 医生

Pick a mistake. The buggy version is on the left, the fixed one on the right, with the changed lines marked. Both outputs are real. Note that three of the six bugs give no error at all — they just quietly give wrong results.

कोई ग़लती चुनें। बाईं ओर buggy version है, दाईं ओर ठीक किया हुआ, बदली हुई lines चिह्नित। दोनों outputs असली हैं। ध्यान दें: छह में से तीन bugs कोई error नहीं देते — बस चुपचाप ग़लत नतीजे देते हैं।

选一个错误。左边是有 bug 的版本，右边是修正后的版本，改动的行已标出。两边的输出都是真实的。注意：六个 bug 中有三个 完全不报错 — 只是悄悄给出错误结果。

Quick Reference 📋Quick Reference 📋速查表 📋

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

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