जब कोई क्लास पैरेंट क्लास से इनहेरिट करता है, तो चाइल्ड क्लास के पास अपने खुद के इंस्टेंस वेरिएबल्स और मेथड्स हो सकते हैं, लेकिन कभी-कभी उसे पैरेंट के कोड के कुछ हिस्सों का उपयोग भी करना पड़ता है।

यहाँ पर super() फंक्शन काम आता है।
यह चाइल्ड क्लास को बिना पैरेंट का नाम हार्डकोड किए, पैरेंट क्लास के मेथड्स (और अप्रत्यक्ष रूप से एट्रिब्यूट्स) तक पहुँचने देता है।

super() का सबसे आम उपयोग चाइल्ड क्लास के अंदर पैरेंट के कंस्ट्रक्टर (__init__) को कॉल करना है, ताकि पैरेंट अपनी एट्रिब्यूट्स सेट कर सके उससे पहले कि चाइल्ड कोई नया एट्रिब्यूट जोड़े।

जब आप एक चाइल्ड क्लास बनाते हैं जो अपना खुद का init मेथड डिफाइन करता है, तो वह पैरेंट के init को ओवरराइड कर देता है। इसका मतलब है कि जब आप चाइल्ड क्लास का ऑब्जेक्ट बनाते हैं, तो केवल चाइल्ड का init चलेगा — पैरेंट का कंस्ट्रक्टर अपने आप कॉल नहीं होगा। परिणामस्वरूप, पैरेंट के init में जो भी सेटअप लॉजिक, डिफ़ॉल्ट वैल्यू, या एट्रिब्यूट डिफाइंड है, वह पूरी तरह स्किप हो जाएगा, जिससे वो चाइल्ड ऑब्जेक्ट में अनडिफाइंड रहेंगे। इससे अप्रत्याशित त्रुटियाँ हो सकती हैं अगर पैरेंट क्लास महत्वपूर्ण इनिशियलाइज़ेशन करता था। इस व्यवहार को बचाने के लिए, आपको चाइल्ड के कंस्ट्रक्टर में super().__init__() कॉल करना चाहिए, जो स्पष्ट रूप से पैरेंट के इनिशियलाइज़ेशन को चलाता है इससे पहले कि चाइल्ड में कुछ भी जोड़ा या ओवरराइड किया जाए।

आइए इसे अब समझते हैं!

super().__init__() का उपयोग क्यों करें?

जब आप एक सबक्लास बनाते हैं, तो आप उसमें अतिरिक्त डेटा स्टोर करना चाहते हैं।
हालांकि, आप चाहते हैं कि पैरेंट के एट्रिब्यूट्स ठीक से इनिशियलाइज़ हों। पैरेंट के इनिशियलाइज़ेशन कोड को दोहराने के बजाय, आप इसे बस super().__init__() से कॉल कर सकते हैं।

उदाहरण: सबक्लास में नया एट्रिब्यूट जोड़ना

मान लीजिए हमारे पास एक Animal क्लास है जो name और age को रखता है।
हम Dog नाम का सबक्लास बनाना चाहते हैं जो कुत्ते की breed (प्रकार) भी रखे, लेकिन हम अभी भी Animal के कंस्ट्रक्टर का उपयोग करना चाहते हैं name और age सेट करने के लिए।

class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age

class Dog(Animal):
    def __init__(self, name, age, breed):
        super().__init__(name, age)  # Animal का कंस्ट्रक्टर कॉल करें
        self.breed = breed           # Dog का अपना एट्रिब्यूट जोड़ें

यह चरण-दर-चरण कैसे काम करता है

1. जब हम Dog ऑब्जेक्ट बनाते हैं, तो Python Dog क्लास का __init__ मेथड चलाता है।
2. Dog.__init__ के अंदर, super().__init__(name, age) लाइन Animal.__init__ को कॉल करती है।
3. पैरेंट कंस्ट्रक्टर (Animal.__init__) self.name और self.age सेट करता है।
4. कंट्रोल वापस Dog.__init__ को आता है, जो फिर self.breed सेट करता है।

इस तरह:

• पैरेंट के एट्रिब्यूट ठीक वैसे ही इनिशियलाइज हो जाते हैं जैसे पैरेंट ने तय किया है।
• चाइल्ड क्लास अपने एट्रिब्यूट जोड़ सकता है बिना कोड डुप्लिकेट किए।

क्लास का उपयोग करना

dog = Dog("Rex", 4, "Golden Retriever")

print(dog.name)   # Rex
print(dog.age)    # 4
print(dog.breed)  # Golden Retriever

super() पैरेंट क्लास का नाम सीधे कॉल करने से बेहतर क्यों है

आप सीधे Animal.__init__(self, name, age) भी कॉल कर सकते हैं, लेकिन super() उपयोग करने के कई फायदे हैं:

• यह मल्टीपल इनहेरिटेंस को अपने आप संभालता है (यदि आपकी क्लास एक से अधिक पैरेंट से इनहेरिट करती है)।
• यह आपके कोड को मेंटेन करना आसान बनाता है — यदि आप कभी पैरेंट क्लास का नाम बदलते हैं, तो हर जगह बदलाव नहीं करना पड़ेगा।
• यह स्पष्ट करता है कि आप जानबूझकर पैरेंट क्लास का मेथड कॉल कर रहे हैं।

TIP: हमेशा `super().__init__()` को चाइल्ड के अपने एट्रिब्यूट सेट करने से पहले कॉल करें, ताकि सभी पैरेंट एट्रिब्यूट्स इस्तेमाल के लिए तैयार हों।

समापन

super() पैरेंट क्लास से जुड़ने का आपका माध्यम है। इसे तब उपयोग करें जब आप:

• पैरेंट के सेटअप कोड को पुनः उपयोग करना चाहते हैं।
• पैरेंट की कार्यक्षमता को डुप्लिकेट किए बिना बढ़ाना चाहते हैं।
• अपना कोड साफ, मेंटेन योग्य, और क्लास हायरेरकी में बदलाव के लिए तैयार रखना चाहते हैं।

अगले पाठ में, हम प्राइवेट मेथड्स और वेरिएबल्स का पता लगाएंगे — आपकी क्लास के अंदरूनी डेटा को बाहर से एक्सेस या बदलने से बचाने का एक तरीका।