यस पाठमा, हामी फंक्शनहरूको बारेमा सिक्नेछौं। फंक्शन भनेको निर्देशनहरूको सानो समूह हो, जस्तै रेसिपी, जसले कम्प्युटरलाई के गर्ने भनेर बताउँछ। फंक्शनहरूले हामीलाई ठूला समस्याहरूलाई स-साना टुक्राहरूमा विभाजन गर्न मद्दत गर्दछ। तिनीहरूले हाम्रो कामलाई सजिलो बनाउँछन् र हाम्रा कार्यक्रमहरूलाई स्पष्ट बनाउँछन्। आज, हामी फंक्शनहरू के हुन्, हामी तिनीहरूलाई किन प्रयोग गर्छौं, र तिनीहरूले हामीलाई सरल तरिकाले प्रोग्रामहरू सिर्जना गर्न कसरी मद्दत गर्छन् भनेर हेर्नेछौं।
कल्पना गर्नुहोस् तपाईंसँग एउटा खेलौना मेसिन छ जसले सधैं एउटै काम गर्छ। जब तपाईं बटन थिच्नुहुन्छ, मेसिनले गीत गाउँछ। कम्प्युटर प्रोग्राममा रहेको फंक्शनले पनि त्यस्तै काम गर्छ। यो निर्देशनहरूको सेट हो जुन तपाईं बारम्बार प्रयोग गर्न सक्नुहुन्छ। तपाईंले एक पटक फंक्शन परिभाषित गर्नुहुन्छ, र त्यसपछि तपाईंले यसलाई प्रयोग गर्न आवश्यक पर्दा कल गर्न सक्नुहुन्छ। यो विचारले प्रोग्रामहरूलाई बुझ्न सजिलो र निर्माण गर्न छिटो बनाउँछ।
हाम्रो दैनिक जीवनमा, हामी काम गर्न चरणहरू पालना गर्छौं। उदाहरणका लागि, जब तपाईं आफ्नो दाँत माझ्नुहुन्छ वा स्यान्डविच बनाउनुहुन्छ, तपाईं क्रमशः सरल चरणहरू पालना गर्नुहुन्छ। एउटा प्रकार्य ती चरणहरू जस्तै हो। यी कामहरू कसरी गर्ने भनेर आफूलाई हरेक पटक सम्झाउनुको सट्टा, तपाईंले चरणहरू सम्झनुहुन्छ वा तपाईंको लागि यो गर्ने बटन थिच्नुहुन्छ।
फंक्शन भनेको कोडको नाम दिइएको ब्लक हो जसले एउटा विशेष कार्य गर्दछ। तपाईं यसलाई आफ्नो ठूलो प्रोग्राम भित्रको मिनी-प्रोग्रामको रूपमा सोच्न सक्नुहुन्छ। फंक्शनहरू एउटा सानो कार्य गर्न लेखिएका हुन्छन्। तिनीहरूले संख्याहरू थप्न सक्छन्, कसैलाई नमस्कार गर्न सक्छन्, वा स्क्रिनमा तस्विरहरू पनि कोर्न सक्छन्। विचार भनेको फंक्शन भित्रको कार्यको विवरण लुकाउनु हो। यसरी, तपाईंले कार्य पूरा गर्न आवश्यक पर्दा मात्र फंक्शनलाई यसको नामले कल गर्न आवश्यक छ।
उदाहरणका लागि, एउटा साधारण प्रकार्य बत्तीको स्विच जस्तो देखिन सक्छ। जब तपाईंले स्विच पल्टाउनुहुन्छ, बत्ती बल्छ। त्यसैगरी, जब तपाईंले कुनै प्रकार्य कल गर्नुहुन्छ, कम्प्युटरले त्यस भित्रका कार्यहरू गर्दछ। यसले तपाईंको कामलाई सफा राख्छ र कुनै पनि समस्याहरू फेला पार्न र समाधान गर्न सजिलो बनाउँछ।
प्रोग्रामिङमा फंक्शनहरू प्रयोग गर्नुका धेरै राम्रा कारणहरू छन्। पहिलो, फंक्शनहरूले हामीलाई हाम्रो काम व्यवस्थित गर्न मद्दत गर्छन्। एउटै निर्देशनहरू धेरै पटक लेख्नुको सट्टा, हामी तिनीहरूलाई फंक्शनमा एक पटक लेख्छौं र त्यसपछि आवश्यक पर्दा फंक्शनलाई कल गर्छौं। यसले समय बचत गर्छ र गल्तीहरू रोक्छ। दोस्रो, फंक्शनहरूले हामीलाई कोड पुन: प्रयोग गर्न मद्दत गर्दछ। एक पटक फंक्शन परिभाषित भएपछि, यो हाम्रो प्रोग्रामको धेरै भागहरूमा प्रयोग गर्न सकिन्छ। तेस्रो, फंक्शनहरूले प्रोग्रामहरू पढ्न सजिलो बनाउँछ। जब कार्यलाई साना फंक्शनहरूमा विभाजन गरिन्छ, तपाईंले प्रोग्रामले के गर्छ भनेर बुझ्न फंक्शनहरूको नाम हेर्न सक्नुहुन्छ।
कल्पना गर्नुहोस् तपाईं एउटा ठूलो LEGO महल बनाउँदै हुनुहुन्छ। तपाईं सम्पूर्ण महल बनाउन साना ब्लकहरू प्रयोग गर्नुहुन्छ। प्रत्येक सानो ब्लक एउटा प्रकार्य जस्तै हो जसले एक विशेष काम गर्दछ। जब सबै ब्लकहरू एकसाथ राखिन्छन्, तपाईंसँग पूर्ण महल हुन्छ। त्यसैगरी, व्यक्तिगत प्रकार्यहरूले पूर्ण कार्यक्रम बनाउँछन्।
हामी एउटा विशेष कोड प्रयोग गरेर कुनै फंक्शन परिभाषित गर्न सक्छौं। धेरै प्रोग्रामिङ भाषाहरूमा, हामी एउटा किवर्ड प्रयोग गर्छौं जसले कम्प्युटरलाई हामीले फंक्शन बनाउँदैछौं भनेर बताउँछ। प्रोग्रामिङ सिकाउन प्रयोग गरिने एउटा लोकप्रिय भाषा पाइथन हो। पाइथनमा, हामी फंक्शन सुरु गर्न def शब्द प्रयोग गर्छौं। यहाँ एउटा साधारण उदाहरण छ:
उदाहरण:
डिफल्ट say_hello():
print("नमस्ते साथी!")
यस उदाहरणमा, फंक्शनलाई say_hello भनिन्छ। def शब्दले कम्प्युटरलाई बताउँछ कि हामी फंक्शन परिभाषित गर्दैछौं। फंक्शनले एउटा काम गर्छ: यसले स्क्रिनमा मैत्रीपूर्ण सन्देश छाप्छ।
एकचोटि हामीले यो प्रकार्य परिभाषित गरिसकेपछि, हामी यसलाई हाम्रो प्रोग्राममा पछि प्रयोग गर्न सक्छौं। यसलाई प्रकार्य कल गर्नु भनिन्छ। कम्प्युटरले प्रत्येक पटक कल गर्दा प्रकार्य भित्रका सबै चरणहरू कार्यान्वयन गर्नेछ।
अब, हामी फंक्शनका तीन सरल उदाहरणहरू हेर्नेछौं। तिनीहरू बुझ्न सजिलो छन् र हामीलाई आधारभूत विचारहरू सिक्न मद्दत गर्छन्।
पहिलो उदाहरणमा, हामी एउटा फंक्शन सिर्जना गर्छौं जसले कसैलाई नाम लिएर अभिवादन गर्छ। जब हामी फंक्शनलाई कल गर्छौं, यसले साथीलाई नमस्ते भन्नेछ।
कोड:
def अभिवादन (नाम):
print("नमस्ते, " + नाम + "!")
# "एलिस" नामको साथ प्रकार्य कल गर्दै
अभिवादन ("एलिस")
चरणबद्ध व्याख्या:
दोस्रो उदाहरणमा, हामी दुई संख्याहरू थप्ने प्रकार्य लेख्छौं। यो एउटा सानो क्याल्कुलेटर जस्तै हो जसले संख्याहरू सँगै जोड्छ।
कोड:
def थप_नम्बरहरू (संख्या १, संख्या २):
नतिजा = संख्या १ + संख्या २
print("योगफल यो हो:", परिणाम)
# ३ र ५ नम्बर भएको प्रकार्य कल गर्दै
संख्याहरू_थप्नुहोस्(३, ५)
चरणबद्ध व्याख्या:
तेस्रो उदाहरणमा, हामी एउटा फंक्शन सिर्जना गर्नेछौं जसले संख्यालाई २ ले गुणन गर्नेछ। यो फंक्शनले पछि प्रयोगको लागि फंक्शनले कसरी मान फिर्ता गर्न सक्छ भनेर देखाउँछ।
कोड:
def दुईद्वारा गुणन (x):
नयाँ_मान = x * २
नयाँ_मान फर्काउनुहोस्
# प्रकार्य कल गर्दै र परिणाम बचत गर्दै
नतिजा = दुईले_गुणा(४)
print("४ लाई २ ले गुणन गरियो", नतिजा)
चरणबद्ध व्याख्या:
प्रकार्यहरूले प्यारामिटरहरू मार्फत बाहिरबाट जानकारी स्वीकार गर्न सक्छन्। प्यारामिटर भनेको एउटा चर हो जसले प्रकार्य कल गर्दा डेटा राख्छ। हाम्रा उदाहरणहरूमा, name , num1 , num2 , र x प्यारामिटरहरू हुन्।
केही प्रकार्यहरूले मानहरू फर्काउँछन् । फिर्ता मान भनेको प्रकार्यले आफ्नो काम गरेपछि फिर्ता दिने परिणाम हो। उदाहरण ३ मा, multiply_by_two प्रकार्यले एउटा मान फर्काउँछ जुन त्यसपछि चरमा भण्डारण हुन्छ।
प्यारामिटरहरू र फिर्ता मानहरू प्रयोग गर्ने विचारले प्रकार्यहरूलाई लचिलो र शक्तिशाली बनाउँछ। तपाईं फरक आउटपुटहरू प्राप्त गर्न इनपुट परिवर्तन गर्न सक्नुहुन्छ, जस्तै रेसिपीमा सामग्रीहरू परिवर्तन गर्दा फरक स्वाद आउन सक्छ।
मोड्युलर प्रोग्रामिङमा फंक्शनहरू एक प्रमुख विचार हुन्। मोड्युलर प्रोग्रामिङ भनेको ठूलो प्रोग्रामलाई साना, व्यवस्थित भागहरू वा मोड्युलहरूमा विभाजन गर्नु हो। प्रत्येक फंक्शन एउटा मोड्युल जस्तै हो जसले एउटा साधारण कार्य गर्दछ। जब सबै मोड्युलहरू सँगै काम गर्छन्, तिनीहरूले पूर्ण प्रोग्राम बनाउँछन्।
एउटा पजल बनाउने बारेमा सोच्नुहोस्। प्रत्येक टुक्रा सानो र सरल छ। तर जब तपाईं सबै टुक्राहरू एकसाथ राख्नुहुन्छ, तपाईंले पूर्ण तस्वीर देख्नुहुन्छ। प्रोग्रामिङमा, फंक्शनहरू प्रयोग गर्नाले तपाईंलाई एक पटकमा एउटा सानो टुक्रामा काम गर्न दिन्छ। यस तरिकाले, प्रोग्रामहरू निर्माण गर्न, बुझ्न र समाधान गर्न सजिलो हुन्छ।
मोड्युलर प्रोग्रामिङले दोहोरिने काम कम गर्न मद्दत गर्छ। यदि तपाईंको प्रोग्रामको कुनै भागले बारम्बार एउटै काम गर्नु पर्छ भने, तपाईंले यसको लागि एउटा प्रकार्य लेख्नुहुन्छ। त्यसपछि हरेक पटक तपाईंलाई त्यो काम पूरा गर्न आवश्यक पर्दा, तपाईंले एउटै कोड लेख्नुको सट्टा फंक्शनलाई कल गर्नुहुन्छ।
यो दृष्टिकोण भनेको जुत्ताको फिता कसरी बाँध्ने भनेर जान्ने सहयोगी राख्नु जस्तै हो, त्यसैले तपाईंले हरेक पटक नयाँ जुत्ता लिँदा यो कसरी गर्ने भनेर पुन: सिक्नु पर्दैन।
आउनुहोस्, कार्यहरूलाई दैनिक क्रियाकलापहरूसँग तुलना गरौं। कल्पना गर्नुहोस् कि तपाईंको घरमा धेरै कामहरू छन्। तपाईंको एउटा काम भनेको बिरुवाहरूलाई पानी हाल्नु हो। हरेक पटक सबै चरणहरूको बारेमा सोच्नुको सट्टा, तपाईंले सम्झन सक्नुहुन्छ, "बिरुवाहरूलाई पानी हाल्नुहोस्।" प्रत्येक पटक जब तपाईं बिरुवाहरूमा काम गर्नुहुन्छ, तपाईं आफ्नै प्रकार्य प्रयोग गर्दै हुनुहुन्छ।
अर्को उदाहरण स्यान्डविच बनाउनु हो। पहिले, तपाईंले दुई स्लाइस ब्रेड लिनुहुन्छ। त्यसपछि, तपाईंले बटर, चीज, र सायद ह्यामको स्लाइस थप्नुहुन्छ। अन्तमा, तपाईंले दुई स्लाइसहरू सँगै राख्नुहुन्छ। प्रत्येक चरण स्पष्ट र सरल छ, प्रकार्यको रेखाहरू जस्तै। प्रत्येक पटक चरणहरू पालना गरेर, तपाईंले सुरुदेखि प्रत्येक चरणको बारेमा सोच्नु बिना नै स्वादिष्ट स्यान्डविच सिर्जना गर्नुहुन्छ।
यी दैनिक उदाहरणहरूले देखाउँछन् कि प्रकार्यहरूले हामीलाई धेरै कार्यहरूलाई स्पष्ट, सरल भागहरूमा विभाजन गरेर गर्न मद्दत गर्छन्।
जब तपाईंले फंक्शनहरूको बारेमा सिक्न थाल्नुहुन्छ, तपाईंले याद गर्नुहुनेछ कि प्रत्येक फंक्शनको नाम , कोष्ठक भित्र प्यारामिटरहरूको सूची र भित्र कोडको ब्लक हुन्छ। यो साधारण ढाँचामा यस्तो देखिन सक्छ:
सामान्य संरचना:
def function_name(प्यारामिटर१, प्यारामिटर२, ...):
# कोड ब्लक
आवश्यक परेमा some_value # फिर्ता गर्नुहोस्
यहाँ, function_name भनेको function को नाम हो। प्यारामिटरहरू function ले प्रयोग गर्ने इनपुटहरू हुन्। कोड ब्लक भनेको function ले कार्यान्वयन गर्ने निर्देशनहरूको सेट हो। अन्तमा, return ले परिणाम फिर्ता दिन्छ।
तपाईंले कहिलेकाहीं त्यस्ता प्रकार्यहरू देख्न सक्नुहुन्छ जसमा कुनै पनि प्यारामिटरहरू हुँदैनन्। जब कुनै प्रकार्यलाई कुनै अतिरिक्त जानकारी आवश्यक पर्दैन, तपाईंले अझै पनि कोष्ठकहरू लेख्नुहुन्छ, तर तिनीहरू खाली रहन्छन्। त्यसैगरी, धेरै प्रकार्यहरूले सन्देशहरू छाप्ने जस्ता कार्यहरू गर्छन् र कुनै मान फिर्ता गर्दैनन्।
यहाँ तपाईंले सम्झनु पर्ने कार्यहरूका केही महत्त्वपूर्ण गुणहरू छन्:
यी गुणहरू पालना गरेर, प्रोग्रामरहरूले समयसँगै बुझ्न, डिबग गर्न र सुधार गर्न सजिलो हुने कार्यक्रमहरू सिर्जना गर्न सक्छन्। आफ्ना खेलौनाहरूलाई बक्सहरूमा क्रमबद्ध गरेर आफ्नो कोठालाई सफा राख्नु जस्तै, प्रकार्यहरूले कार्यक्रमहरूलाई सफा र व्यवस्थित राख्छन्।
जब तपाईं फंक्शनहरूको विचारसँग सहज हुँदै जानुहुन्छ, तपाईंले केही भिन्नताहरू सामना गर्न सक्नुहुन्छ। कहिलेकाहीँ फंक्शनहरूले केही पनि फिर्ता गर्दैनन्; तिनीहरूले केवल कार्यहरू गर्छन्। अन्य समयमा, फंक्शनहरूले अन्य फंक्शनहरूलाई कल गर्न सक्छन्। यसलाई नेस्टिङ फंक्शनहरू वा फंक्शन संरचना भनिन्छ।
उदाहरणका लागि, कुनै फंक्शनले अर्को कार्य सुरु गर्नु अघि ग्रीटिंग फंक्शनलाई कल गर्न सक्छ। फंक्शनहरूको यो तहले तपाईंलाई धेरै साना, साधारण कार्यहरूबाट जटिल प्रोग्रामहरू निर्माण गर्न दिन्छ।
पछिको चरणमा, तपाईंले रिकर्सिभ फंक्शनहरू जस्ता विषयहरू अन्वेषण गर्न सक्नुहुन्छ। रिकर्सिभ फंक्शन भनेको आफैंलाई बोलाउने फंक्शन हो। यो विचार अलि गाह्रो सुनिए पनि, यो समस्याहरूलाई साना भागहरूमा विभाजन गर्ने अर्को तरिका हो। अहिलेको लागि, यो जान्न पर्याप्त छ कि फंक्शनहरूले तपाईंलाई स्मार्ट र व्यवस्थित कोड लेख्न मद्दत गर्दछ।
कार्यहरूले चरणबद्ध रूपमा कसरी काम गर्छन् भनेर देखाउने थप दुई विस्तृत उदाहरणहरू हेरौं।
उदाहरण ४: सम संख्याहरू जाँच गर्ने कार्य
def समान छ(संख्या):
# संख्या बराबर छ कि छैन जाँच गर्नुहोस्
यदि संख्या % २ == ०:
सत्य फर्काउनुहोस्
अन्यथा:
गलत फर्काउनुहोस्
# नम्बर ६ जाँच गर्न प्रकार्य प्रयोग गर्दै
नतिजा = समान छ(६)
print("के ६ बराबर छ?", नतिजा)
चरणबद्ध व्याख्या:
उदाहरण ५: वर्गको क्षेत्रफल गणना गर्ने कार्य
वर्गको_क्षेत्रफल(छेउको_लम्बाइ):
# सूत्र प्रयोग गरेर क्षेत्रफल गणना गर्नुहोस्: क्षेत्रफल = साइड_लम्बाइ * साइड_लम्बाइ
क्षेत्रफल = साइड_लम्बाइ * साइड_लम्बाइ
फिर्ता क्षेत्र
# ५ को भुजा लम्बाइ भएको वर्गको क्षेत्रफल गणना गर्न प्रकार्य प्रयोग गर्दै
वर्ग_क्षेत्रफल = वर्गको_क्षेत्रफल(५)
print("वर्गको क्षेत्रफल हो", वर्ग_क्षेत्रफल)
चरणबद्ध व्याख्या:
उदाहरण ६: दुई संख्याहरू मध्ये ठूलो निर्धारण गर्ने कार्य
def ठूलो_संख्या(a, b):
# दुई संख्याहरू तुलना गर्नुहोस् र ठूलो संख्या फर्काउनुहोस्।
यदि a > b:
फिर्ता गर्नुहोस्
अन्यथा:
फिर्ता ख
# ७ र १० बीचको ठूलो संख्या पत्ता लगाउन प्रकार्य प्रयोग गर्दै
सबैभन्दा ठूलो = ठूलो_संख्या(७, १०)
print("ठूलो संख्या हो", सबैभन्दा ठूलो)
चरणबद्ध व्याख्या:
फंक्शनहरू एक शक्तिशाली उपकरण हो जसले हामीलाई मोड्युलर तरिकाले प्रोग्रामहरू निर्माण गर्न मद्दत गर्दछ। फंक्शनहरू प्रयोग गरेर, तपाईं आफ्नो प्रोग्रामको छुट्टाछुट्टै भागहरू सिर्जना गर्न सक्नुहुन्छ जुन स्वतन्त्र रूपमा काम गर्दछ। यसको मतलब यो हो कि यदि तपाईंको प्रोग्रामको एक भागमा गल्ती छ वा सुधार आवश्यक छ भने, तपाईंले कोडको ठूलो समूह हेर्नुको सट्टा त्यो एउटा प्रकार्य मात्र समाधान गर्न आवश्यक छ।
मोड्युलर प्रोग्रामिङ भनेको LEGO ब्लकहरू प्रयोग गरेर निर्माण गर्नु जस्तै हो। प्रत्येक ब्लक स्वतन्त्र हुन्छ र विभिन्न संरचनाहरू सिर्जना गर्न विभिन्न तरिकाले जडान गर्न सकिन्छ। यदि एउटा ब्लक भाँचियो भने, तपाईंले सम्पूर्ण महल पुनर्निर्माण नगरीकन यसलाई प्रतिस्थापन गर्न सक्नुहुन्छ। प्रकार्यहरूको साथ, तपाईंको कार्यक्रमको प्रत्येक सानो खण्ड आफैंमा निर्माण, परीक्षण र फिक्स गर्न सकिन्छ।
प्रोग्रामिङको यो तरिकाले तपाईंलाई समस्याहरू राम्रोसँग बुझ्न मद्दत गर्छ र जटिल कार्यहरूलाई सजिलो बनाउँछ। यसले तपाईंलाई समस्याहरूको बारेमा तार्किक रूपमा कसरी सोच्ने र तिनीहरूलाई चरणबद्ध रूपमा कसरी समाधान गर्ने भनेर पनि सिकाउँछ।
निष्कर्षमा, फंक्शनहरू प्रोग्रामिङको एक आवश्यक भाग हुन्। तिनीहरूले हामीलाई सफा, स्पष्ट, र बुझ्न सजिलो कोड लेख्न अनुमति दिन्छन्। फंक्शनहरू प्रयोग गरेर, हामी ठूला समस्याहरूलाई साना, व्यवस्थित कार्यहरूमा विभाजन गरेर समाधान गर्न सक्छौं। चाहे यो साथीलाई अभिवादन गर्ने होस्, गणना गर्ने होस्, वा संख्या बराबर छ कि छैन भनेर जाँच गर्ने होस्, फंक्शनहरूले हाम्रा कार्यक्रमहरूलाई सरल र रमाइलो बनाउन मद्दत गर्छन्।
सधैं सम्झनुहोस्: हरेक ठूलो कार्यलाई साना चरणहरू प्रयोग गरेर सजिलो बनाउन सकिन्छ, र ती साना चरणहरू तपाईंको कार्यक्रममा कार्यहरू हुन्।
प्रोग्रामिङ सिक्दै, अन्वेषण गर्दै र रमाइलो गर्दै जानुहोस्। फंक्शनहरू रचनात्मक र उपयोगी कोड लेख्ने पहिलो चरण हो!