पायथन में फंक्शन ओवरलोडिंग को समझना

फ़ंक्शन ओवरलोडिंग कुछ प्रोग्रामिंग भाषाओं में एक सुविधा है जो आपको एक ही फ़ंक्शन की विविधताओं को परिभाषित करने देती है। प्रत्येक संस्करण का एक ही नाम है, लेकिन अद्वितीय फ़ंक्शन हस्ताक्षरों के साथ अलग-अलग कार्यान्वयन हैं।

यह तकनीक आपको किसी फ़ंक्शन में दिए गए तर्कों के प्रकार और संख्या के आधार पर विभिन्न ऑपरेशन करने की सुविधा देती है।

C++ और Java जैसी भाषाओं के विपरीत, Python डिफ़ॉल्ट रूप से फ़ंक्शन ओवरलोडिंग का समर्थन नहीं करता है, लेकिन समान कार्यक्षमता प्राप्त करने के तरीके हैं।

पायथन फ़ंक्शन ओवरलोडिंग को कैसे संभालता है?

पायथन में, आप प्रत्येक परिभाषा में विभिन्न मापदंडों, डेटा प्रकारों या दोनों के साथ एक ही फ़ंक्शन को एक से अधिक बार परिभाषित कर सकते हैं। हालाँकि, जब आप इसे कॉल करेंगे तो पायथन केवल फ़ंक्शन की अंतिम परिभाषा को पहचानेगा। यहाँ एक उदाहरण है:

defarithmetics(a, b):
return a - b
defarithmetics(a, b, c, d):
return a + b - c * d
print(arithmetics(1, 2, 3, 5)) # returns -12
print(arithmetics(1, 2)) # returns missing positional arguments error

जावा जैसी ऑब्जेक्ट-ओरिएंटेड भाषाएं अक्सर फ़ंक्शन और विधि ओवरलोडिंग का समर्थन करती हैं। एक विधि बस एक फ़ंक्शन है जिसे आप कक्षा के अंदर परिभाषित करते हैं।

उपरोक्त कोड में, पायथन केवल दूसरी परिभाषा को पहचानेगा अंकगणित() जब आप इसे अपने प्रोजेक्ट में कॉल करने का प्रयास करते हैं तो फ़ंक्शन। यदि आप फ़ंक्शन को पहले परिभाषित दो तर्कों के साथ कॉल करने का प्रयास करते हैं, तो आपको एक त्रुटि मिलेगी जो कहती है, "आवश्यक स्थितीय तर्क गायब हैं"।

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

इसलिए, पायथन डिफ़ॉल्ट रूप से फ़ंक्शन ओवरलोडिंग को संभाल नहीं पाता है, लेकिन कुछ तरकीबें हैं जिनका उपयोग आप अपने प्रोग्राम में इसके व्यवहार को अनुकरण करने के लिए कर सकते हैं।

विधि 1: वैकल्पिक पैरामीटर्स या डिफ़ॉल्ट तर्कों का उपयोग करना

आप किसी फ़ंक्शन को डिफ़ॉल्ट तर्कों के साथ परिभाषित करके ओवरलोडिंग प्राप्त कर सकते हैं। यहाँ एक उदाहरण है:

defarithmetics(a, b=0, c=0):

 Arguments:
 a: The first number.
 b: The second number (optional).
 c: The third number (optional).

return a - b + c

इस फ़ंक्शन में तीन पैरामीटर हैं, लेकिन उनमें से दो में डिफ़ॉल्ट मान हैं। इसका मतलब है कि आप इसे एक से तीन तर्कों के बीच कॉल कर सकते हैं:

print(arithmetics(1)) # returns 1
print(arithmetics(2, 5)) # returns -3
print(arithmetics(10, 3, 4)) # returns 11

हालाँकि यह दृष्टिकोण आपको फ़ंक्शन को कई अलग-अलग तरीकों से कॉल करने की अनुमति देता है, लेकिन लंबे समय में यह बहुत प्रभावी नहीं है। यहां इसकी कुछ सीमाएँ दी गई हैं:

• आप केवल वे तर्क पारित कर सकते हैं जो या तो पूर्णांक हैं या फ़्लोट हैं।
• फ़ंक्शन के व्यवहार में कोई महत्वपूर्ण परिवर्तन नहीं हुआ है. उदाहरण के लिए, आप किसी आकृति या प्रिंट के क्षेत्रफल की गणना करने के लिए उसका व्यवहार नहीं बदल सकते हैलो वर्ल्ड.

विधि 2: परिवर्तनशील तर्कों का उपयोग करना

आपको पायथन में फ़ंक्शन ओवरलोडिंग के लिए परिवर्तनीय तर्कों का उपयोग करना चाहिए अपने फ़ंक्शन को परिभाषित करते समय args पैरामीटर शामिल करें. तर्क पैरामीटर आपको अपने फ़ंक्शन को कॉल करते समय कई स्थितीय तर्क पारित करने की अनुमति देता है। यहाँ एक उदाहरण है:

defarithmetics(a, *args):

 Arguments:
 a: The first number.
 *args: A variable number of arguments (optional).

 args_sum = 0
for num in args:
 args_sum *= num
return a - args_sum
print(arithmetics(1)) # returns 1
print(arithmetics(2, 5)) # returns 2
print(arithmetics(10, 3, 4, 2, 4, 6)) # returns 10

उपरोक्त फ़ंक्शन दो तर्क लेता है: एक अनिवार्य तर्क कहा जाता है ए और यह तर्क तर्क, जो आपको आवश्यकतानुसार उतने तर्क दर्ज करने की अनुमति देता है।

हालाँकि यह कई तर्क ले सकता है, उपरोक्त फ़ंक्शन केवल चर तर्कों पर गुणन ऑपरेशन कर सकता है, अर्थात, द्वारा दर्शाए गए तर्क तर्क कीवर्ड.

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

विधि 3: मल्टीपल डिस्पैच डेकोरेटर का उपयोग करना

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

मल्टीपल डिस्पैच डेकोरेटर का उपयोग करने के लिए, इन चरणों का पालन करें:

1. स्थापित करना मल्टीडिसपैथ आपके पायथन वातावरण में:

   pip install multipledispatch
   

2. अपने फंक्शन को इनसे सजाएं @प्रेषण डेकोरेटर. @प्रेषण डेकोरेटर एक है पायथन डेकोरेटर जो आपको एकाधिक प्रेषण लागू करने की अनुमति देता है। यह आपके द्वारा दिए गए तर्कों के आधार पर स्वचालित रूप से उचित फ़ंक्शन भेज देगा। आप इसका उपयोग कर सकते हैं @प्रेषण इस पैटर्न का पालन करके डेकोरेटर:

   from multipledispatch import dispatch
   @dispatch(data type1, data type2, data typeX)
   defyour_function(a, b, c, x):
   pass
   # perform your operations here
   

यहां एक उदाहरण दिया गया है जो पायथन में फ़ंक्शन ओवरलोडिंग के लिए मल्टीपल डिस्पैच डेकोरेटर का उपयोग करता है:

from multipledispatch import dispatch
@dispatch(int, int)
defadd(a, b):

 Arguments:
 a: Any integer.
 b: Any integer.

return a + b
@dispatch(int, list)
defadd(a, b):

 Arguments:
 a: Any integer.
 b: Any Python list.

 b.append(a)
return b
# returns 3
print(add(1, 2))
# returns [2, 3, 4, 5, 'w', 'done', 1]
print(add(1, [2, 3, 4, 5, 'w', 'done']))

उपरोक्त कोड स्निपेट दो उदाहरणों को परिभाषित करता है जोड़ना() समारोह। पहला उदाहरण दो पूर्णांकों को अपने तर्क के रूप में लेता है और उनका योग लौटाता है।

इस बीच, इस फ़ंक्शन का दूसरा संस्करण एक पूर्णांक और एक सूची लेता है। यह पूर्णांक को सूची में जोड़ता है और नई सूची लौटाता है।

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

पायथन में फंक्शन ओवरलोडिंग के प्रति सर्वोत्तम दृष्टिकोण

ओवरलोडिंग के लिए आप जो दृष्टिकोण अपनाते हैं, वह इस बात पर निर्भर होना चाहिए कि आप क्या हासिल करने की कोशिश कर रहे हैं। यदि आप डिफ़ॉल्ट या परिवर्तनीय तर्कों का उपयोग करके अपना कार्य पूरा कर सकते हैं, तो मल्टीपल डिस्पैच डेकोरेटर ओवरकिल हो सकता है। हालाँकि, मल्टीपल डिस्पैच डेकोरेटर आमतौर पर अपनी दक्षता और सटीकता के लिए सबसे अच्छा विकल्प है।

यह डेकोरेटर पायथन में फ़ंक्शन ओवरलोडिंग को लागू करने का एक स्वच्छ और लचीला तरीका प्रदान करता है। यह आपको किसी एकल फ़ंक्शन के तर्कों के प्रकार के आधार पर उसके एकाधिक कार्यान्वयन को परिभाषित करने देता है।

इस दृष्टिकोण के साथ, आप लचीले फ़ंक्शन बना सकते हैं जो जटिल सशर्त बयानों की आवश्यकता के बिना विभिन्न पैरामीटर प्रकारों को स्वीकार कर सकते हैं।