மரபுவழி மற்றும் 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__` இல் பெற்றோரின் setup ஐ இயக்க அத்യাவசியம், மற்றும் மேலெழுதப்பட்ட முறைகளை நீட்டிக்க (மாற்ற அல்ல).

## நீட்டிக்க vs முழுமையாக மேலெழுத

```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()` சங்கிலிகள் சிக்கலான வரிசைமுறை மற்றும் mixins இல் கணிக்கக்கூடியதாக இருப்பதாகும்.

MRO எவ்வாறு செயல்படுகிறது மற்றும் `super()` அதைப் பின்பற்றுகிறது (மற்றும் வைரம் வடிவ அல்லது mixin-அடிப்படையிலான வடிவமைப்பில் குழப்பம் ஏற்படாமல் இருக்க) என்பதை அறிந்தால், வாস்தவ Python கோட்பேஸ்களில் பொதுவாக உள்ள குழப்பம் தடுக்கப்படும்.