ਵਿਰਾਸਤ ਅਤੇ 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()` ਇੱਕ subclass ਨੂੰ ਮਾਤਾ-ਪਿਤਾ ਦੇ ਵਿਵਹਾਰ ਨੂੰ ਸ਼ਾਮਿਲ ਕਰਨ ਦਿੰਦਾ ਹੈ — `__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 ਐਲਗੋਰਿਦਮ ਦੁਆਰਾ ਗਣਿਤ ਕੀਤਾ ਗਿਆ। `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 ਫ੍ਰੇਮਵਰਕ ਵਿੱਚ ਵਰਤੇ ਜਾਂਦੇ ਹਨ (ਜਿਵੇਂ Django ਮਾਡੇਲ subclassing, exception hierarchies)।

`super()` (ਮਾਤਾ-ਪਿਤਾ ਲਾਜਿਕ ਨੂੰ ਕਾਲ ਕਰਨਾ, ਖਾਸ ਕਰ `__init__` ਵਿੱਚ) ਅਤੇ **MRO** ਨੂੰ ਸਮਝਣਾ Python ਵਿੱਚ ਖਾਸ ਤੌਰ 'ਤੇ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿਉਂਕਿ ਇਹ **multiple inheritance** ਨੂੰ ਸਮਰਥਿਤ ਕਰਦਾ ਹੈ — MRO ਉਹ ਹੈ ਜੋ ਗੁੰਝਲਦਾਰ hierarchies ਅਤੇ mixins ਵਿੱਚ ਵਿਧੀ ਰੈਜ਼ੋਲਿਊਸ਼ਨ ਅਤੇ `super()` ਚੇਨਜ਼ ਨੂੰ ਸ਼ੁਮਾਰ ਬਣਾਉਂਦਾ ਹੈ।

ਇਹ ਜਾਣਨਾ ਕਿ MRO ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ (ਅਤੇ ਇਹ `super()` ਇਸ ਨੂੰ ਅਨੁਸਰਨ ਕਰਦਾ ਹੈ) diamond-shaped ਜਾਂ mixin-based ਡਿਜ਼ਾਇਨ ਵਿੱਚ ਷ੋਭਾ ਤੋਂ ਬਚਾਉਂਦਾ ਹੈ ਜੋ ਵਾਸਤਵਿਕ Python codebases ਵਿੱਚ ਆਮ ਹਨ।