इनहेरिटन्स र 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 frameworks भरिपूर प्रयोग गरिन्छ (उदा. Django मोडेलहरूको उप-वर्गीकरण, अपवाद पदानुक्रम)।

`super()` को समझ (अभिभावक तर्क आह्वान गर्दै, विशेषत: `__init__` मा) र **MRO** Python मा विशेषत: महत्त्वपूर्ण छ किनकि यो **गुणनात्मक इनहेरिटन्स** समर्थन गर्छ — MRO त्यो हो जसले विधि समाधान र `super()` साङ्ग्लाइनलाई जटिल पदानुक्रमहरू र मिक्सिनमा पूर्वानुमेय बनाउँछ।

MRO कसरी काम गर्छ भन्ने कुरा जान्नु (र `super()` यसलाई पालना गर्छ) हीरा-आकारको वा मिक्सिन-आधारित डिजाइनमा भ्रमण रोक्छ जो वास्तविक Python कोडबेसमा सामान्य छ।