हाँ, पायथन पॉलीमॉर्फिज्म पूरी तरह से सपोर्ट करता है। पॉलीमॉर्फिज्म का अर्थ है "एक नाम, अनेक रूप" - एक ही इंटरफेस के माध्यम से विभिन्न प्रकार के ऑब्जेक्ट्स को हैंडल करना।
पॉलीमॉर्फिज्म के प्रकार
- मेथड ओवरराइडिंग (Runtime Polymorphism) - चाइल्ड क्लास पैरेंट के मेथड को पुनर्परिभाषित करती है
- मेथड ओवरलोडिंग (Compile-time Polymorphism) - पायथन में पारंपरिक ओवरलोडिंग नहीं, लेकिन डिफ़ॉल्ट आर्गुमेंट्स/*args/**kwargs से समान प्रभाव
- डक टाइपिंग - "यदि यह बतख की तरह चलता और क्वैक करता है, तो यह बतख है"
- ऑपरेटर ओवरलोडिंग - विशेष मेथड्स (
__add__,__len__, आदि) द्वारा
उदाहरण 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
सारांश
पायथन का पॉलीमॉर्फिज्म डायनामिक और लचीला है। यह इनहेरिटेंस-आधारित ओवरराइडिंग, डक टाइपिंग, और ऑपरेटर ओवरलोडिंग के माध्यम से प्राप्त होता है, जिससे कोड पुन: प्रयोज्य और एक्सटेंसिबल बनता है।