Python OOP — Method Overriding, Static Methods & Static Variables

The Story That Ties These Three Ideas Together ☕इन तीन विचारों को जोड़ने वाली कहानी ☕把三个概念串起来的故事 ☕

Meet All Three at a Glance 👀तीनों से एक नज़र में मिलिए 👀一眼认识三者 👀

Static Variables — The Shop's Posted Rules 📌Static Variables — Shop के लगे हुए नियम 📌静态变量 — 店里张贴的规则 📌

A static variable is a value written directly under the class line, not inside __init__. There is exactly one copy in memory, and every instance reads it.

Static variable एक value है जो सीधे class line के नीचे लिखी जाती है, __init__ के अंदर नहीं। Memory में ठीक एक copy होती है, और हर instance उसे पढ़ता है।

静态变量是直接写在 class 行下面的值，而不是写在 __init__ 里。内存中只有 一份，每个实例都读取它。

class Drink:
    # == STATIC VARIABLES - one copy, shared by every drink ==
    STANDARD_CUP_ML = 250
    MAX_BREW_TEMP_C = 95
    TAX_RATE        = 0.10
    CURRENCY        = "$"

    def __init__(self, base_price):
        # INSTANCE variables - one per drink
        self.base_price = base_price

# Read via the class (the usual form)
print(Drink.STANDARD_CUP_ML)
print(Drink.TAX_RATE)
print(Drink.CURRENCY)

# Every instance sees the same value - it is not copied per drink
d1 = Drink(3); d2 = Drink(5); d3 = Drink(4)
print(d1.TAX_RATE, d2.TAX_RATE, d3.TAX_RATE)
print(d1.__dict__)                     # only base_price lives on the object

The last line shows that TAX_RATE is not stored on the drink. Python finds it on the class.

आख़िरी line दिखाती है कि TAX_RATE drink पर रखा ही नहीं है। Python उसे class पर पाता है।

最后一行表明 TAX_RATE 并不存放在饮品对象上。Python 是在类上找到它的。

class Drink:
    TAX_RATE = 0.10
    def __init__(self, base_price):
        self.base_price = base_price

espresso, latte = Drink(3), Drink(5)

latte.TAX_RATE = 0.15            # WRONG: makes a shadow on latte only
print(latte.TAX_RATE, espresso.TAX_RATE, Drink.TAX_RATE)
print(latte.__dict__)

Drink.TAX_RATE = 0.12            # through the class: everyone without a shadow sees it
print(latte.TAX_RATE, espresso.TAX_RATE, Drink.TAX_RATE)

🪞 Simulator: Shadow Lab🪞 Simulator: Shadow Lab🪞 模拟器：遮蔽实验室

Run lines in any order. Each drink shows what drink.TAX_RATE reads and where it comes from. The two price rows show something surprising: the static method calculate_total reads Drink.TAX_RATE, so it ignores a shadow — but code that reads self.TAX_RATE does not. Checked against real Python on 300 random sequences.

Lines किसी भी क्रम में चलाएँ। हर drink दिखाता है कि drink.TAX_RATE क्या पढ़ता है और वह कहाँ से आता है। दो price rows एक हैरान करने वाली बात दिखाती हैं: static method calculate_total Drink.TAX_RATE पढ़ता है, इसलिए shadow को नज़रअंदाज़ करता है — पर self.TAX_RATE पढ़ने वाला code नहीं करता। असली Python से 300 random sequences पर जाँचा गया।

以任意顺序运行代码行。每杯饮品显示 drink.TAX_RATE 读到的值及其来源。两行价格揭示了一个意外：静态方法 calculate_total 读取的是 Drink.TAX_RATE，所以它会 忽略 遮蔽 — 而读取 self.TAX_RATE 的代码不会。已在 300 个随机序列上与真实 Python 核对。

Static Methods — The Shared Utility Shelf 🔧Static Methods — साझा औज़ारों की Shelf 🔧静态方法 — 共享的工具架 🔧

A static method is written with the @staticmethod decorator and takes no self and no cls. It is a plain function that happens to live inside the class. Use it for validators, converters, formatters and pure calculations.

Static method @staticmethod decorator के साथ लिखा जाता है और न self लेता है न cls। यह एक सादा function है जो बस class के अंदर रहता है। इसे validators, converters, formatters और शुद्ध गणनाओं के लिए इस्तेमाल करें।

静态方法用 @staticmethod 装饰器来写，不接收 self，也不接收 cls。它是一个恰好住在类里的普通函数。适合校验器、换算器、格式化函数和纯计算。

class Drink:
    STANDARD_CUP_ML = 250
    TAX_RATE        = 0.10

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

    # == STATIC METHOD - pure input -> output, no self, no cls ==
    @staticmethod
    def celsius_to_fahrenheit(c):
        return c * 9 / 5 + 32

    @staticmethod
    def is_valid_size(size_ml):
        return 25 <= size_ml <= 500

    @staticmethod
    def calculate_total(price):
        # Uses the class-level constant - but needs no self or cls
        return price * (1 + Drink.TAX_RATE)

# Call BEFORE any drink exists - that is the whole point
print(Drink.celsius_to_fahrenheit(65))
print(Drink.is_valid_size(200))
print(Drink.is_valid_size(1000))
print(Drink.calculate_total(5.00))          # with 10% tax

latte = Drink(5)
print(latte.celsius_to_fahrenheit(65))      # also works through an instance

⚙️ Simulator: Static Method Machine⚙️ Simulator: Static Method Machine⚙️ 模拟器：静态方法机器

Pick a static method and drag the input. Then try two things: call it through an object, and remove the decorator. Every output matches real Python on the whole slider range.

कोई static method चुनें और input खिसकाएँ। फिर दो चीज़ें आज़माएँ: इसे object के ज़रिए बुलाएँ, और decorator हटा दें। हर output पूरी slider range पर असली Python से मिलता है।

选一个静态方法，拖动输入。然后试两件事：通过对象 调用它，以及 去掉装饰器。在整个滑块范围内，每个输出都与真实 Python 一致。

Method Overriding — Same Call, Different Behaviour 🔁Method Overriding — एक Call, अलग व्यवहार 🔁方法重写 — 同样的调用，不同的行为 🔁

Method overriding happens when a child class defines a method with the same name as one in its parent. When the method is called on the child, Python uses the child's version, and the parent's version is not used. This is what makes polymorphism possible: many types respond to the same command in different ways.

Method overriding तब होता है जब child class अपने parent जैसे नाम का method define करती है। Child पर method बुलाने पर Python child का version इस्तेमाल करता है, parent वाला नहीं। इसी से polymorphism संभव होता है: कई types एक ही आदेश पर अलग-अलग तरह से जवाब देते हैं।

当子类定义了一个与父类方法 同名 的方法时，就发生了 方法重写。在子类上调用该方法时，Python 使用 子类的版本，父类的版本不会被用到。这让 多态 成为可能：多种类型对同一个命令做出不同的响应。

class Drink:
    def __init__(self, size_ml, base_price):
        self.size_ml    = size_ml
        self.base_price = base_price

    # A generic prepare() - subclasses will override this
    def prepare(self):
        print("Preparing a generic drink - hot water in a cup.")

class Espresso(Drink):
    # -- OVERRIDE - same name, brand-new implementation --
    def prepare(self):
        print(f"Espresso ({self.size_ml}ml): grind beans, tamp, extract 25s.")

class Latte(Drink):
    def prepare(self):
        print(f"Latte ({self.size_ml}ml): pull espresso, steam milk to 65°C, pour art.")

class Cappuccino(Drink):
    def prepare(self):
        print(f"Cappuccino ({self.size_ml}ml): equal parts espresso, milk, foam.")

# Same call, different result - that is polymorphism
for drink in [Espresso(30, 3), Latte(250, 5), Cappuccino(180, 4.5)]:
    drink.prepare()

print([c.__name__ for c in Espresso.mro()])   # where Python searches

🍹 Simulator: One Call, Many Drinks🍹 Simulator: एक Call, कई Drinks🍹 模拟器：一次调用，多种饮品

These are the classes from the complete example in Section 07. Pick a drink to see where prepare() and price_receipt() are found. Then build a menu and press Run loop: the same drink.prepare() call goes to a different class each time. All outputs are real.

ये Section 07 के पूरे उदाहरण की classes हैं। कोई drink चुनें और देखें कि prepare() और price_receipt() कहाँ मिलते हैं। फिर menu बनाएँ और Run loop दबाएँ: वही drink.prepare() call हर बार अलग class तक जाती है। सभी outputs असली हैं।

这些是第 07 节完整示例中的类。选一杯饮品，看看 prepare() 和 price_receipt() 在哪里被找到。然后搭一份菜单，按 Run loop：同一个 drink.prepare() 调用每次都会走到不同的类。所有输出都是真实的。

Override + Extend — Using super() to Keep the Parent's Behaviour 🧩Override + Extend — Parent का व्यवहार रखने के लिए super() 🧩重写 + 扩展 — 用 super() 保留父类行为 🧩

Sometimes you do not want to replace the parent's method — you want to extend it. Call super().method() inside your override to run the parent's version first, then add your own steps.

कभी-कभी आप parent का method replace नहीं करना चाहते — उसे extend करना चाहते हैं। अपने override के अंदर super().method() बुलाएँ ताकि पहले parent का version चले, फिर अपने steps जोड़ें।

有时你并不想 替换 父类的方法 — 而是想 扩展 它。在你的重写中调用 super().method()，先运行父类版本，再加上你自己的步骤。

class Drink:
    def __init__(self, size_ml, base_price):
        self.size_ml    = size_ml
        self.base_price = base_price

    def prepare(self):
        print("  1. Warm the cup")
        print("  2. Fill with liquid")

class FlavouredLatte(Drink):
    def __init__(self, size_ml, base_price, syrup):
        super().__init__(size_ml, base_price)
        self.syrup = syrup

    def prepare(self):
        super().prepare()                       # run the parent's steps first
        print(f"  3. Add {self.syrup} syrup")   # then extend
        print("  4. Steam milk and pour")

drink = FlavouredLatte(250, 5.50, syrup="vanilla")
drink.prepare()

🧩 Simulator: Replace vs Extend🧩 Simulator: Replace बनाम Extend🧩 模拟器：替换与扩展

Switch between the two versions of FlavouredLatte.prepare() and step through each. With extend, watch super().prepare() open the parent's frame on top of the stack, print steps 1–2, then return. With replace, the parent's prepare() is never called. Recorded with sys.settrace.

FlavouredLatte.prepare() के दोनों versions में बदलें और हर एक को step करें। Extend में देखें कि super().prepare() stack के ऊपर parent का frame खोलता है, steps 1–2 print करता है, फिर लौटता है। Replace में parent का prepare() कभी बुलाया ही नहीं जाता। sys.settrace से रिकॉर्ड।

在 FlavouredLatte.prepare() 的两个版本之间切换，并逐步运行。在 扩展 版本中，看 super().prepare() 在栈顶打开父类的帧，打印第 1–2 步，然后返回。在 替换 版本中，父类的 prepare() 根本不会被调用。由 sys.settrace 记录。

Putting All Three Together — The Complete Coffee Shop 🏪तीनों एक साथ — पूरी Coffee Shop 🏪三者合一 — 完整的咖啡店 🏪

One family of classes that uses static variables (shop rules), static methods (utility functions) and method overriding (each drink's own preparation). This is the real payoff.

Classes का एक परिवार जो static variables (shop के नियम), static methods (utility functions) और method overriding (हर drink का अपना तरीक़ा) इस्तेमाल करता है। यही असली फ़ायदा है।

一个类家族，同时使用静态变量（店规）、静态方法（工具函数）和方法重写（每款饮品自己的做法）。这才是真正的收获。

class Drink:
    # == STATIC VARIABLES - shared across every drink and every subclass ==
    STANDARD_CUP_ML = 250
    MAX_BREW_TEMP_C = 95
    TAX_RATE        = 0.10
    CURRENCY        = "$"

    def __init__(self, size_ml, base_price):
        if not Drink.is_valid_size(size_ml):     # uses a STATIC METHOD
            raise ValueError(f"{size_ml}ml is out of range")
        self.size_ml    = size_ml
        self.base_price = base_price

    # -- Generic prepare - subclasses OVERRIDE this --
    def prepare(self):
        print("Generic drink: hot water, done.")

    # -- Instance method - uses a static variable for its calculation --
    def price_receipt(self):
        total = Drink.calculate_total(self.base_price)
        return f"  Price: {Drink.CURRENCY}{self.base_price:.2f} + tax → {Drink.CURRENCY}{total:.2f}"

    # == STATIC METHODS - utility functions grouped with the class ==
    @staticmethod
    def is_valid_size(size_ml):
        return 25 <= size_ml <= 500

    @staticmethod
    def celsius_to_fahrenheit(c):
        return c * 9 / 5 + 32

    @staticmethod
    def calculate_total(price):
        return price * (1 + Drink.TAX_RATE)

class Espresso(Drink):
    def __init__(self):
        super().__init__(size_ml=30, base_price=3.00)

    # OVERRIDE - Espresso has its own steps
    def prepare(self):
        print(f"[Espresso {self.size_ml}ml] grind → tamp → extract for 25s")

class Latte(Drink):
    def __init__(self):
        super().__init__(size_ml=250, base_price=5.00)

    def prepare(self):
        temp_f = Drink.celsius_to_fahrenheit(65)     # uses a STATIC METHOD
        print(f"[Latte {self.size_ml}ml] pull espresso → steam milk to 65°C ({temp_f}°F) → pour art")

class Cappuccino(Drink):
    def __init__(self):
        super().__init__(size_ml=180, base_price=4.50)

    def prepare(self):
        print(f"[Cappuccino {self.size_ml}ml] equal parts espresso + steamed milk + foam")

class FlavouredLatte(Latte):
    def __init__(self, syrup):
        super().__init__()
        self.syrup = syrup
        self.base_price += 0.75              # flavour surcharge

    # OVERRIDE + EXTEND - run the parent's Latte prepare, then add the syrup step
    def prepare(self):
        super().prepare()
        print(f"              → finish with {self.syrup} syrup")

# -- Use the static methods BEFORE any drink exists --
print("Valid 150ml cup?", Drink.is_valid_size(150))
print("Valid 900ml cup?", Drink.is_valid_size(900))
print("Brew temp in F:", Drink.celsius_to_fahrenheit(Drink.MAX_BREW_TEMP_C))
print()

# -- Same loop, each drink runs its own prepare() --
menu = [Espresso(), Latte(), Cappuccino(), FlavouredLatte(syrup="vanilla")]
for drink in menu:
    drink.prepare()                 # goes to the right override
    print(drink.price_receipt())    # inherited from Drink, uses a static var + method
    print()

When to Reach for Each Tool — Decision Grid 🧭कब कौन-सा Tool — Decision Grid 🧭何时用哪个工具 — 决策表 🧭

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

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

Six of these mistakes, run for real. Buggy code on the left, fixed code on the right, changed lines marked. Three of them give no error at all.

इनमें से छह ग़लतियाँ, असली run में। बाईं ओर buggy code, दाईं ओर ठीक किया हुआ, बदली lines चिह्नित। इनमें से तीन कोई error नहीं देतीं।

其中六个错误的真实运行。左边是有 bug 的代码，右边是修正后的代码，改动的行已标出。其中三个 完全不报错。

Quick Reference 📋Quick Reference 📋速查表 📋

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

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