Computer >> कंप्यूटर ट्यूटोरियल >  >> प्रोग्रामिंग >> Python

क्या पायथन पॉलीमॉर्फिज्म सपोर्ट करता है?

हाँ, पायथन पॉलीमॉर्फिज्म पूरी तरह से सपोर्ट करता है। पॉलीमॉर्फिज्म का अर्थ है "एक नाम, अनेक रूप" - एक ही इंटरफेस के माध्यम से विभिन्न प्रकार के ऑब्जेक्ट्स को हैंडल करना।

पॉलीमॉर्फिज्म के प्रकार

  1. मेथड ओवरराइडिंग (Runtime Polymorphism) - चाइल्ड क्लास पैरेंट के मेथड को पुनर्परिभाषित करती है
  2. मेथड ओवरलोडिंग (Compile-time Polymorphism) - पायथन में पारंपरिक ओवरलोडिंग नहीं, लेकिन डिफ़ॉल्ट आर्गुमेंट्स/*args/**kwargs से समान प्रभाव
  3. डक टाइपिंग - "यदि यह बतख की तरह चलता और क्वैक करता है, तो यह बतख है"
  4. ऑपरेटर ओवरलोडिंग - विशेष मेथड्स (__add__, __len__, आदि) द्वारा
  5. उदाहरण 1: मेथड ओवरराइडिंग (इनहेरिटेंस के साथ)

    class Fish:
        def swim(self):
            print("मछली तैर रही है।")
        
        def swim_backwards(self):
            print("मछली पीछे तैर सकती है, लेकिन डूब सकती है।")
        
        def skeleton(self):
            print("मछली का कंकाल कार्टिलेज का बना होता है।")
    
    class Clownfish(Fish):
        def swim(self):
            print("क्लाउनफिश तैर रही है।")
        
        def swim_backwards(self):
            print("क्लाउनफिश पीछे तैर सकती है।")
        
        def skeleton(self):
            print("क्लाउनफिश का कंकाल हड्डी का बना होता है।")
    
    # पॉलीमॉर्फिक व्यवहार
    def describe_fish(fish):
        fish.skeleton()
    
    a = Fish()
    b = Clownfish()
    
    describe_fish(a)  # Fish का मेथड
    describe_fish(b)  # Clownfish का मेथड

    आउटपुट

    मछली का कंकाल कार्टिलेज का बना होता है।
    क्लाउनफिश का कंकाल हड्डी का बना होता है।

    उदाहरण 2: डक टाइपिंग (इनहेरिटेंस के बिना)

    class Duck:
        def quack(self):
            print("क्वैक!")
    
        def feathers(self):
            print("सफेद और भूरे पंख")
    
    class Person:
        def quack(self):
            print("व्यक्ति बतख की नकल करता है: क्वैक!")
    
        def feathers(self):
            print("व्यक्ति जमीन से पंख उठाता है और दिखाता है")
    
    def in_the_forest(duck):
        duck.quack()
        duck.feathers()
    
    in_the_forest(Duck())
    in_the_forest(Person())

    आउटपुट

    क्वैक!
    सफेद और भूरे पंख
    व्यक्ति बतख की नकल करता है: क्वैक!
    व्यक्ति जमीन से पंख उठाता है और दिखाता है

    उदाहरण 3: ऑपरेटर ओवरलोडिंग

    class Vector:
        def __init__(self, x, y):
            self.x = x
            self.y = y
        
        def __add__(self, other):
            return Vector(self.x + other.x, self.y + other.y)
        
        def __str__(self):
            return f"Vector({self.x}, {self.y})"
    
    v1 = Vector(2, 3)
    v2 = Vector(4, 5)
    v3 = v1 + v2  # __add__ ऑटोमेटिकली कॉल होता है
    print(v3)

    आउटपुट

    Vector(6, 8)

    उदाहरण 4: बिल्ट-इन फंक्शन्स के साथ पॉलीमॉर्फिज्म

    # len() विभिन्न प्रकारों पर काम करता है
    print(len("Hello"))      # 5 - स्ट्रिंग
    print(len([1, 2, 3]))    # 3 - लिस्ट
    print(len({"a": 1}))     # 1 - डिक्शनरी
    
    # + ऑपरेटर
    print(1 + 2)             # 3 - इंट
    print("a" + "b")         # "ab" - स्ट्रिंग
    print([1] + [2])         # [1, 2] - लिस्ट

    पायथन में "ओवरलोडिंग" (डिफ़ॉल्ट आर्गुमेंट्स के साथ)

    class Calculator:
        def add(self, a, b, c=0):  # डिफ़ॉल्ट आर्गुमेंट से "ओवरलोडिंग"
            return a + b + c
    
    calc = Calculator()
    print(calc.add(2, 3))       # 5
    print(calc.add(2, 3, 4))    # 9
    
    # *args/**kwargs से वास्तविक वेरिएबल आर्गुमेंट्स
    def flexible_add(*args):
        return sum(args)
    
    print(flexible_add(1, 2))        # 3
    print(flexible_add(1, 2, 3, 4))  # 10

    सारांश

    पायथन का पॉलीमॉर्फिज्म डायनामिक और लचीला है। यह इनहेरिटेंस-आधारित ओवरराइडिंग, डक टाइपिंग, और ऑपरेटर ओवरलोडिंग के माध्यम से प्राप्त होता है, जिससे कोड पुन: प्रयोज्य और एक्सटेंसिबल बनता है।

  1. - पायथन में क्लास इनहेरिटेंस

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

  1. - पायथन में classmethod()

    एक क्लास मेथड अपने पहले आर्गुमेंट के रूप में क्लास को ही प्राप्त करता है। इस तरह हम क्लास से पहले इंस्टेंस बनाए बिना क्लास के अंदर मेथड को कॉल करने में सक्षम होते हैं। हम क्लास में निहित मेथड की घोषणा से पहले डेकोरेटर @classmethod का उपयोग करते हैं और फिर हम सीधे मेथड को एक्सेस कर सकते हैं। नीचे क्

  1. पायथन में इनहेरिटेंस (Inheritance) पायथन में इनहेरिटेंस (Inheritance)

    इस लेख में, हम पायथन 3.x या उससे पहले के संस्करण में इनहेरिटेंस और क्लासेस को एक्सटेंड करने के बारे में जानेंगे।इनहेरिटेंस वास्तविक दुनिया के संबंधों को अच्छी तरह से दर्शाता है, पुन: प्रयोज्यता प्रदान करता है और ट्रांजिटिविटी का समर्थन करता है। यह तेज़ विकास समय, आसान रखरखाव और विस्तार में आसानी प्र