आप इस्तेमाल किए गए ऑपरेंड के आधार पर पायथन में एक ऑपरेटर के अर्थ को बदल सकते हैं। इस ट्यूटोरियल में, आप सीखेंगे कि पायथन ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग में ऑपरेटर ओवरलोडिंग का उपयोग कैसे करें।
पायथन ऑपरेटर ओवरलोडिंग
पायथन ऑपरेटर बिल्ट-इन कक्षाओं के लिए काम करते हैं। लेकिन एक ही ऑपरेटर विभिन्न प्रकारों के साथ अलग व्यवहार करता है। उदाहरण के लिए, +ऑपरेटर दो संख्याओं पर अंकगणित जोड़ देगा, दो सूचियों को मर्ज कर देगा या दो तार जोड़ देगा।
पायथन में यह सुविधा, जो एक ही ऑपरेटर को संदर्भ के अनुसार अलग-अलग अर्थ रखने की अनुमति देती है, ऑपरेटर ओवरलोडिंग कहलाता है।
तो क्या होता है जब हम उन्हें उपयोगकर्ता-परिभाषित वर्ग की वस्तुओं के साथ उपयोग करते हैं? आइए हम निम्नलिखित वर्ग पर विचार करें, जो 2-डी समन्वय प्रणाली में एक बिंदु का अनुकरण करने की कोशिश करता है।
class Point: def __init__(self, x=0, y=0): self.x = x self.y = y p1 = Point(1, 2) p2 = Point(2, 3) print(p1+p2)
आउटपुट
ट्रेसबैक (सबसे हालिया कॉल अंतिम): फ़ाइल "", लाइन 9, प्रिंट में (p1 + P2) टाइपर्रर: असमर्थित ऑपरेंड प्रकार (ओं) के लिए +: 'प्वाइंट' और 'प्वाइंट'
यहां, हम देख सकते हैं कि एक TypeErrorउठाया गया था, क्योंकि पायथन को पता नहीं था कि दो Pointवस्तुओं को एक साथ कैसे जोड़ा जाए।
हालाँकि, हम ऑपरेटर ओवरलोडिंग के माध्यम से पायथन में इस कार्य को प्राप्त कर सकते हैं। लेकिन पहले, चलो विशेष कार्यों के बारे में एक धारणा प्राप्त करें।
पायथन स्पेशल फंक्शंस
डबल अंडरस्कोर के साथ शुरू होने वाले क्लास फ़ंक्शंस __को पायथन में विशेष फ़ंक्शन कहा जाता है।
ये कार्य वे विशिष्ट कार्य नहीं हैं जिन्हें हम एक वर्ग के लिए परिभाषित करते हैं। __init__()ऊपर हमने जो फ़ंक्शन परिभाषित किया है, उनमें से एक है। हर बार जब हम उस वर्ग की एक नई वस्तु बनाते हैं तो उसे कॉल किया जाता है।
पायथन में कई अन्य विशेष कार्य हैं। उनके बारे में अधिक जानने के लिए पायथन स्पेशल फंक्शन्स पर जाएँ।
विशेष कार्यों का उपयोग करके, हम अपने वर्ग को अंतर्निहित कार्यों के साथ संगत बना सकते हैं।
>>> p1 = Point(2,3) >>> print(p1)
मान लीजिए कि हम चाहते हैं कि हमें जो मिला है उसके बजाय print()फ़ंक्शन के निर्देशांक प्रिंट करें Point। हम __str__()अपने वर्ग में एक विधि को परिभाषित कर सकते हैं जो नियंत्रित करता है कि वस्तु कैसे मुद्रित होती है। आइए देखें कि हम इसे कैसे प्राप्त कर सकते हैं:
class Point: def __init__(self, x = 0, y = 0): self.x = x self.y = y def __str__(self): return "((0),(1))".format(self.x,self.y)
अब print()फंक्शन को फिर से ट्राई करें
class Point: def __init__(self, x=0, y=0): self.x = x self.y = y def __str__(self): return "((0), (1))".format(self.x, self.y) p1 = Point(2, 3) print(p1)
आउटपुट
(२, ३)
वह बेहतर है। पता चला है, कि जब हम का उपयोग में निर्मित समारोह इस एक ही विधि शुरू हो जाती है str()या format()।
>>> str(p1) '(2,3)' >>> format(p1) '(2,3)'
इसलिए, जब आप उपयोग करते हैं str(p1)या format(p1), पायथन आंतरिक रूप से p1.__str__()विधि कहता है । इसलिए नाम, विशेष कार्य।
अब चलते हैं ऑपरेटर ओवरलोडिंग पर।
ओवरलोडिंग + ऑपरेटर
+ऑपरेटर को अधिभारित करने के लिए , हमें __add__()कक्षा में फ़ंक्शन को लागू करना होगा । महान सत्ताओं के साथ ही महान जिम्मेदारियां भी आती हैं। इस फंक्शन के अंदर हम जो चाहें वो कर सकते हैं। लेकिन Pointसमन्वय राशि का एक वस्तु लौटना अधिक समझदार है ।
class Point: def __init__(self, x=0, y=0): self.x = x self.y = y def __str__(self): return "((0),(1))".format(self.x, self.y) def __add__(self, other): x = self.x + other.x y = self.y + other.y return Point(x, y)
अब इसके अतिरिक्त ऑपरेशन को फिर से आज़माएँ:
class Point: def __init__(self, x=0, y=0): self.x = x self.y = y def __str__(self): return "((0),(1))".format(self.x, self.y) def __add__(self, other): x = self.x + other.x y = self.y + other.y return Point(x, y) p1 = Point(1, 2) p2 = Point(2, 3) print(p1+p2)
आउटपुट
(3,5)
वास्तव में क्या होता है, जब आप उपयोग करते हैं p1 + p2, तो पायथन कॉल करता है p1.__add__(p2)जो बदले में होता है Point.__add__(p1,p2)। इसके बाद, अतिरिक्त ऑपरेशन को हमारे द्वारा निर्दिष्ट तरीके से किया जाता है।
इसी तरह, हम अन्य ऑपरेटरों को भी ओवरलोड कर सकते हैं। विशेष कार्य जिसे हमें लागू करने की आवश्यकता है वह नीचे सारणीबद्ध है।
| ऑपरेटर | अभिव्यक्ति | आंतरिक रूप से |
|---|---|---|
| जोड़ | p1 + p2 | p1.__add__(p2) |
| घटाव | p1 - p2 | p1.__sub__(p2) |
| गुणन | p1 * p2 | p1.__mul__(p2) |
| शक्ति | p1 ** p2 | p1.__pow__(p2) |
| विभाजन | p1 / p2 | p1.__truediv__(p2) |
| फ्लोर डिवीजन | p1 // p2 | p1.__floordiv__(p2) |
| शेष (मोडुलो) | p1 % p2 | p1.__mod__(p2) |
| बिटवाइस लेफ्ट शिफ्ट | p1 << p2 | p1.__lshift__(p2) |
| बिटवाइज़ राइट शिफ्ट | p1>> p2 | p1.__rshift__(p2) |
| बिटवाइज़ और | p1 & p2 | p1.__and__(p2) |
| बिटवार या | p1 | p2 | p1.__or__(p2) |
| बिटवाइज़ XOR | p1 p2 | p1.__xor__(p2) |
| बिटवाइज़ नहीं | ~p1 | p1.__invert__() |
ओवरलोडिंग तुलनात्मक संचालक
पायथन केवल ऑपरेटर को अंकगणित करने के लिए सीमित नहीं करता है। हम तुलना ऑपरेटरों को भी अधिभारित कर सकते हैं।
मान लीजिए कि हम <अपनी Pointकक्षा में प्रतीक चिन्ह से कम लागू करना चाहते थे ।
Let us compare the magnitude of these points from the origin and return the result for this purpose. It can be implemented as follows.
# overloading the less than operator class Point: def __init__(self, x=0, y=0): self.x = x self.y = y def __str__(self): return "((0),(1))".format(self.x, self.y) def __lt__(self, other): self_mag = (self.x ** 2) + (self.y ** 2) other_mag = (other.x ** 2) + (other.y ** 2) return self_mag < other_mag p1 = Point(1,1) p2 = Point(-2,-3) p3 = Point(1,-1) # use less than print(p1
Output
True False FalseSimilarly, the special functions that we need to implement, to overload other comparison operators are tabulated below.
Operator Expression Internally
Less than p1 < p2p1.__lt__(p2)
Less than or equal to p1 <= p2p1.__le__(p2)
Equal to p1 == p2p1.__eq__(p2)
Not equal to p1 != p2p1.__ne__(p2)
Greater than p1> p2p1.__gt__(p2)
Greater than or equal to p1>= p2p1.__ge__(p2)
