Inheritance ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग (OOP) के मुख्य अवधारणाओं में से एक है।
यह एक क्लास (जिसे child या subclass कहा जाता है) को दूसरी क्लास (जिसे parent या superclass कहा जाता है) के attributes और methods वारिस में लेने की अनुमति देता है।

इसका मतलब है कि आप एक बेस क्लास में सामान्य व्यवहार और डेटा परिभाषित कर सकते हैं, फिर अधिक विशिष्ट क्लास बना सकते हैं जो उस कार्यक्षमता को फिर से उपयोग करें और अनुकूलित करें — बिना एक ही कोड को दोहराए।

वंशानुक्रम के लिए मूल सिंटैक्स

Python में, inheritance उस पैरेंट क्लास के नाम को बच्चे के क्लास नाम के बाद कोष्ठकों में निर्दिष्ट करके लागू किया जाता है।

class ParentClass:
    # पैरेंट क्लास के attributes और methods

class ChildClass(ParentClass):
    # बच्चे क्लास के attributes और methods

जब एक ChildClass किसी ParentClass से वारिस होती है, तो वह प्राप्त करती है:

• पैरेंट के सभी attributes (ऑब्जेक्ट से जुड़ी वैरिएबल)
• पैरेंट के सभी methods (ऑब्जेक्ट से जुड़ी फंक्शन)
• पैरेंट क्लास के किसी भी constructor (__init__) को

उदाहरण: जानवर और उनकी आवाजें

आइए inheritance को जीवन में लाते हैं कुछ ऐसा जिसके साथ हम सभी जुड़ सकते हैं — जानवर।
हम एक सामान्य Animal क्लास से शुरू करेंगे जो बताता है कि सभी जानवरों में क्या समानताएं हैं, फिर हम विशिष्ट जानवरों के प्रकार बनाएंगे (Dog और Cat) जो उन गुणों को साझा करते हैं लेकिन अलग-अलग आवाज़ें करते हैं।

यहाँ बेस क्लास है:

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

    def sound(self):
        pass  # हम हर जानवर को अपनी खास आवाज़ तय करने देंगे

Animal क्लास में है:

• एक __init__ मेथड जो हर जानवर के लिए name और age सेट करता है।
• एक sound() मेथड जो अभी कुछ नहीं करता (pass सिर्फ एक प्लेसहोल्डर है)। हम इसे हर जानवर के प्रकार में उनकी आवाज़ से रिप्लेस करेंगे।

अब दो विशिष्ट जानवर क्लास बनाते हैं:

class Dog(Animal):
    def sound(self):
        print("Woof woof!")

class Cat(Animal):
    def sound(self):
        print("Meow!")

यहाँ क्या हो रहा है:

• दोनों Dog और Cat Animal से inherit करते हैं, इसलिए वे name और age attributes अपने आप पा लेते हैं बिना हमें उस कोड को दोहराने की जरूरत।
• हर एक ने sound() मेथड को override किया ताकि वे अपनी अलग आवाज़ निकाल सकें।

ऑब्जेक्ट बनाना और उपयोग करना

dog = Dog("Rex", 2)
cat = Cat("Mimi", 3)

print(dog.name)  # Rex
dog.sound()      # Woof woof!

print(cat.name)  # Mimi
cat.sound()      # Meow!

जब हम Dog("Rex", 2) बनाते हैं, तो यह चरण-दर-चरण होता है:

1. Python __init__ मेथड को Animal से कॉल करता है (क्योंकि Dog अपना खुद का __init__ नहीं रखता)।
2. दिए गए name और age मान नए ऑब्जेक्ट में स्टोर हो जाते हैं।
3. जब हम dog.sound() कॉल करते हैं, Python सबसे पहले Dog में sound() मेथड खोजता है। वह वह मेथड पाता है जो हमने लिखा है और उसे चलाता है — जो कि "Woof woof!" प्रिंट करता है।

यह लॉजिक Cat पर भी लागू होता है, लेकिन वह अपनी sound() मेथड चलाता है।

यह उदाहरण inheritance का जादू दिखाता है:

• हम सामान्य सेटअप (__init__) केवल एक बार Animal क्लास में लिखते हैं।
• हर subclass (Dog, Cat) साझा विशेषताएं रखता है और अपनी अनूठी व्यवहार जोड़ता है।
• परिणामस्वरूप कम दोहराव वाला कोड, अधिक संगठित लॉजिक, और संबंधित ऑब्जेक्ट्स का आसान प्रबंधन होता है।

3. यह कैसे काम करता है

• साझा संरचना: Animal का __init__ मेथड तब चलता है जब आप Dog या Cat ऑब्जेक्ट बनाते हैं, क्योंकि वे इसे अपने आप वारिस में लेते हैं।
• मेथड ओवरराइडिंग: दोनों Dog और Cat के अपने sound() मेथड होते हैं जो Animal में मौजूद प्लेसहोल्डर को बदल देते हैं। जब आप Dog पर sound() कॉल करते हैं, Python Dog मेथड का उपयोग करता है, Animal का नहीं।

टिप: अगर कोई child class किसी मेथड को ओवरराइड नहीं करता, तो वह अपने parent class के मेथड का उपयोग अपने आप करता है।

वंशानुक्रम क्यों उपयोग करें?

Inheritance आपको यह करने देता है:

• साझा लॉजिक को एक बेस क्लास में रखने से कोड की पुनरावृत्ति से बचाएं।
• अपने कोड को अधिक मॉड्यूलर और पढ़ने योग्य बनाएं।
• एक सामान्य ब्लूप्रिंट से विशिष्ट क्लास बनाएं।

Inheritance में सोचने का उदाहरण:

• Animal → name, age, और sound() मेथड के साथ सामान्य ब्लूप्रिंट।
• Dog → एक विशिष्ट प्रकार का जानवर अपनी अनूठी आवाज़ के साथ।
• Cat → एक अलग प्रकार का जानवर अपनी अलग आवाज़ के साथ।

संक्षेप में

Inheritance OOP में एक शक्तिशाली उपकरण है जो क्लासेस का एक पदानुक्रम बनाता है, सामान्य अवधारणाओं से शुरू करके अधिक विशिष्ट तक बढ़ता है।

Python में, आप इसे लागू करते हैं:

1. एक parent class लिखकर जिसमें सामान्य attributes और methods हों।
2. child classes बनाकर जिनमें पैरेंट क्लास नाम को कोष्ठकों में सूचीबद्ध करें।
3. आवश्यकतानुसार child classes में मेथड जोड़ें या ओवरराइड करें।

अगले पाठ में, हम इस अवधारणा को आगे बढ़ाएंगे और super() का पता लगाएंगे — जो child classes को उनके parent classes के व्यवहार को कॉल और बढ़ाने का तरीका देता है।