Back to the topics list

कार्यों को परिभाषित करना

कार्यों को परिभाषित करना

इस पाठ में, हम फ़ंक्शन के बारे में जानेंगे। फ़ंक्शन निर्देशों का एक छोटा सा ब्लॉक होता है, जैसे कि कोई नुस्खा, जो कंप्यूटर को बताता है कि क्या करना है। फ़ंक्शन हमें बड़ी समस्याओं को छोटे-छोटे टुकड़ों में तोड़ने में मदद करते हैं। वे हमारे काम को आसान बनाते हैं और हमारे प्रोग्राम को स्पष्ट बनाते हैं। आज, हम देखेंगे कि फ़ंक्शन क्या हैं, हम उनका उपयोग क्यों करते हैं, और वे हमें सरल तरीके से प्रोग्राम बनाने में कैसे मदद करते हैं।

परिचय

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

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

फ़ंक्शन क्या है?

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

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

हम फ़ंक्शन का उपयोग क्यों करते हैं?

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

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

फ़ंक्शन को कैसे परिभाषित करें

हम एक विशेष कोड का उपयोग करके फ़ंक्शन को परिभाषित कर सकते हैं। कई प्रोग्रामिंग भाषाओं में, हम एक कीवर्ड का उपयोग करते हैं जो कंप्यूटर को बताता है कि हम एक फ़ंक्शन बना रहे हैं। प्रोग्रामिंग सिखाने के लिए इस्तेमाल की जाने वाली एक लोकप्रिय भाषा पायथन है। पायथन में, हम फ़ंक्शन शुरू करने के लिए def शब्द का उपयोग करते हैं। यहाँ एक सरल उदाहरण दिया गया है:

उदाहरण:

 डेफ़ say_hello():
    प्रिंट("नमस्ते, मित्र!")
  

इस उदाहरण में, फ़ंक्शन को say_hello कहा जाता है। def शब्द कंप्यूटर को बताता है कि हम एक फ़ंक्शन परिभाषित कर रहे हैं। फ़ंक्शन एक काम करता है: यह स्क्रीन पर एक दोस्ताना संदेश प्रिंट करता है।

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

फ़ंक्शन के सरल उदाहरण

अब हम फ़ंक्शन के तीन सरल उदाहरण देखेंगे। उन्हें समझना आसान है और वे हमें बुनियादी विचार सीखने में मदद करते हैं।

उदाहरण 1: अभिवादन फ़ंक्शन

पहले उदाहरण में, हम एक ऐसा फ़ंक्शन बनाते हैं जो किसी व्यक्ति का नाम लेकर अभिवादन करता है। जब हम फ़ंक्शन को कॉल करते हैं, तो यह किसी मित्र को नमस्ते कहता है।

कोड:

 डेफ़ अभिवादन (नाम):
    प्रिंट("नमस्ते, " + नाम + "!")
  
# "ऐलिस" नाम से फ़ंक्शन को कॉल करना
नमस्कार("ऐलिस")
  

चरण-दर-चरण स्पष्टीकरण:

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

उदाहरण 2: योग फ़ंक्शन

दूसरे उदाहरण में, हम एक ऐसा फ़ंक्शन लिखते हैं जो दो संख्याओं को जोड़ता है। यह एक मिनी कैलकुलेटर की तरह है जो संख्याओं को एक साथ जोड़ता है।

कोड:

 def add_numbers(संख्या1, संख्या2):
    परिणाम = संख्या1 + संख्या2
    प्रिंट("योग है:", परिणाम)
  
# संख्या 3 और 5 के साथ फ़ंक्शन को कॉल करना
add_numbers(3, 5)
  

चरण-दर-चरण स्पष्टीकरण:

• add_numbers फ़ंक्शन को दो पैरामीटरों के साथ परिभाषित किया गया है: num1 और num2 .
• फ़ंक्शन के अंदर, दो संख्याओं को एक साथ जोड़ा जाता है। यह कुल परिणाम नामक एक चर में संग्रहीत किया जाता है।
• इसके बाद फ़ंक्शन "योग है:" प्रिंट करता है, जिसके बाद परिणाम का मान आता है।
• जब हम add_numbers(3, 5) को कॉल करते हैं, तो फ़ंक्शन 3 और 5 को जोड़कर 8 देता है, जिसे फिर प्रिंट किया जाता है।

उदाहरण 3: गुणन फलन

तीसरे उदाहरण में, हम एक ऐसा फ़ंक्शन बनाएंगे जो किसी संख्या को 2 से गुणा करता है। यह फ़ंक्शन दिखाता है कि कोई फ़ंक्शन बाद में उपयोग के लिए मान कैसे लौटा सकता है।

कोड:

 def गुणा_से_दो(x):
    नया_मूल्य = x * 2
    नया_मूल्य लौटाएं
  
# फ़ंक्शन को कॉल करना और परिणाम को सहेजना
परिणाम = गुणा_दो_से(4)
प्रिंट("4 गुणा 2 है", परिणाम)
  

चरण-दर-चरण स्पष्टीकरण:

• फ़ंक्शन multiply_by_two को एक पैरामीटर x के साथ परिभाषित किया गया है।
• फ़ंक्शन के अंदर, x के मान को 2 से गुणा किया जाता है और new_value नामक चर में संग्रहीत किया जाता है।
• फ़ंक्शन परिणाम को वापस उस स्थान पर भेजने के लिए return कीवर्ड का उपयोग करता है जहां फ़ंक्शन को कॉल किया गया था।
• जब हम multiply_by_two(4) को कॉल करते हैं, तो फ़ंक्शन गणना करता है कि 4 को 2 से गुणा करने पर 8 आता है और यह मान लौटाता है।
• लौटाया गया मान result नामक चर में संग्रहीत किया जाता है, जिसे बाद में मुद्रित किया जाता है।

पैरामीटर्स और रिटर्न वैल्यूज़ को समझना

फ़ंक्शन पैरामीटर के माध्यम से बाहर से जानकारी स्वीकार कर सकते हैं। पैरामीटर एक वैरिएबल है जो फ़ंक्शन को कॉल किए जाने पर डेटा रखता है। हमारे उदाहरणों में, नाम , num1 , num2 और x पैरामीटर हैं।

कुछ फ़ंक्शन मान लौटाते हैं । रिटर्न वैल्यू वह परिणाम है जो फ़ंक्शन अपना काम करने के बाद देता है। उदाहरण 3 में, फ़ंक्शन मल्टीप्लाय_बाय_टू एक मान लौटाता है जो फिर एक चर में संग्रहीत हो जाता है।

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

मॉड्यूलर प्रोग्रामिंग: समस्याओं को टुकड़ों में तोड़ना

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

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

मॉड्यूलर प्रोग्रामिंग दोहराव को कम करने में मदद करती है। अगर आपके प्रोग्राम के किसी हिस्से को बार-बार एक ही काम करने की ज़रूरत है, तो आप उसके लिए एक फ़ंक्शन लिखते हैं। फिर जब भी आपको वह काम पूरा करना होता है, तो आप वही कोड लिखने के बजाय बस फ़ंक्शन को कॉल करते हैं।

यह दृष्टिकोण ऐसा है जैसे आपके पास एक सहायक हो जो जूते के फीते बांधना जानता हो, ताकि आपको हर बार नए जूते खरीदने पर यह काम दोबारा न सीखना पड़े।

रोज़मर्रा के प्रासंगिक उदाहरण

आइए हम कार्यों की तुलना रोज़मर्रा की गतिविधियों से करें। कल्पना करें कि आपके घर में बहुत सारे काम हैं। आपके कामों में से एक है पौधों को पानी देना। हर बार सभी चरणों के बारे में सोचने के बजाय, आप याद रख सकते हैं, "पौधों को पानी दें।" हर बार जब आप पौधों पर काम करते हैं, तो आप अपना खुद का कार्य इस्तेमाल कर रहे होते हैं।

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

ये रोजमर्रा के उदाहरण दिखाते हैं कि फ़ंक्शन हमें कई कार्यों को स्पष्ट, सरल भागों में तोड़कर उन्हें पूरा करने में मदद करते हैं।

फ़ंक्शन परिभाषित करने के बारे में अधिक जानकारी

जब आप फ़ंक्शन के बारे में सीखना शुरू करेंगे, तो आप देखेंगे कि प्रत्येक फ़ंक्शन का एक नाम होता है, कोष्ठकों के अंदर पैरामीटर की एक सूची होती है, और अंदर कोड का एक ब्लॉक होता है। यह एक साधारण प्रारूप में इस तरह दिख सकता है:

सामान्य संरचना:

 def फ़ंक्शन_नाम(पैरामीटर1, पैरामीटर2, ...):
    # कोड ब्लॉक
    यदि आवश्यक हो तो some_value # लौटाएं
  

यहाँ, function_name फ़ंक्शन का नाम है। पैरामीटर इनपुट हैं जिनका उपयोग फ़ंक्शन करता है। कोड ब्लॉक निर्देशों का सेट है जिसे फ़ंक्शन निष्पादित करेगा। अंत में, return परिणाम वापस देता है।

आप कभी-कभी ऐसे फ़ंक्शन देख सकते हैं जिनमें कोई पैरामीटर नहीं होता। जब किसी फ़ंक्शन को किसी अतिरिक्त जानकारी की आवश्यकता नहीं होती है, तब भी आप कोष्ठक लिखते हैं, लेकिन वे खाली रहते हैं। इसी तरह, कई फ़ंक्शन संदेश प्रिंट करने जैसी क्रियाएँ करते हैं और कोई मान नहीं लौटाते हैं।

कार्यों के आवश्यक गुण

यहां फ़ंक्शन के कुछ महत्वपूर्ण गुण दिए गए हैं जिन्हें आपको याद रखना चाहिए:

• पुन: प्रयोज्यता: एक बार कोई फ़ंक्शन परिभाषित हो जाने पर, आप उसी कोड को दोबारा लिखे बिना उसे कई बार उपयोग कर सकते हैं।
• मॉड्यूलरिटी: फंक्शन प्रोग्राम को छोटे भागों में तोड़ने में मदद करते हैं। प्रत्येक भाग एक विशिष्ट कार्य करता है।
• रखरखाव: यदि कोई त्रुटि है या परिवर्तन की आवश्यकता है, तो आप कोड की कई पंक्तियों के बजाय केवल एक फ़ंक्शन को ठीक कर सकते हैं।
• स्पष्टता: फ़ंक्शन प्रोग्राम को पढ़ने में आसान बनाते हैं। बहुत सारे कोड पढ़ने के बजाय, आप स्पष्ट फ़ंक्शन नाम देखते हैं जो आपको बताते हैं कि प्रत्येक भाग क्या करता है।

इन गुणों का पालन करके, प्रोग्रामर ऐसे प्रोग्राम बना सकते हैं जिन्हें समझना, डीबग करना और समय के साथ सुधारना आसान होता है। जिस तरह आप अपने खिलौनों को बक्सों में अलग करके अपने कमरे को साफ-सुथरा रखते हैं, उसी तरह फंक्शन प्रोग्राम को साफ-सुथरा और व्यवस्थित रखते हैं।

विविधताएं और अधिक उन्नत विचार

जैसे-जैसे आप फ़ंक्शन के विचार से अधिक सहज होते जाते हैं, आपको कुछ भिन्नताएँ देखने को मिल सकती हैं। कभी-कभी फ़ंक्शन कुछ भी नहीं लौटाते हैं; वे केवल क्रियाएँ करते हैं। अन्य बार, फ़ंक्शन अन्य फ़ंक्शन को कॉल कर सकते हैं। इसे नेस्टिंग फ़ंक्शन या फ़ंक्शन कंपोजिशन के रूप में जाना जाता है।

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

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

अतिरिक्त उदाहरण और चरण-दर-चरण समाधान

आइए दो और विस्तृत उदाहरण देखें जो दिखाते हैं कि फ़ंक्शन चरण दर चरण कैसे काम करते हैं।

उदाहरण 4: सम संख्याओं की जाँच करने के लिए एक फ़ंक्शन

 def is_even(संख्या):
    # जाँचें कि संख्या सम है या नहीं
    यदि संख्या % 2 == 0:
        सत्य लौटें
    अन्य:
        विवरण झूठा है

# संख्या 6 की जांच करने के लिए फ़ंक्शन का उपयोग करना
परिणाम = is_even(6)
प्रिंट("क्या 6 सम है?", परिणाम)
  

चरण-दर-चरण स्पष्टीकरण:

• फ़ंक्शन is_even number नामक एक पैरामीटर लेता है।
• यह मापांक ऑपरेटर % का उपयोग करके जाँचता है कि 2 से विभाजित संख्या में कोई शेष नहीं है।
• यदि कोई शेष नहीं है, तो फ़ंक्शन True लौटाता है, जिसका अर्थ है कि संख्या सम है।
• यदि कोई शेष है, तो फ़ंक्शन False लौटाता है।
• जब is_even(6) को कॉल किया जाता है, तो फ़ंक्शन जाँचता है और पाता है कि 6 सम है, इसलिए यह True लौटाता है।

उदाहरण 5: वर्ग का क्षेत्रफल ज्ञात करने के लिए एक फ़ंक्शन

 def क्षेत्र_का_वर्ग(पक्ष_लंबाई):
    # सूत्र का उपयोग करके क्षेत्रफल की गणना करें: क्षेत्रफल = भुजा_लंबाई * भुजा_लंबाई
    क्षेत्र = भुजा_लंबाई * भुजा_लंबाई
    वापसी क्षेत्र

# 5 भुजा लंबाई वाले वर्ग के क्षेत्रफल की गणना करने के लिए फ़ंक्शन का उपयोग करना
वर्ग_क्षेत्रफल = वर्ग_का_क्षेत्रफल(5)
प्रिंट("वर्ग का क्षेत्रफल है", square_area)
  

चरण-दर-चरण स्पष्टीकरण:

• फ़ंक्शन area_of_square पैरामीटर के रूप में side_length का उपयोग करता है।
• फ़ंक्शन के अंदर, यह भुजा की लंबाई को खुद से गुणा करता है। यह गणितीय सूत्र \(\textrm{क्षेत्र} = \textrm{भुजा\_लंबाई} \times \textrm{भुजा\_लंबाई}\) अनुसरण करता है।
• फिर गणना किया गया क्षेत्र प्रोग्राम के मुख्य भाग में वापस आ जाता है।
• जब हम area_of_square(5) को कॉल करते हैं, तो फ़ंक्शन \(5 \times 5\) की गणना करके 25 देता है।

उदाहरण 6: दो संख्याओं में से बड़ी संख्या निर्धारित करने के लिए एक फ़ंक्शन

 डेफ़ बड़ा_नंबर(ए, बी):
    # दो संख्याओं की तुलना करें और बड़ी संख्या लौटाएं
    यदि a > b:
        वापस लौटें
    अन्य:
        वापसी बी

# 7 और 10 के बीच बड़ी संख्या ज्ञात करने के लिए फ़ंक्शन का उपयोग करना
सबसे बड़ा = बड़ा_नंबर(7, 10)
प्रिंट("बड़ी संख्या है", सबसे बड़ी)
  

चरण-दर-चरण स्पष्टीकरण:

• फ़ंक्शन bigger_number दो पैरामीटर लेता है: a और b ।
• यह दो संख्याओं की तुलना करता है।
• यदि a , b से बड़ा है, तो यह a लौटाता है। अन्यथा, यह b लौटाता है।
• उदाहरण में, bigger_number(7, 10) 10 लौटाता है क्योंकि 10, 7 से बड़ा है।

मॉड्यूलरिटी के लिए फंक्शन क्यों महत्वपूर्ण हैं

फ़ंक्शन एक शक्तिशाली उपकरण है जो हमें मॉड्यूलर तरीके से प्रोग्राम बनाने में मदद करता है। फ़ंक्शन का उपयोग करके, आप अपने प्रोग्राम के अलग-अलग हिस्से बना सकते हैं जो स्वतंत्र रूप से काम करते हैं। इसका मतलब यह है कि अगर आपके प्रोग्राम के किसी हिस्से में कोई गलती है या उसमें सुधार की ज़रूरत है, तो आपको कोड के बड़े ढेर को देखने के बजाय केवल उस एक फ़ंक्शन को ठीक करना होगा।

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

प्रोग्रामिंग का यह तरीका आपको समस्याओं को बेहतर ढंग से समझने में मदद करता है और जटिल कार्यों को आसान बनाता है। यह आपको समस्याओं के बारे में तार्किक रूप से सोचना और उन्हें चरणबद्ध तरीके से हल करना भी सिखाता है।

मुख्य बिंदुओं का सारांश

• परिभाषा: फ़ंक्शन कोड का एक ब्लॉक है जो एक विशिष्ट कार्य करता है।
• पुन: प्रयोज्यता: एक बार कोई फ़ंक्शन परिभाषित हो जाने पर, उसे पूरे प्रोग्राम में कई बार उपयोग किया जा सकता है।
• संरचना: फ़ंक्शन को एक विशेष कीवर्ड (जैसे पायथन में def ) का उपयोग करके परिभाषित किया जाता है और इसमें पैरामीटर और रिटर्न मान शामिल हो सकते हैं।
• सरल उदाहरण: हमने किसी का अभिवादन करने, संख्याओं को जोड़ने, किसी संख्या को दो से गुणा करने, किसी संख्या के सम होने की जांच करने, क्षेत्रफल की गणना करने तथा दो संख्याओं की तुलना करने के कार्यों को देखा।
• मॉड्यूलर प्रोग्रामिंग: फ़ंक्शन किसी बड़ी समस्या को छोटे, आसान भागों में तोड़ने में मदद करते हैं। इससे प्रोग्राम लिखना, पढ़ना और ठीक करना आसान हो जाता है।
• दैनिक तुलना: जैसे किसी रेसिपी का अनुसरण करना या छोटे लेगो ब्लॉकों का उपयोग करके बड़ी संरचना बनाना, वैसे ही फंक्शन हमें अपने दैनिक जीवन में कार्यों को व्यवस्थित करने में मदद करते हैं।
• लचीलापन: पैरामीटर्स फ़ंक्शन को विभिन्न इनपुट के साथ काम करने की अनुमति देते हैं, और रिटर्न मान हमें परिणामों का उपयोग करने की क्षमता देते हैं।
• वास्तविक-विश्व प्रभाव: फंक्शन और मॉड्यूलर प्रोग्रामिंग आधुनिक प्रौद्योगिकी के निर्माण खंड हैं, जिनका उपयोग गेम, ऐप्स और कई दैनिक जीवन प्रणालियों में किया जाता है।

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

हमेशा याद रखें: हर बड़े कार्य को छोटे-छोटे कदमों से आसान बनाया जा सकता है, और वे छोटे-छोटे कदम ही आपके प्रोग्राम के फंक्शन हैं।

प्रोग्रामिंग के साथ सीखते रहें, खोज करते रहें और मज़े करते रहें। फंक्शन रचनात्मक और उपयोगी कोड लिखने का पहला कदम है!