कार्य
आतापर्यंत, आम्ही आमचे सर्व कोड app.py मध्ये लिहित आहोत, परंतु जसजसे आमचे प्रोग्राम्स वाढत जातात, तसतसे आम्हाला आमचा कोड व्यवस्थापित करण्यासाठी अधिक चांगल्या पद्धतीची आवश्यकता असते. आम्हाला आमच्या कोडचे लहान, अधिक आटोपशीर आणि अधिक देखरेख करण्यायोग्य भागांमध्ये विभाजन करणे आवश्यक आहे ज्याला आम्ही फंक्शन्स म्हणतो. फंक्शन कोडच्या काही ओळींसाठी एक कंटेनर आहे जे विशिष्ट कार्य करतात.
उदाहरणार्थ, तुम्ही पायथनमधील काही अंगभूत फंक्शन्सबद्दल आधीच शिकलात print()
आणि input()
. प्रत्येक कार्याचा एक उद्देश असतो आणि विशिष्ट कार्य कसे करावे हे माहित असते. म्हणून, जेव्हा आपण मोठे कॉम्प्लेक्स प्रोग्रॅम बनवतो, तेव्हा आपण आपला कोड पुन्हा वापरता येण्याजोग्या छोट्या भागांमध्ये, म्हणजे फंक्शन्समध्ये मोडला पाहिजे.
शुभेच्छा संदेश छापण्यासाठी प्रोग्राम तयार करून ही संकल्पना समजून घेऊ.
print('Hi there!')
print('Welcome aboard!')
येथे आपल्याकडे कोडच्या फक्त दोन ओळींचा एक साधा प्रोग्राम आहे. आता, आपण असे म्हणू या की, आपण ते पुन्हा वापरू शकतो अशा फंक्शनमध्ये ठेवण्यासाठी आपल्याला इतर प्रोग्राममध्ये त्यांची आवश्यकता असेल.
मी एक राखीव कीवर्ड सादर करतो def
Python मध्ये, जे परिभाषित करण्यासाठी लहान आहे आणि फंक्शन परिभाषित करण्यासाठी वापरले जाते.
def greet_user():
print('Hi there!')
print('Welcome aboard!')
आता कोडचा हा ब्लॉक फंक्शन परिभाषित करेल "greet_user
"त्यानंतर कोडच्या ओळींसह. जेव्हा जेव्हा हे फंक्शन कॉल केले जाते तेव्हा या दोन ओळी कार्यान्वित केल्या जातील. चला हे वापरूया:
print('start')
greet_user()
print('finish')
प्रोग्राम क्रमाक्रमाने कार्यान्वित केला जातो, म्हणजे प्रोग्राममध्ये कॉल करण्यापूर्वी तुम्हाला फंक्शन परिभाषित करावे लागेल.
घटके
परिभाषित फंक्शन्स पायथनच्या अंगभूत फंक्शन्सपेक्षा थोडी वेगळी कार्य करतात. उदाहरणार्थ, च्या बाबतीत print()
फंक्शन, आम्हाला काही माहिती लागते जी आम्हाला प्रिंट करायची आहे, परंतु आमचे ग्रीट फंक्शन कोणतीही माहिती घेत नाही. जर तुम्ही वापरकर्त्याचे नाव येथे पास केले आणि नंतर "हाय तेथे" म्हणण्याऐवजी, वापरकर्त्याचे नाव छापता आले तर ते चांगले होईल का?
परिभाषित फंक्शनच्या कंसात पॅरामीटर्स जोडून तुम्ही हे करू शकता. मी तुम्हाला दाखवतो:
def greet_user(name):
print('Hi there!')
print('Welcome aboard!')
आता "name
” कंसाच्या आत स्थानिक व्हेरिएबल प्रमाणे काम करेल आणि आम्ही त्याला कॉल करताना वापरकर्त्याचे नाव पास करू शकतो.
greet_user('Shahbaz')
आता नाव पॅरामीटर सेट केले आहे “Shahbaz
" त्याचा वापर करण्यासाठी प्रोग्राममध्ये बदल करूया.
def greet_user(name):
print(f'Hi {name}')
print('Welcome aboard!')
print('start')
greet_user('Shahbaz')
print('finish')
एक महत्त्वाची गोष्ट लक्षात घेण्यासारखी आहे की पहिल्या ओळीतील “नाव” ला पॅरामीटर म्हणतात तर पुरवलेल्या नावाला म्हणजेच शाहबाजला युक्तिवाद म्हणतात.
चला पुढे जाऊन हा कार्यक्रम राबवूया.
तर या पॅरामीटर्ससह, आम्ही आमच्या कार्यांमध्ये माहिती प्राप्त करू शकतो.
आता, काहीतरी मनोरंजक करूया. समजा तुम्हाला शुभेच्छा संदेशात दुसरे नाव जोडायचे आहे. हे सोपं आहे.
def greet_user(name):
print(f'Hi {name}')
print('Welcome aboard!')
print('start')
greet_user('Shahbaz')
greet_user('Aayush')
print('finish')
आता लक्षात घ्या की जेव्हा फंक्शनमध्ये पॅरामीटर असते, तेव्हा त्या पॅरामीटरसाठी मूल्य पास करण्यास आम्ही बांधील असतो. तुम्ही फंक्शनमधून नाव काढून प्रोग्राम रन केल्यास, आम्हाला एरर मिळेल. तुम्ही स्वल्पविरामाने विभक्त केलेल्या एकाच फंक्शनमध्ये अनेक पॅरामीटर्स देखील वापरू शकता.
उदाहरणार्थ, greet_user(first_name, last_name):
. युक्तिवाद देखील त्याच प्रकारे स्वरूपित केले जातील.
कीवर्ड आर्ग्युमेंट्स
आतापर्यंत, आम्ही शिकलो आहोत की जेव्हाही आम्ही आमच्या फंक्शन्ससाठी पॅरामीटर्स परिभाषित करतो तेव्हा आम्ही नेहमी मूल्ये पुरवली पाहिजे अन्यथा आम्हाला एक त्रुटी येईल. शेवटच्या कार्यक्रमात वाद झाले 'Shahbaz'
आणि 'Bhatti'
पोझिशनल आर्ग्युमेंट्स म्हणतात, म्हणजे प्रोग्राममधील त्यांची स्थिती किंवा क्रम महत्त्वाचा.
पायथनमध्ये, आपल्याकडे कीवर्ड आर्ग्युमेंट्स नावाचा आणखी एक प्रकारचा युक्तिवाद आहे, ज्यासाठी स्थान काही फरक पडत नाही. ते कसे कार्य करतात ते मी तुम्हाला दाखवतो.
शेवटचा कार्यक्रम बघा. आम्ही ते याप्रमाणे सुधारू शकतो:
def greet_user(first_name, last_name):
print(f'Hi {first_name} {last_name}')
print('Welcome aboard!')
print('start')
greet_user(first_name='Shahbaz', last_name='Bhatti')
print('finish')
आता first_name
आणि last_name
कीवर्ड पॅरामीटर्स आहेत. आपण त्यांची ठिकाणे बदलू शकता आणि परिणाम समान असेल.
आता याचा अर्थ असा नाही की आपण नेहमी कीवर्ड वितर्क वापरावे. बर्याच वेळा आम्ही स्थितीत्मक युक्तिवाद वापरतो, परंतु काही विशिष्ट परिस्थितींमध्ये, हे कीवर्ड युक्तिवाद आम्हाला आमच्या कोडची वाचनीयता सुधारण्यात मदत करतात.
कीवर्ड वितर्कांबद्दल आपल्याला आणखी एक गोष्ट माहित असणे आवश्यक आहे. कीवर्ड आर्ग्युमेंट नेहमी पोझिशनल आर्ग्युमेंट्स नंतर आले पाहिजेत.
रिटर्न स्टेटमेंट
आतापर्यंत आपण फंक्शन्स कशी तयार करायची आणि त्यांचे पॅरामीटर्स वापरून माहिती कशी पाठवायची हे शिकलो. आता व्हॅल्यू रिटर्न करणारी फंक्शन्स कशी तयार करायची ते पाहू. हे विशेषतः उपयुक्त आहे जर तुम्ही काही प्रकारचे आकडेमोड करत असाल आणि तुम्हाला तुमचा फंक्शन वापरणाऱ्याला निकाल परत करायचा असेल. मी तुला दाखवतो.
चला एक फंक्शन परिभाषित करू जे एका संख्येच्या वर्गाची गणना करेल.
def square(number):
return number*number
फंक्शनच्या बाहेर हा नंबर परत करण्यासाठी आम्ही रिटर्न स्टेटमेंट वापरले आहे. आता, जर आपण या फंक्शनला कॉल केला, तर ते जसे की व्हॅल्यू मिळवते input()
कार्य टर्मिनलवर प्रिंट करू.
तुम्ही असा युक्तिवाद करू शकता की रिटर्न स्टेटमेंट न वापरता समान परिणाम मिळू शकतो. चला ते तपासूया.
आपण दोन गोष्टी पाहतो, संख्या 9, आणि काहीही नाही. इथे काय चाललंय?
जेव्हा पायथन इंटरप्रिटर हा कोड कार्यान्वित करतो, तेव्हा प्रथम ते स्क्वेअर फंक्शनला कॉल करेल आणि नियंत्रण फंक्शनमध्ये हलवेल. येथे आपण दिलेल्या संख्येचा वर्ग काढतो आणि नंतर टर्मिनलवर प्रिंट करतो.
आता, डीफॉल्टनुसार, सर्व फंक्शन्स कोणतेही मूल्य परत करत नाहीत. त्यामुळे आमच्याकडे येथे रिटर्न स्टेटमेंट नसल्यास, बाय डीफॉल्ट पायथन काहीही रिटर्न करत नाही. मूल्याच्या अनुपस्थितीचे प्रतिनिधित्व करणारी कोणतीही वस्तू नाही. हे C, C++, Java आणि Javascript मध्ये काहीही किंवा शून्य सारखे आहे.
गुंडाळणे!
मला आशा आहे की तुम्हाला फंक्शन्सचे महत्त्व समजले असेल.
जर तुम्ही तुमच्या कोडिंग करिअरमध्ये मोठे आणि क्लिष्ट प्रोग्राम लिहिण्याची योजना आखत असाल तर ते पायथन लर्निंगचे महत्त्वपूर्ण पैलू आहेत.
प्रत्युत्तर द्या