विरासत और super() कैसे काम करते हैं?

Question

Accepted Answer

**विरासत** एक वर्ग को किसी अन्य वर्ग से व्युत्पन्न करने देती है, इसके व्यवहार को पुनः उपयोग और विस्तारित करते हुए। **`super()`** मूल वर्ग की विधियों को कॉल करता है। Python **multiple inheritance** का समर्थन करता है, जिसे **MRO** (Method Resolution Order) द्वारा हल किया जाता है।

## मूल विरासत और super()

```python
class Animal:
    def __init__(self, name):
        self.name = name
    def speak(self):
        return "some sound"

class Dog(Animal):                  # Dog inherits from Animal
    def __init__(self, name, breed):
        super().__init__(name)       # call the parent's __init__ (reuse its logic)
        self.breed = breed
    def speak(self):                 # OVERRIDE the parent method
        return "Woof"

d = Dog("Rex", "Lab")
d.name      # "Rex" (set by Animal via super())
d.speak()   # "Woof" (Dog's override)
```

`super()` एक सबक्लास को मूल व्यवहार को आह्वान करने देता है — मूल की सेटअप चलाने के लिए `__init__` में आवश्यक है, और ओवरराइड की गई विधियों को विस्तारित (केवल प्रतिस्थापित नहीं) करने के लिए।

## विस्तारित करना बनाम पूरी तरह ओवरराइड करना

```python
class Cat(Animal):
    def speak(self):
        base = super().speak()       # call parent, then ADD to it
        return f"{base} ... Meow"
```

## Multiple inheritance और MRO

```python
class A:
    def greet(self): return "A"
class B(A):
    def greet(self): return "B"
class C(A):
    def greet(self): return "C"
class D(B, C):                       # inherits from BOTH B and C
    pass

D().greet()       # "B" — found via the MRO
D.__mro__         # (D, B, C, A, object) — the search order
```

Multiple inheritance के साथ, Python विधियों को एक विशिष्ट रैखिक क्रम में खोजता है — **MRO**, C3 algorithm द्वारा गणना की जाती है। `D.__mro__` इसे दिखाता है; `super()` इसका पालन करता है। MRO सुनिश्चित करता है कि प्रत्येक वर्ग को एक बार देखा जाए और माता-पिता बच्चों के बाद आएं, "diamond problem" को पूर्वानुमानित तरीके से हल करते हुए।

## super() MRO का पालन करता है (केवल शाब्दिक मूल नहीं)

```python
# in cooperative multiple inheritance, super() goes to the NEXT class in the MRO,
# not necessarily the "parent" — enabling mixins to chain correctly
```

## यह क्यों महत्वपूर्ण है

विरासत और `super()` व्यवहार को पुनः उपयोग और विस्तारित करने के लिए मुख्य OOP उपकरण हैं, जिनका उपयोग पूरे Python frameworks में किया जाता है (जैसे Django models को subclass करना, exception hierarchies)।

`super()` को समझना (मूल तर्क को कॉल करना, विशेषकर `__init__` में) और **MRO** को Python में विशेष रूप से महत्वपूर्ण है क्योंकि यह **multiple inheritance** का समर्थन करता है — MRO ही वह है जो method resolution और `super()` chains को जटिल hierarchies और mixins में अनुमानित बनाता है।

यह जानना कि MRO कैसे काम करता है (और यह कि `super()` इसका पालन करता है) diamond-shaped या mixin-based designs में भ्रम को रोकता है जो वास्तविक Python codebases में सामान्य हैं।