This post is also available in: English العربية (Arabic)
एक शुरुआत के रूप में, हम बहुत छोटे प्रोग्राम लिखते हैं। जब कोई कार्यक्रम काफी छोटा होता है, तो हम कार्यक्रम के सभी विवरण एक ही बार में अपने दिमाग में रख सकते हैं। वास्तविक एप्लिकेशन प्रोग्राम आपके द्वारा लिखे गए किसी भी प्रोग्राम से 100 से 10000 गुना बड़े होते हैं (या शायद इस पर काम भी किया हो); वे हमारे सिर में अपना सारा विवरण रखने के लिए बस बहुत बड़े और जटिल होते हैं।
बड़े सॉफ़्टवेयर की जटिलता को प्रबंधित करने का एक प्रमुख समाधान मॉड्यूलर प्रोग्रामिंग है: कोड कई अलग-अलग कोड मॉड्यूल से बना होता है जिन्हें आमतौर पर विकसित फ़ंक्शन के रूप में जाना जाता है। यह विभिन्न डेवलपर्स को सिस्टम के असतत टुकड़ों को लेने और बाकी सभी को समझे बिना उन्हें डिजाइन करने और उन्हें लागू करने की अनुमति देता है। इस लेख में, हम पायथन में विभिन्न प्रकार के फंक्शन्स पर गौर करेंगे।
फंक्शन क्या है?
एक फ़ंक्शन कोड का एक ब्लॉक है जो कुछ विशिष्ट कार्य करता है। इसे कई बार बुलाया और पुन: उपयोग किया जा सकता है। आप जानकारी पास कर सकते हैं और यह जानकारी वापस भेज सकता है। कई प्रोग्रामिंग भाषाओं में दो प्रकार के फंक्शन्स होते हैं:
- बिल्ट-इन फंक्शन्स: एक फंक्शन जो किसी एप्लिकेशन या प्रोग्रामिंग लैंग्वेज में बनाया गया है और इसे एंड-यूजर्स द्वारा एक्सेस किया जा सकता है। उदाहरण के लिए, अधिकांश स्प्रैडशीट एप्लिकेशन एक अंतर्निहित (बिल्ट-इन) SUM फ़ंक्शन का समर्थन करते हैं जो एक पंक्ति या स्तंभ में सभी कक्षों को जोड़ता है। इसी तरह, C में printf() और scanf() बिल्ट-इन फ़ंक्शन हैं जिनका उपयोग मूल्यों को प्रिंट करने और पढ़ने के लिए किया जाता है।
- यूज़र-डिफाइंड फंक्शन्स: एक उपयोगकर्ता अपने प्रोग्राम के लिए प्रासंगिक कार्य करने के लिए फंक्शन्स को परिभाषित कर सकता है। ऐसे फंक्शन्स को यूज़र-डिफाइंड फंक्शन्स कहा जाता है। main() फ़ंक्शन जिसमें हम अपने सभी प्रोग्राम लिखते हैं, एक यूज़र-डिफाइंड फ़ंक्शन है।
जब आप किसी फ़ंक्शन को कॉल करते हैं, तो प्रोग्राम वर्तमान प्रोग्राम को रोक देगा और फ़ंक्शन को निष्पादित करेगा। फ़ंक्शन को ऊपर से नीचे की ओर निष्पादित किया जाता है। एक बार फ़ंक्शन पूरा हो जाने के बाद, प्रोग्राम वहीं से शुरू होता है जहां वह रुका था। यदि फ़ंक्शन ने कोई मान लौटाया है, तो उस मान का उपयोग किया जाएगा जहां फ़ंक्शन को कॉल किया गया था।
पायथन में फंक्शन्स के प्रकार
जैसा कि ऊपर उल्लेख किया गया है, आप प्रोग्रामिंग में फ़ंक्शंस का उपयोग उन निर्देशों के एक सेट को बंडल करने के लिए करते हैं जिन्हें आप बार-बार उपयोग करना चाहते हैं या, उनकी जटिलता के कारण, उप-प्रोग्राम में बेहतर स्व-निहित हैं और आवश्यकता होने पर कॉल किए जाते हैं। इसका मतलब है कि एक फ़ंक्शन एक निर्दिष्ट कार्य को पूरा करने के लिए लिखा गया कोड का एक टुकड़ा है। उस विशिष्ट कार्य को करने के लिए, फ़ंक्शन को कई इनपुट की आवश्यकता हो भी सकती है और नहीं भी। जब कार्य किया जाता है, तो फ़ंक्शन एक या अधिक मान वापस कर सकता है या नहीं।
पायथन में तीन प्रकार के फंक्शन्स होते हैं:
- बिल्ट-इन फंक्शंस: ये पाइथन में बिल्ट-इन फंक्शन हैं जैसे help() मदद मांगना, मिनिमम वैल्यू पाने के लिए min(), टर्मिनल पर ऑब्जेक्ट प्रिंट करने के लिए print()।
- यूज़र डिफाइंड फंक्शन(यूडीएफ): ये उपयोगकर्ता द्वारा उनकी प्रोग्रामिंग आवश्यकताओं के अनुसार बनाए गए फंक्शन्स हैं।
- एनोनिमस फ़ंक्शंस: इन फ़ंक्शंस को लैम्ब्डा फ़ंक्शंस (lambda functions) भी कहा जाता है क्योंकि इन्हें मानक def कीवर्ड के साथ घोषित नहीं किया जाता है।
फंक्शन्स बनाम मेथड्स
फंक्शन
एक फ़ंक्शन किसी विशिष्ट कार्य को करने के लिए कोड का एक ब्लॉक होता है, जिसमें इसका अपना दायरा होता है, और इसे इसके नाम से पुकारा जाता है। सभी फ़ंक्शन में शून्य (नहीं) आर्गुमेंट या एक से अधिक आर्ग्यूमेंट्स हो सकते हैं। बाहर निकलने पर, कोई फ़ंक्शन एक या अधिक मान वापस कर सकता है या नहीं।
बेसिक फंक्शन सिंटेक्स
def functionName( arg1, arg2,….): ……. # Function_body ……..
निम्नलिखित फ़ंक्शन अभिवादन का एक उदाहरण है जो फ़ंक्शन में दिए गए नाम के लिए ग्रीटिंग संदेश प्रिंट करता है।
def greet(name): “”” This function greets to the person passed in as a parameter “”” print(“Hello, ” + name + “. Good morning!”)>>> greet(‘Paul’)Hello, Paul. Good morning!
मेथड (Method)
पायथन में एक मेथड कुछ हद तक एक फ़ंक्शन के समान है, सिवाय इसके कि यह ऑब्जेक्ट्स/क्लासेज़ से जुड़ा हुआ होता है। पायथन में मेथड्स दो प्रमुख अंतरों को छोड़कर फंक्शन्स के समान होते हैं।
- मेथड का उपयोग उस वस्तु के लिए किया जाता है जिसके लिए इसे एक्टिवेट किया जाता है।
- मेथड उस डेटा के लिए सुलभ है जो क्लास के भीतर निहित है।
बेसिक मेथड सिंटैक्स
class ClassName: def method_name(): ………….. # Method_body ………………
आइए निम्नलिखित सरल कोड के माध्यम से मेथड को समझते हैं:
class Pet(object): def my_method(self): print(“I am a Cat”)cat = Pet()cat.my_method()
आउटपुट:
I am a Cat
उपरोक्त कोड में, हमने पहले Pet क्लास को परिभाषित किया, फिर हमने इस ब्लूप्रिंट से एक ऑब्जेक्ट cat बनाया। इसके बाद, हम ऑब्जेक्ट (यानी, cat) के साथ my_method नामक अपने कस्टम मेथड को कॉल करते हैं।
पैरामीटर बनाम आर्गुमेंट
पैरामीटर और आर्गुमेंट शब्द कई प्रोग्रामर द्वारा परस्पर उपयोग किए जाते हैं, लेकिन उन दोनों के अलग-अलग अर्थ हैं।
एक पैरामीटर एक विशेष प्रकार का चर है जिसका उपयोग फ़ंक्शन में इनपुट के रूप में प्रदान किए गए डेटा के टुकड़ों में से एक को संदर्भित करने के लिए किया जाता है। ये डेटा उन आर्गुमेंट के मान हैं जिनके साथ फ़ंक्शन को कॉल/आह्वान किया जाएगा।
सरल शब्दों में, आर्गुमेंट किसी फ़ंक्शन को दिया गया वास्तविक मान है, जबकि पैरामीटर फ़ंक्शन की परिभाषा के अंदर चर है। हम कह सकते हैं कि एक पैरामीटर एक प्रकार है जो फ़ंक्शन परिभाषाओं में प्रकट होता है, जबकि एक आर्ग्यूमेंट्स एक उदाहरण है जो फ़ंक्शन कॉल में दिखाई देता है। उपरोक्त उदाहरण में name को पैरामीटर कहा जाता है और Paul को आर्गुमेंट कहा जाता है।
पायथन में यूज़र-डिफाइंड फ़ंक्शन (यूडीएफ) को कैसे परिभाषित करें?
पायथन में एक फ़ंक्शन को परिभाषित करने के चार चरण निम्नलिखित हैं:
- फ़ंक्शन घोषित करने के लिए कीवर्ड def का उपयोग करें और फ़ंक्शन नाम के साथ इसे लिखें।
- फ़ंक्शन में पैरामीटर जोड़ें। इन्हें फ़ंक्शन के कोष्ठक के भीतर लिखा जाना चाहिए। एक कोलन के साथ अपनी लाइन समाप्त करें।
- वह स्टेटमेंट जोड़ें जिसे आप फ़ंक्शन से निष्पादित करवाना चाहते हैं।
- यदि फ़ंक्शन को कुछ आउटपुट करना चाहिए तो अपने फ़ंक्शन को रिटर्न (return) स्टेटमेंट के साथ समाप्त करें। रिटर्न स्टेटमेंट के बिना, आपका फ़ंक्शन किसी ऑब्जेक्ट को वापस नहीं करेगा।
पायथन में फ़ंक्शन आर्ग्यूमेंट्स
ऊपर आपने परमटेर्स और आर्ग्यूमेंट्स के बीच अंतर के बारे में सीखा। संक्षेप में, आर्ग्यूमेंट्स वे चीजें हैं जो किसी भी फ़ंक्शन को दी जाती हैं, जबकि फ़ंक्शन कोड उनके पैरामीटर नामों से आर्ग्यूमेंट्स को संदर्भित करता है। चार प्रकार के आर्ग्यूमेंट्स हैं जो पायथन यूडीएफ ले सकते हैं:
- डिफ़ॉल्ट आर्ग्यूमेंट्स
- रिक्वायर्ड आर्ग्यूमेंट्स
- कीवर्ड आर्ग्यूमेंट्स
- आर्ग्यूमेंट्स की परिवर्तनीय संख्या
डिफ़ॉल्ट आर्ग्यूमेंट्स
डिफ़ॉल्ट आर्ग्यूमेंट्स वे हैं जो फ़ंक्शन कॉल के दौरान कोई आर्गुमेंट मान पारित नहीं होने पर डिफ़ॉल्ट मान लेते हैं। आप इस डिफ़ॉल्ट मान को असाइनमेंट ऑपरेटर = के साथ असाइन कर सकते हैं, जैसा कि निम्न उदाहरण में है:
# Define `plus()` functiondef plus(a,b = 2): return a + b# Call `plus()` with only `a` parameterplus(a=1)# Call `plus()` with `a` and `b` parametersplus(a=1, b=3)
रिक्वायर्ड आर्ग्यूमेंट्स
जैसा कि नाम से पता चलता है, यूडीएफ के आवश्यक आर्ग्यूमेंट्स वे हैं जो वहां होने चाहिए। इन आर्ग्यूमेंट्स को फ़ंक्शन कॉल के दौरान और ठीक सही क्रम में पारित करने की आवश्यकता है, बस निम्नलिखित उदाहरण में:
# Define `plus()` with required argumentsdef plus(a,b): return a + b
आपको बिना किसी त्रुटि के फ़ंक्शन को कॉल करने के लिए a के साथ-साथ b पैरामीटर के लिए आर्ग्यूमेंट्स की आवश्यकता है। यदि आप a और बी को आपस में स्विच करते हैं, तो परिणाम अलग नहीं होगा, लेकिन यह हो सकता है कि यदि आप फ़ंक्शन plus() को निम्न में बदलते हैं:
# Define `plus()` with required argumentsdef plus(a,b): return a/b
कीवर्ड आर्ग्यूमेंट्स
यदि आप यह सुनिश्चित करना चाहते हैं कि आप सभी आर्ग्यूमेंट्स को सही क्रम में कहते हैं, तो आप अपने फ़ंक्शन कॉल में कीवर्ड आर्गुमेंट चुन सकते हैं। आप इनका उपयोग आर्ग्यूमेंट्स को उनके पैरामीटर नाम से पहचानने के लिए करते हैं। आइए इसे स्पष्ट करने के लिए ऊपर से उदाहरण लेते हैं।
# Define `plus()` functiondef plus(a,b): return a + b# Call `plus()` function with parameters plus(2,3)# Call `plus()` function with keyword argumentsplus(a=1, b=2)
ध्यान दें कि कीवर्ड आर्ग्यूमेंट्स का उपयोग करके, आप पैरामीटर के क्रम को भी बदल सकते हैं और जब आप अपना फ़ंक्शन निष्पादित करते हैं तब भी वही परिणाम प्राप्त कर सकते हैं:
# Define `plus()` functiondef plus(a,b): return a + b# Call `plus()` function with keyword argumentsplus(b=2, a=1)
आर्ग्यूमेंट्स की परिवर्तनीय संख्या
ऐसे मामलों में जहां आप किसी फ़ंक्शन को पास किए जाने वाले आर्ग्यूमेंट्स की सटीक संख्या नहीं जानते हैं, आप निम्न सिंटैक्स का उपयोग *args के साथ कर सकते हैं:
# Define `plus()` function to accept a variable number of argumentsdef plus(*args): return sum(args)# Calculate the sumplus(1,4,5)plus(5,6,7,8,4)
आउटपुट:
10
30
तारक(एस्टरिस्क) (*) को चर नाम से पहले रखा जाता है जिसमें सभी गैर-कीवर्ड चर आर्ग्यूमेंट्स के मान होते हैं। यहां ध्यान दें कि आपने plus() फ़ंक्शन में *varint, *var_int_args, या कोई अन्य नाम पास किया होगा। *args को किसी अन्य नाम से बदलने का प्रयास करें जिसमें तारक शामिल हो। आप देखेंगे कि उपरोक्त कोड काम करता रहता है!
ग्लोबल बनाम लोकल चर (वेरिएबल)
सामान्य तौर पर, किसी फ़ंक्शन के अंदर परिभाषित चर का एक लोकल दायरा होता है, और जो बाहर परिभाषित होते हैं उनका ग्लोबल दायरा होता है। इसका मतलब है कि लोकल चर को फ़ंक्शन ब्लॉक के भीतर परिभाषित किया गया है और केवल उस फ़ंक्शन के अंदर ही पहुंचा जा सकता है, जबकि ग्लोबल चर को आपकी स्क्रिप्ट में मौजूद सभी फंक्शन्स द्वारा एक्सेस किया जा सकता है।
# Global variable `init`init = 1# Define `plus()` function to accept a variable number of argumentsdef plus(*args): # Local variable `sum()` total = 0 for i in args: total += i return total# Access the global variableprint(“this is the initialized value ” + str(init))# (Try to) access the local variableprint(“this is the sum ” + str(total))
आप देखेंगे कि आपको एक NameError मिलेगा जो कहता है कि name ‘total’ is not defined जब आप स्थानीय चर total को प्रिंट करने का प्रयास करते हैं जिसे फ़ंक्शन बॉडी के अंदर परिभाषित किया गया था। दूसरी ओर, init वैरिएबल को बिना किसी समस्या के प्रिंट किया जा सकता है।
पायथन में एनोनिमस फंक्शन्स
एनोनिमस फंक्शन्स को पायथन में लैम्ब्डा फ़ंक्शन भी कहा जाता है क्योंकि उन्हें मानक def कीवर्ड के साथ घोषित करने के बजाय, आप lambda कीवर्ड का उपयोग करते हैं।
double = lambda x: x*2double(5)
आउटपुट:
10
lambda x: x*2 एनोनिमस या लैम्ब्डा फ़ंक्शन है। x आर्गुमेंट है, और x*2 अभिव्यक्ति या निर्देश है जिसका मूल्यांकन किया जाता है और वापस किया जाता है। इस फ़ंक्शन के बारे में विशेष बात यह है कि इसका कोई नाम नहीं है, जैसा कि आपने उपरोक्त उदाहरण फंक्शन्स में देखा है।
