इनहेरिटन्स आणि super() कसे कार्य करते?

Question

Accepted Answer

**इनहेरिटन्स** एका वर्गाला दुसऱ्या वर्गातून व्युत्पन्न होऊ देते, त्याच्या वर्तनाचा पुनर्वापर आणि विस्तार करून. **`super()`** मूल वर्गाच्या पद्धतीला कॉल करते. Python **मल्टीपल इनहेरिटन्स** समर्थन करते, जे **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"
```

## मल्टीपल इनहेरिटन्स आणि 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
```

मल्टीपल इनहेरिटन्स सह, Python एक विशिष्ट रेखीय क्रमात पद्धती शोधते — **MRO**, C3 अल्गोरिदम द्वारे गणना केली जाते. `D.__mro__` याला दर्शविते; `super()` याचे अनुसरण करते. MRO हे सुनिश्चित करते की प्रत्येक वर्ग एकदा भेट दिला जाईल आणि मूल संतानांनंतर येतात, "हीरे समस्या" पूर्वसूचित समाधानाने सोडवण्यास आवश्यक आहे.

## 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 फ्रेमवर्क सर्वत्र वापरली जातात (उदा. Django मॉडेल्सचे उपवर्गीकरण, अपवाद पदानुक्रम).

`super()` (मूल तर्क कॉल करणे, विशेषत: `__init__` मध्ये) आणि **MRO** समजून घेणे Python मध्ये विशेषत: महत्त्वाचे आहे कारण ते **मल्टीपल इनहेरिटन्स** समर्थन करते — MRO हे आहे जे पद्धती संकल्प आणि `super()` साखळीला जटिल पदानुक्रमे आणि मिश्रणांमध्ये पूर्वानुमेय बनवते.

MRO कसे कार्य करते हे जाणून घेणे (आणि हे `super()` अनुसरण करते) हीरे-आकाराचे किंवा मिश्रण-आधारित डिজाइनमधील गोंधळ प्रतिबंधित करते जे वास्तविक Python कोडबेसमध्ये सामान्य आहे.