વારસો અને super() કેવી રીતે કાર્ય કરે છે?

Question

Accepted Answer

**વારસો** એક વર્ગને અન્ય વર્ગ પાસેથી વ્યુત્પન્ન કરવાની મંજૂરી આપે છે, તેના વર્તણૂક પુનઃ ઉપયોગ અને વિસ્તૃત કરે છે. **`super()`** અભિભાવક વર્ગની પદ્ધતિઓને કૉલ કરે છે. Python **બહુવિધ વારસો**ને સમર્થન આપે છે, જે **MRO** (પદ્ધતિ ઠરાવણીનો ક્રમ) દ્વારા હલ કરવામાં આવે છે.

## મૂળભૂત વારસો અને 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 એ જ છે જે પદ્ધતિ ઠરાવણી અને જટિલ શ્રેણીક્રમ અને mixins માં `super()` શૃંખલાઓ અનુમાનક્ષમ બનાવે છે.

MRO કેવી રીતે કાર્ય કરે છે તે જાણવું (અને તે `super()` અનુસરે છે) હીરાના આકાર અથવા mixin-આધારિત ડિઝાઇનમાં મૂંઝવણ અટકાવે છે જે વાસ્તવિક Python કોડબેસમાં સામાન્ય છે.