Python OOP — Inheritance, super(), and Method Overriding Explained

The Story That Explains Inheritance 🍞Inheritance समझाने वाली कहानी 🍞一个讲清继承的故事 🍞

Why We Need Inheritance — Don't Repeat Yourself ♻️Inheritance क्यों चाहिए — ख़ुद को न दोहराएँ ♻️为什么需要继承 — 不要重复自己 ♻️

Suppose you model three kinds of vehicles. Without inheritance, you write the same brand, wheels, speed and start() code three times. Change something? Update three places. Add a fourth vehicle? Copy-paste again. Bugs creep in, and the copies slowly drift apart. This idea — write it once — is called DRY: Don't Repeat Yourself.

मान लीजिए आप तीन तरह के vehicles model करते हैं। Inheritance के बिना आप वही brand, wheels, speed और start() code तीन बार लिखते हैं। कुछ बदलना है? तीन जगह update करें। चौथा vehicle जोड़ना है? फिर copy-paste। Bugs घुसते हैं, और copies धीरे-धीरे अलग हो जाती हैं। यह विचार — एक बार लिखो — DRY कहलाता है: Don't Repeat Yourself।

假设你要为三种交通工具建模。没有继承，你就得把同样的 brand、wheels、speed 和 start() 代码写三遍。要改点什么？改三处。再加第四种？再复制粘贴一次。bug 会混进来，各个副本也会慢慢走样。"只写一次"的思想叫 DRY：Don't Repeat Yourself（不要重复自己）。

Basic Syntaxबुनियादी Syntax基本语法

# -- Parent class (also called base class or superclass) --
class Vehicle:
    def __init__(self, brand, wheels):
        self.brand  = brand
        self.wheels = wheels

    def start(self):
        print(f"{self.brand} engine starting...")

# -- Child class: put the parent in parentheses --
class Car(Vehicle):     # "Car IS-A Vehicle"
    pass                # nothing new yet - but it already has __init__ and start()

my_car = Car("Honda", 4)     # uses Vehicle's __init__
my_car.start()               # uses Vehicle's start()
print(my_car.brand)
print(my_car.wheels)
print("start" in Car.__dict__, "start" in Vehicle.__dict__)   # where start() really lives

The last line proves the point: start is not stored in Car at all. It lives only in Vehicle, and Python finds it there. The parent is also called the base class or superclass; the child is the subclass.

आख़िरी line बात साबित करती है: start Car में रखा ही नहीं है। वह सिर्फ़ Vehicle में है, और Python उसे वहीं पाता है। Parent को base class या superclass भी कहते हैं; child को subclass।

最后一行证明了这一点：start 根本不在 Car 里。它只存在于 Vehicle 中，Python 在那里找到它。父类也叫 基类（base class） 或 超类（superclass）；子类叫 subclass。

The Inheritance Tree 🌳Inheritance Tree 🌳继承树 🌳

Three levels: Vehicle at the top, Car in the middle, ElectricCar at the bottom. Each child gets everything above it and adds its own. On the right, one tesla object shows everything it can reach.

तीन स्तर: सबसे ऊपर Vehicle, बीच में Car, नीचे ElectricCar। हर child को ऊपर का सब कुछ मिलता है और वह अपना जोड़ता है। दाईं ओर एक tesla object दिखाता है कि वह किन-किन तक पहुँच सकता है।

三层结构：顶部是 Vehicle，中间是 Car，底部是 ElectricCar。每个子类获得上面的一切，再加上自己的。右边的一个 tesla 对象展示了它能访问的全部内容。

Extending — Adding New Attributes and Methods ➕Extending — नए Attributes और Methods जोड़ना ➕扩展 — 添加新的属性和方法 ➕

Inheriting is only half the story. The real power of a child class is to add its own attributes and methods without touching the parent. The child has everything the parent has, plus whatever you define.

Inherit करना आधी कहानी है। Child class की असली ताक़त है parent को छुए बिना अपने attributes और methods जोड़ना। Child के पास parent का सब कुछ है, और जो आप define करें वह भी।

继承只是故事的一半。子类真正的威力在于不改动父类就能 添加 自己的属性和方法。子类拥有父类的一切，再加上你定义的内容。

class Vehicle:
    def __init__(self, brand, wheels):
        self.brand  = brand
        self.wheels = wheels
        self.speed  = 0

    def accelerate(self, amount):
        self.speed += amount
        print(f"{self.brand} now at {self.speed} km/h")

class Car(Vehicle):
    def __init__(self, brand, doors, fuel_type):
        # Call the parent's __init__ first - super() is explained in Section 06
        super().__init__(brand, wheels=4)
        # Now add child-specific instance variables
        self.doors     = doors
        self.fuel_type = fuel_type

    # A brand-new method that only Car has
    def open_doors(self):
        print(f"Opening all {self.doors} doors of the {self.brand}")

honda = Car("Honda Civic", doors=4, fuel_type="petrol")
honda.accelerate(50)         # inherited from Vehicle
honda.open_doors()           # brand-new on Car
print(honda.wheels)          # set by the parent's __init__
print(honda.fuel_type)       # added by the child
print(honda.__dict__)        # one object holds both layers

honda.__dict__ shows one object with both layers: brand, wheels and speed were set by Vehicle.__init__; doors and fuel_type by Car.__init__.

honda.__dict__ दोनों layers वाला एक object दिखाता है: brand, wheels और speed को Vehicle.__init__ ने set किया; doors और fuel_type को Car.__init__ ने।

honda.__dict__ 显示了一个同时包含两层数据的对象：brand、wheels 和 speed 由 Vehicle.__init__ 设置；doors 和 fuel_type 由 Car.__init__ 设置。

Method Overriding — Replacing the Parent's Behaviour 🔁Method Overriding — Parent का व्यवहार बदलना 🔁方法重写 — 替换父类的行为 🔁

Sometimes the parent's method is not right for the child. An electric car does not start with a roar — it starts silently. Instead of adding a new method, the child redefines a method with the same name. This is called overriding.

कभी-कभी parent का method child के लिए सही नहीं होता। Electric car दहाड़ के साथ start नहीं होती — चुपचाप start होती है। नया method जोड़ने की जगह child उसी नाम का method दोबारा define करता है। इसे overriding कहते हैं।

有时父类的方法并不适合子类。电动车不会轰鸣着启动 — 它安静地启动。子类不是新增方法，而是 用同样的名字重新定义一个方法。这叫 重写（overriding）。

class Car:
    def __init__(self, brand):
        self.brand = brand

    def start(self):
        print(f"{self.brand} engine starts with a ROAR!")

class ElectricCar(Car):
    # Same method name -> this REPLACES the parent's start()
    def start(self):
        print(f"{self.brand} powers on silently. Ready to drive.")

petrol   = Car("Honda")
electric = ElectricCar("Tesla")

petrol.start()
electric.start()

This search order is called the Method Resolution Order (MRO). Every class can show it to you:

खोज के इस क्रम को Method Resolution Order (MRO) कहते हैं। हर class इसे दिखा सकती है:

这个查找顺序叫 方法解析顺序（MRO）。每个类都能把它显示出来：

class Vehicle: pass
class Car(Vehicle): pass
class ElectricCar(Car): pass

print(ElectricCar.mro())
print([c.__name__ for c in ElectricCar.mro()])   # just the names

🔎 Simulator: Method Lookup Explorer🔎 Simulator: Method Lookup Explorer🔎 模拟器：方法查找探索器

Pick an object and a name. Watch Python check the object's own data first, then each class in the MRO, until the first match. Try charge on the bike, or fly on anything. All 24 results come from real Python (the classes are the ones from Section 08).

कोई object और कोई नाम चुनें। देखें कि Python पहले object का अपना data देखता है, फिर MRO की हर class, जब तक पहला match न मिले। Bike पर charge या किसी पर भी fly आज़माएँ। सभी 24 नतीजे असली Python से हैं (classes वही हैं जो Section 08 में हैं)।

选一个对象和一个名字。看 Python 先查对象自己的数据，再依次查 MRO 中的每个类，直到第一个匹配。试试在 bike 上调用 charge，或在任意对象上调用 fly。全部 24 个结果都来自真实 Python（所用的类与第 08 节相同）。

super() — Reaching Back to the Parent 🪜super() — Parent तक वापस पहुँचना 🪜super() — 回头调用父类 🪜

When you override a method but still want the parent's behaviour plus your own, use super(). It lets you call the parent's version first, then add to it.

जब आप method override करते हैं पर parent का व्यवहार भी चाहिए, साथ में अपना भी, तो super() इस्तेमाल करें। इससे आप पहले parent का version बुलाते हैं, फिर उसमें जोड़ते हैं।

当你重写了一个方法，但仍想要父类的行为 再加上 你自己的，就用 super()。它让你先调用父类的版本，再在此基础上追加。

class Vehicle:
    def __init__(self, brand, wheels):
        self.brand  = brand
        self.wheels = wheels
        print(f"  [Vehicle] set brand={brand}, wheels={wheels}")

    def describe(self):
        return f"{self.brand} with {self.wheels} wheels"

class Car(Vehicle):
    def __init__(self, brand, doors):
        super().__init__(brand, wheels=4)   # call the parent's __init__ first
        self.doors = doors
        print(f"  [Car] added doors={doors}")

    def describe(self):
        # EXTEND the parent's describe() instead of replacing it
        base = super().describe()
        return f"{base}, {self.doors} doors"

class ElectricCar(Car):
    def __init__(self, brand, doors, battery_kwh):
        super().__init__(brand, doors)            # chain up to Car -> Vehicle
        self.battery_kwh = battery_kwh
        print(f"  [ElectricCar] added battery_kwh={battery_kwh}")

    def describe(self):
        base = super().describe()                 # Car's describe -> Vehicle's describe
        return f"{base}, {self.battery_kwh} kWh battery"

print("Creating Tesla...")
tesla = ElectricCar("Tesla Model 3", doors=4, battery_kwh=75)
print()
print(tesla.describe())

🪜 Simulator: super() Chain Stepper🪜 Simulator: super() Chain Stepper🪜 模拟器：super() 调用链逐步演示

Step through a real run. Watch the call stack grow as each super() climbs one level up — every frame has the same self — then shrink as each level finishes and the child continues. Then describe() does the same climb. Recorded from real Python with sys.settrace.

एक असली run को step करें। देखें कि हर super() के एक स्तर ऊपर चढ़ने पर call stack बढ़ता है — हर frame में वही self है — फिर हर स्तर के पूरा होने पर घटता है और child आगे बढ़ता है। फिर describe() भी ऐसे ही चढ़ता है। असली Python से sys.settrace द्वारा रिकॉर्ड।

逐步运行一次真实的程序。看着每次 super() 向上爬一层时 调用栈 变高 — 每个帧里都是 同一个 self — 然后每层完成时栈变矮，子类继续执行。接着 describe() 也同样向上爬。由 sys.settrace 从真实 Python 记录。

Types of Inheritance 🧩Inheritance के प्रकार 🧩继承的类型 🧩

Complete Practical Example — Vehicle Hierarchy 🚗पूरा व्यावहारिक उदाहरण — Vehicle Hierarchy 🚗完整实例 — 交通工具层次结构 🚗

A full three-level chain using everything so far: inheritance, extending, overriding and super() chaining. Ready to paste and run.

अब तक की हर चीज़ इस्तेमाल करती एक पूरी तीन-स्तर chain: inheritance, extending, overriding और super() chaining। Paste करें और चलाएँ।

一条完整的三层继承链，用上了目前学过的一切：继承、扩展、重写和 super() 链式调用。可以直接粘贴运行。

class Vehicle:
    """Base class - everything on wheels shares this."""
    def __init__(self, brand, wheels):
        self.brand  = brand
        self.wheels = wheels
        self.speed  = 0

    def start(self):
        print(f"{self.brand} engine starts with a ROAR!")

    def accelerate(self, amount):
        self.speed += amount
        print(f"{self.brand} → {self.speed} km/h")

    def info(self):
        return f"{self.brand} · {self.wheels} wheels · {self.speed} km/h"

class Car(Vehicle):
    """A Car is a Vehicle with doors and a fuel type."""
    def __init__(self, brand, doors, fuel_type):
        super().__init__(brand, wheels=4)     # the parent handles brand/wheels/speed
        self.doors     = doors
        self.fuel_type = fuel_type

    def open_doors(self):
        print(f"{self.brand}: opening {self.doors} doors")

    def info(self):
        # EXTEND the parent's info - don't rewrite it
        return super().info() + f" · {self.doors} doors · {self.fuel_type}"

class ElectricCar(Car):
    """An ElectricCar is a Car powered by a battery."""
    def __init__(self, brand, doors, battery_kwh):
        super().__init__(brand, doors, fuel_type="electric")
        self.battery_kwh  = battery_kwh
        self.charge_level = 100

    # OVERRIDE - electric cars start silently
    def start(self):
        print(f"{self.brand} powers on silently — battery at {self.charge_level}%")

    # A new method only on ElectricCar
    def charge(self, amount):
        self.charge_level = min(100, self.charge_level + amount)
        print(f"{self.brand} charged to {self.charge_level}%")

    def info(self):
        return super().info() + f" · {self.battery_kwh} kWh · {self.charge_level}% charged"

# -- Create one of each --
honda = Car("Honda Civic", doors=4, fuel_type="petrol")
tesla = ElectricCar("Tesla Model 3", doors=4, battery_kwh=75)

# -- Start each - the override is easy to see --
honda.start()          # uses Vehicle.start()
tesla.start()          # uses ElectricCar.start() (override)

# -- Inherited methods work everywhere --
honda.accelerate(40)   # inherited from Vehicle
tesla.accelerate(80)   # inherited from Vehicle

# -- Level-specific methods --
honda.open_doors()     # added in Car
tesla.charge(-10)      # added in ElectricCar (a negative amount lowers the charge)

print()
print(honda.info())    # chained super().info() calls
print(tesla.info())    # chained super().info() calls, 3 levels deep

The empty line in the output comes from the bare print(). tesla.info() runs three info() methods: ElectricCar's calls Car's, which calls Vehicle's, and each adds its part on the way back.

Output की ख़ाली line ख़ाली print() से आती है। tesla.info() तीन info() methods चलाता है: ElectricCar वाला Car वाले को बुलाता है, जो Vehicle वाले को, और लौटते समय हर एक अपना हिस्सा जोड़ता है।

输出中的空行来自空的 print()。tesla.info() 运行了三个 info() 方法：ElectricCar 的调用 Car 的，Car 的再调用 Vehicle 的，返回途中每一层都加上自己的部分。

Practical Example 2 — Developers Need an Extra OTP 🔐व्यावहारिक उदाहरण 2 — Developers को एक अतिरिक्त OTP चाहिए 🔐实例 2 — 开发者需要额外的 OTP 🔐

A real-world case of "extend, don't replace". Every Employee logs in with a username and password. Developers need one more step — an OTP (one-time password) — because they can reach production systems. The child overrides auth() but reuses the parent's username/password check through super().auth(...) instead of rewriting it.

"Extend करो, replace नहीं" का असली उदाहरण। हर Employee username और password से login करता है। Developers को एक और step चाहिए — OTP (one-time password) — क्योंकि वे production systems तक पहुँच सकते हैं। Child auth() को override करता है, पर username/password की जाँच दोबारा लिखने की जगह super().auth(...) से parent वाली इस्तेमाल करता है।

一个"扩展而非替换"的真实案例。每个 Employee 用用户名和密码登录。Developer 还需要多一步 — OTP（一次性密码）— 因为他们能访问生产系统。子类重写了 auth()，但通过 super().auth(...) 复用父类的用户名/密码检查，而不是重写它。

class Employee:
    """Base auth for every employee - username + password only."""
    def __init__(self, username, password):
        self.username  = username
        self._password = password        # in real code: store a hash, not plain text

    def auth(self, username, password):
        """Verify username + password. Returns True on success."""
        print(f"  [Employee.auth] checking username & password for {username!r}...")
        if username != self.username:
            print("    ✗ username mismatch")
            return False
        if password != self._password:
            print("    ✗ password mismatch")
            return False
        print("    ✓ base credentials OK")
        return True

class Developer(Employee):
    """Developers need everything an Employee needs - PLUS an OTP."""
    def __init__(self, username, password, otp_secret):
        super().__init__(username, password)     # let Employee handle username/password
        self._otp_secret = otp_secret            # developer-specific field

    # OVERRIDE - same method name, one extra parameter (otp)
    def auth(self, username, password, otp):
        # Step 1 - DELEGATE the username/password check to the parent.
        #          If Employee.auth ever changes, we get the fix for free.
        if not super().auth(username, password):
            return False
        # Step 2 - the EXTRA check that only developers need
        print(f"  [Developer.auth] checking OTP for {username!r}...")
        if otp != self._otp_secret:
            print("    ✗ OTP mismatch")
            return False
        print("    ✓ OTP verified")
        return True

# -- Regular employee: only username + password --
alice = Employee("alice", "MyPass123!")
print("Alice logs in:")
print("  → result:", alice.auth("alice", "MyPass123!"))
print()

# -- Developer: needs username + password + OTP --
bob = Developer("bob", "DevPass456!", otp_secret="774123")
print("Bob (dev) logs in with the correct OTP:")
print("  → result:", bob.auth("bob", "DevPass456!", otp="774123"))
print()
print("Bob (dev) logs in with a WRONG OTP - parent OK, child fails:")
print("  → result:", bob.auth("bob", "DevPass456!", otp="000000"))
print()
print("Bob (dev) logs in with a WRONG password - the parent stops early:")
print("  → result:", bob.auth("bob", "wrong", otp="774123"))

🔐 Simulator: Login Lab🔐 Simulator: Login Lab🔐 模拟器：登录实验室

Choose who logs in and what they type. The two boxes show which class did which check. Try calling alice.auth with an OTP, or bob.auth without one — the override changed the method's parameters. All 54 combinations were run in real Python.

चुनें कौन login करता है और क्या type करता है। दो डिब्बे दिखाते हैं कि किस class ने कौन-सी जाँच की। alice.auth को OTP के साथ, या bob.auth को बिना OTP के बुलाकर देखें — override ने method के parameters बदल दिए। सभी 54 combinations असली Python में चलाए गए।

选择谁登录、输入什么。两个方框显示哪个类做了哪项检查。试试带 OTP 调用 alice.auth，或不带 OTP 调用 bob.auth — 重写改变了方法的参数。全部 54 种组合都在真实 Python 中运行过。

isinstance() and issubclass() — Checking the Family 👪isinstance() और issubclass() — परिवार की जाँच 👪isinstance() 与 issubclass() — 检查家族关系 👪

Once you have a hierarchy, you often ask: "Is this object part of the family?" Python has two built-in checks, and both understand inheritance — an ElectricCar counts as a Car and as a Vehicle. (The classes are the ones from Section 08.)

Hierarchy बन जाने के बाद आप अक्सर पूछते हैं: "क्या यह object इस परिवार का है?" Python में दो built-in जाँचें हैं, और दोनों inheritance समझती हैं — ElectricCar एक Car भी गिना जाता है और Vehicle भी। (Classes वही हैं जो Section 08 में हैं।)

有了类层次之后，你经常会问："这个对象属于这个家族吗？"Python 提供了两个内置检查，都理解继承 — ElectricCar 既算 Car，也算 Vehicle。（所用的类与第 08 节相同。）

class Vehicle:
    """Base class - everything on wheels shares this."""
    def __init__(self, brand, wheels):
        self.brand  = brand
        self.wheels = wheels
        self.speed  = 0

    def start(self):
        print(f"{self.brand} engine starts with a ROAR!")

    def accelerate(self, amount):
        self.speed += amount
        print(f"{self.brand} → {self.speed} km/h")

    def info(self):
        return f"{self.brand} · {self.wheels} wheels · {self.speed} km/h"

class Car(Vehicle):
    """A Car is a Vehicle with doors and a fuel type."""
    def __init__(self, brand, doors, fuel_type):
        super().__init__(brand, wheels=4)     # the parent handles brand/wheels/speed
        self.doors     = doors
        self.fuel_type = fuel_type

    def open_doors(self):
        print(f"{self.brand}: opening {self.doors} doors")

    def info(self):
        # EXTEND the parent's info - don't rewrite it
        return super().info() + f" · {self.doors} doors · {self.fuel_type}"

class ElectricCar(Car):
    """An ElectricCar is a Car powered by a battery."""
    def __init__(self, brand, doors, battery_kwh):
        super().__init__(brand, doors, fuel_type="electric")
        self.battery_kwh  = battery_kwh
        self.charge_level = 100

    # OVERRIDE - electric cars start silently
    def start(self):
        print(f"{self.brand} powers on silently — battery at {self.charge_level}%")

    # A new method only on ElectricCar
    def charge(self, amount):
        self.charge_level = min(100, self.charge_level + amount)
        print(f"{self.brand} charged to {self.charge_level}%")

    def info(self):
        return super().info() + f" · {self.battery_kwh} kWh · {self.charge_level}% charged"

tesla = ElectricCar("Tesla", 4, 75)

# -- isinstance(obj, ClassOrTuple): is this object one of these types? --
print(isinstance(tesla, ElectricCar))    # its own type
print(isinstance(tesla, Car))            # inherits from Car
print(isinstance(tesla, Vehicle))        # inherits from Vehicle
print(isinstance(tesla, object))         # everything is an object
print(isinstance(tesla, int))            # an unrelated type

# -- issubclass(Cls, ParentOrTuple): is Cls a subclass of Parent? --
print(issubclass(ElectricCar, Car))
print(issubclass(ElectricCar, Vehicle))  # walks the whole chain
print(issubclass(Car, ElectricCar))      # a parent is not a subclass of its child

# -- Practical use: accept any Vehicle --
def describe_any_vehicle(v):
    if not isinstance(v, Vehicle):
        raise TypeError("Expected a Vehicle (or subclass)")
    return v.info()

print(describe_any_vehicle(tesla))
try:
    describe_any_vehicle("a bicycle")
except TypeError as e:
    print("TypeError:", e)

print(type(tesla) == Car, isinstance(tesla, Car))   # type() == rejects the subclass

👪 Simulator: Family Checker👪 Simulator: Family Checker👪 模拟器：家族检查器

Pick an object. Compare isinstance() with type() == for five classes — highlighted rows are where they disagree. Below is the full issubclass() table. Every cell is a real Python result.

कोई object चुनें। पाँच classes के लिए isinstance() और type() == की तुलना करें — हाइलाइट rows वहाँ हैं जहाँ दोनों अलग जवाब देते हैं। नीचे पूरी issubclass() table है। हर cell असली Python नतीजा है।

选一个对象。对五个类比较 isinstance() 与 type() == — 高亮的行是两者结果不同的地方。下面是完整的 issubclass() 表。每个单元格都是真实的 Python 结果。

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

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

Four of these mistakes, run for real. Buggy code on the left, fixed code on the right, changed lines marked. Two of them give no error — just a wrong answer.

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

其中四个错误的真实运行。左边是有 bug 的代码，右边是修正后的代码，改动的行已标出。其中两个 完全不报错 — 只是给出错误结果。

Quick Reference 📋Quick Reference 📋速查表 📋

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

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