फंक्शनमधून मूल्ये परत करा. रिटर्न ऑपरेटर. इंटरएक्टिव्ह पायथन ट्यूटोरियल

फंक्शन्स त्यांच्या शरीरातील कोणताही डेटा प्रोग्रामच्या मुख्य शाखेत हस्तांतरित करू शकतात. फंक्शन असे म्हटले जाते की ते मूल्य परत करते. पायथनसह बऱ्याच प्रोग्रामिंग भाषांमध्ये, फंक्शनमधून बाहेर पडणे आणि डेटा जिथे कॉल केला गेला आहे तिथे पाठवणे रिटर्न स्टेटमेंटसह केले जाते.

जर पायथन इंटरप्रिटर, फंक्शनचा मुख्य भाग कार्यान्वित करताना, परत येतो, तर तो या कमांडनंतर निर्दिष्ट केलेले मूल्य "घेतो" आणि फंक्शनमधून "बाहेर पडतो".

def सिलेंडर(): r = float(input()) h = float(input()) # सिलेंडर बाजूच्या पृष्ठभागाचे क्षेत्रफळ:बाजू = 2 * 3.14 * r * h एका सिलेंडर बेसचे # क्षेत्र:वर्तुळ = 3.14 * r**2 # सिलेंडरचे एकूण क्षेत्रफळ:पूर्ण = बाजू + 2 * वर्तुळ परतावा पूर्ण चौरस = सिलेंडर () प्रिंट (चौरस)

अंमलबजावणीचे उदाहरण:

3 7 188.4

या प्रोग्राममध्ये, लोकल व्हेरिएबल फुल ची व्हॅल्यू फंक्शनमधून मुख्य शाखेत परत केली जाते. व्हेरिएबल स्वतःच नाही, परंतु त्याचे मूल्य, या प्रकरणात सिलिंडरच्या क्षेत्राची गणना करून काही संख्या प्राप्त होते.

प्रोग्रामच्या मुख्य शाखेत, हे मूल्य ग्लोबल व्हेरिएबल स्क्वेअरला नियुक्त केले आहे. म्हणजेच, अभिव्यक्ती वर्ग = सिलिंडर() असे कार्यान्वित केले आहे:

सिलेंडर() फंक्शन म्हणतात.

त्यातून मूल्य परत केले जाते.

हे मूल्य स्क्वेअर व्हेरिएबलला नियुक्त केले आहे.

व्हेरिएबलला निकाल देणे आवश्यक नाही; ते स्क्रीनवर त्वरित प्रदर्शित केले जाऊ शकते:

प्रिंट(सिलेंडर())

येथे cylinder() मधून मिळवलेली संख्या थेट print() फंक्शनला दिली जाते. प्राप्त डेटा व्हेरिएबलला न देता किंवा पुढे कुठेतरी पास न करता प्रोग्राममध्ये cylinder() लिहिल्यास हा डेटा नष्ट होईल. पण वाक्यरचना त्रुटी असणार नाही.

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

def cylinder() : प्रयत्न करा : r = फ्लोट (इनपुट () ) h = फ्लोट (इनपुट () ) ValueError वगळता : रिटर्न साइड = 2 * 3.14 * r * h वर्तुळ = 3.14 * r**2 पूर्ण = बाजू + 2 * सर्कल रिटर्न पूर्ण प्रिंट (सिलेंडर() )

तुम्ही अंकांऐवजी अक्षरे टाकण्याचा प्रयत्न केल्यास, त्याशिवाय नेस्टेड इन केलेले रिटर्न काम करेल. हे फंक्शन संपुष्टात आणेल, त्यामुळे पूर्ण परताव्यासह त्यानंतरची सर्व गणना वगळली जाईल. अंमलबजावणीचे उदाहरण:

पण थांब! "रिक्त" आम्हाला परत आले की नाही हा शब्द काय आहे? हे काहीही नाही, अशी वस्तू "काहीही नाही" आहे. तो NoneType वर्गाचा आहे. याआधी, आम्हाला चार डेटा प्रकार माहित होते, ज्यांना चार वर्ग देखील म्हणतात: int, float, str, bool. पाचवीची वेळ झाली.

जेव्हा रिटर्न नंतर काहीही निर्दिष्ट केले जात नाही, तेव्हा डीफॉल्ट असे आहे की तेथे काहीही नाही. पण रिटर्न नोन लिहिण्यापासून तुम्हाला कोणीही रोखत नाही.

शिवाय. पूर्वी, आम्ही अशी फंक्शन्स पाहिली ज्यांना रिटर्न स्टेटमेंट नसल्यामुळे कोणतेही मूल्य मिळत नाही. खरं तर, ते परत केले गेले, आम्ही फक्त त्याकडे लक्ष दिले नाही, ते कोणत्याही व्हेरिएबलला नियुक्त केले नाही आणि ते स्क्रीनवर प्रदर्शित केले नाही. Python मध्ये, प्रत्येक फंक्शन काहीतरी परत करतो. जर त्यात रिटर्न स्टेटमेंट नसेल, तर ते काहीही रिटर्न करत नाही. जसे की त्यात "रिक्त" परतावा आहे.

एकाधिक मूल्ये परत करत आहे

Python मध्ये, तुम्ही रिटर्न कमांडनंतर स्वल्पविरामाने विभक्त केलेल्या फंक्शनमधून अनेक ऑब्जेक्ट्सची सूची करून परत करू शकता:

def सिलेंडर() : r = फ्लोट (इनपुट () ) h = फ्लोट (इनपुट () ) बाजू = 2 * 3.14 * r * h वर्तुळ = 3.14 * r**2 पूर्ण = बाजू + 2 * वर्तुळ परतीची बाजू, पूर्ण sCyl , fCyl = सिलेंडर () प्रिंट ( "बाजूच्या पृष्ठभागाचे क्षेत्रफळ %.2f"% sCyl) प्रिंट ( "एकूण क्षेत्रफळ %.2f"% fCyl)

सिलिंडर() फंक्शन दोन व्हॅल्यू मिळवते. त्यापैकी पहिले व्हेरिएबल sCyl ला नियुक्त केले आहे, दुसरे - fCyl. ही गट असाइनमेंट क्षमता एक पायथन वैशिष्ट्य आहे जी सामान्यत: इतर भाषांमध्ये आढळत नाही:

>>> a, b, c = 10, 15, 19 >>>अ 10 >>>ब 15 >>> ग 19

येथे युक्ती अशी आहे की स्वल्पविरामाने विभक्त केलेल्या मूल्यांची सूची (उदाहरणार्थ, 10, 15, 19) टपल प्रकारची एक वस्तू तयार करते. "ट्यूपल" म्हणून रशियनमध्ये अनुवादित. हा डेटा स्ट्रक्चरचा प्रकार आहे ज्याचा नंतर शोध घेतला जाईल.

जेव्हा ट्यूपल एकाच वेळी अनेक व्हेरिएबल्सना नियुक्त केले जाते, तेव्हा त्याच्या घटकांची तुलना रांगेतील संबंधित व्हेरिएबल्सशी केली जाते. याला अनपॅकिंग म्हणतात.

अशाप्रकारे, जेव्हा फंक्शन अनेक व्हॅल्यूज रिटर्न करते, तेव्हा ते प्रत्यक्षात एकच टपल ऑब्जेक्ट रिटर्न करते. ही एकाधिक मूल्ये परत येण्यापूर्वी ट्यूपलमध्ये पॅक केली जातात. जर रिटर्न स्टेटमेंट नंतर फक्त एक व्हेरिएबल किंवा ऑब्जेक्ट असेल, तर त्याचा प्रकार जसा आहे तसा जतन केला जातो.

अनपॅक करणे पर्यायी आहे. हे असे कार्य करेल:

...प्रिंट(सिलेंडर())

अंमलबजावणीचे उदाहरण:

4 3 (75.36 , 175.84 )

कंस द्वारे दर्शविल्याप्रमाणे स्क्रीनवर टपल प्रदर्शित केले जाते. हे एका व्हेरिएबलला देखील नियुक्त केले जाऊ शकते आणि नंतर स्क्रीनवर त्याचे मूल्य प्रदर्शित करा.

Python मध्ये फंक्शन पॅरामीटर्स (वितर्क) वापरण्याबद्दल एक स्मरणपत्र.

पोझिशनल पॅरामीटर्स

टिपा:

• सर्व काही नेहमीप्रमाणे आहे.
• कॉल करताना, सर्व स्थितीसंबंधी युक्तिवाद निर्दिष्ट करण्याचे सुनिश्चित करा.

वितर्कांची अनियंत्रित संख्या

टिपा:

• युक्तिवादाच्या आधी तारकाद्वारे सूचित केले - *args
• फंक्शनचा आतील भाग ट्यूपलसारखा दिसतो, ट्युपलचे घटक कॉल केल्यावर फंक्शन आर्ग्युमेंट्स निर्दिष्ट केलेल्या क्रमाने मांडलेले असतात.
• फंक्शनला कॉल करताना समोरील सूचीच्या पदनामात तारांकन जोडून तुम्ही वितर्कांचा संच म्हणून सूची पास करू शकता.

उदाहरण 1. वितर्कांच्या व्हेरिएबल संख्येसह फंक्शन परिभाषित करणे:

उदाहरण 2. वितर्कांचा संच म्हणून फंक्शनला सूची पास करणे:

टिप्पण्या उदाहरणार्थ 2:

• ओळ 8: वितर्कांची चल संख्या
• ओळ 9: यादी (एक युक्तिवाद म्हणून पास)
• ओळ 10: तारकासह सूची (वितर्कांची चल संख्या म्हणून पास)

नामांकित युक्तिवाद

टिपा:

• कॉल करताना निर्दिष्ट करणे आवश्यक नाही. निर्दिष्ट न केल्यास, त्यांना डीफॉल्ट मूल्ये नियुक्त केली जातात.

टिपा:

• जेव्हा प्रोग्राम चालतो, तेव्हा फंक्शन परिभाषित केलेल्या ठिकाणी, नामांकित पॅरामीटर्सना मूल्ये नियुक्त केली जातात. जर असाइन केलेला ऑब्जेक्ट म्यूटेबल असेल, तर फंक्शनच्या ऑपरेशन दरम्यान बदलला गेला असेल, त्यानंतरच्या कॉलमध्ये फंक्शन डेफिनिशनमधील मूल्य म्हणून निर्दिष्ट केलेले मूल्य नसेल, परंतु मागील कॉल दरम्यान नियुक्त केलेले मूल्य असेल.

लक्षात घेण्यासारखे उदाहरण:

नामांकित युक्तिवादांची अनियंत्रित संख्या

टिपा:

• युक्तिवादाच्या आधी दोन तारकांनी दर्शविले - **kwargs
• फंक्शनच्या आत, फंक्शनला कॉल करताना निर्दिष्ट केलेल्या वितर्कांच्या नावांशी संबंधित कीजसह ते शब्दकोशासारखे दिसते.
• फंक्शन कॉल करताना तुम्ही डिक्शनरी पदनामाच्या आधी दोन तारांकित जोडून नामांकित वितर्कांचा संच म्हणून डिक्शनरी पास करू शकता. उदाहरणार्थ यासारखे: **kwargs

उदाहरण 1. नामांकित वितर्कांच्या अनियंत्रित संख्येसह फंक्शन परिभाषित करणे:

उदाहरण 2. नामांकित वितर्कांची अनियंत्रित संख्या म्हणून फंक्शनला डिक्शनरी पास करणे:

टिप्पण्या उदाहरणार्थ 2:

• ओळ 9: शब्दकोष एकच नावाचा युक्तिवाद म्हणून पास केला जातो.
• ओळ 10: शब्दकोष नामांकित वितर्कांची अनियंत्रित संख्या म्हणून पास केला जातो.

सर्व प्रकारचे पॅरामीटर्स एकत्र

संदर्भानुसार पॅरामीटर पास करणे (फंक्शनमध्ये पॅरामीटर बदलणे)

जर, फंक्शन कॉल करताना, आपण वितर्काच्या मूल्याप्रमाणे व्हेरिएबल बदलतो आणि फंक्शनच्या मुख्य भागामध्ये आपण आर्ग्युमेंटचे मूल्य बदलतो, तर काय होते ते आपले व्हेरिएबल कोणत्या मूल्याशी संबंधित आहे यावर अवलंबून असते. जर व्हेरिएबल अपरिवर्तनीय मूल्याशी संबंधित असेल, उदाहरणार्थ int, str, तुळपे, तर नैसर्गिकरित्या हे मूल्य बदलणार नाही. परंतु जर व्हेरिएबल सूची, शब्दकोश किंवा वर्गाशी संबंधित असेल तर व्हेरिएबलशी संबंधित ऑब्जेक्टचे मूल्य बदलेल.

बदलत नाही:

बदल:

परिणाम 1: जर आम्हाला "संदर्भानुसार पॅरामीटर पास करणे" आवश्यक असेल, तर आपण हे करू नये; C मध्ये संदर्भानुसार पॅरामीटर पास करण्याचा उद्देश फंक्शनमधील संदर्भानुसार मूल्ये बदलून फंक्शनमधून एकाधिक मूल्ये परत करणे आहे. पायथन तुम्हाला ट्यूपल परत करण्याची परवानगी देतो, म्हणून तुम्हाला एकाधिक मूल्ये परत करायची असल्यास, तुम्हाला ट्यूपल परत करणे आणि व्हेरिएबल्सला त्याची मूल्ये नियुक्त करणे आवश्यक आहे.

परिणाम 2: "साइड इफेक्ट्स" टाळण्यासाठी, डिफॉल्ट मूल्ये म्हणून अपरिवर्तनीय प्रकार वापरणे चांगले आहे (कोणतेही, int, str, तुळपे)

टिप्पण्या:

धन्यवाद, ते उपयुक्त होते

a(**d) साठी विशेष धन्यवाद.

स्पष्ट स्पष्टीकरणांबद्दल धन्यवाद!

def fprintf(*args,**kwargs):
क्वार्ग प्रिंट करा...
args प्रिंट करा...

KP = 2
N_elem =
c="privet"

KP = 2
N_elem =
c = "हॅलो"

fprintf(KP, N_elem, c)

परिणाम:
KP = 2
N_elem =
c = privet

>> फंक्शन कसे लिहायचे जेणेकरुन ते त्याच्या व्हेरिएबल्सची नावे आणि मूल्ये मुद्रित करेल??

def fprintf(**kwargs):
kwargs.items( मध्ये k, v साठी):
"%s = %s" % (k, v) प्रिंट करा

आणि विकृतपणे कॉल करा:
fprintf(KP=KP, N_elem=N_elem, c=c)

ही खेदाची गोष्ट आहे की सीपीपीमध्ये इतक्या मोठ्या संख्येने उदाहरणे वापरली जाऊ शकत नाहीत, कारण मला फायटोन्की माहित नाही. परंतु विषय मनोरंजक आहे आणि मला ते प्रत्यक्ष व्यवहारात कसे लागू करायचे हे जाणून घ्यायचे आहे, फक्त 1,2,3 नाही. उदाहरणार्थ, atmega8 On srr मध्ये कल्पना भाषांतरित करण्याचे कार्य असल्यास [हा ॲरे इंडेक्स आहे] = (हॅलो वर्ल्ड) =)
अनुक्रमणिका++ आणि प्रत्येक चक्र अक्षरानुसार आउटपुट करा.

जेव्हा प्रोग्राम चालतो, तेव्हा फंक्शन परिभाषित केलेल्या ठिकाणी, नामांकित पॅरामीटर्सना मूल्ये नियुक्त केली जातात. जर असाइन केलेला ऑब्जेक्ट म्यूटेबल असेल, तर फंक्शनच्या ऑपरेशन दरम्यान बदलला गेला असेल, त्यानंतरच्या कॉलमध्ये फंक्शन डेफिनिशनमधील मूल्य म्हणून निर्दिष्ट केलेले मूल्य नसेल, परंतु मागील कॉल दरम्यान नियुक्त केलेले मूल्य असेल.

तुम्ही जे नमूद केले आहे ते फक्त याद्यांना लागू होते.
कारण पॅरामीटरला सूची नियुक्त केल्याने, पॅरामीटर आणि सूची दोन्ही एकाच सेलमध्ये तयार होतात आणि त्यांचा आयडी समान असतो. जेव्हा तुम्ही पॅरामीटर बदलता, तेव्हा सूची बदलते आणि सर्व काही त्याच सेलमध्ये सेव्ह होते.

सर्वसाधारणपणे, असे काहीतरी!

def सम(x):
जर x%2==0:
प्रिंट ("होय")
____?
प्रिंट ("नाही")

उपांत्य काय घालावे

def सम(x):
जर x%2==0:
प्रिंट ("होय")
____?
प्रिंट ("नाही")

उपांत्य ओळीत काय ठेवायचे???

अस्या, मूर्ख!

जेव्हा मी OOP बद्दल धडा लिहायला सुरुवात केली तेव्हा मला जाणवले की मी Python चा एवढा मोठा आणि आवश्यक विभाग फंक्शन्स म्हणून कव्हर करायला विसरलो होतो. हा विषय मोठा आणि विस्तृत आहे, म्हणून धड्यांमधील विराम जास्त वाढू नये म्हणून, मी ते 2 भागांमध्ये विभागण्याचे ठरविले. प्रथम, मी तुम्हाला मूलभूत गोष्टी सांगेन, नंतर पायथनच्या कार्य अभियांत्रिकीची सखोल वैशिष्ट्ये सांगेन.

पायथनमधील फंक्शन्स सोप्या नव्हे तर अगदी सोप्या पद्धतीने घोषित केले जातात. येथे सर्वात सोप्याचे उदाहरण आहे:

def empty_func(): पास
डिक्लेरेशनची सुरुवात def या कीवर्डने होते, जे तुम्ही अंदाज लावू शकता, ते परिभाषित करण्यासाठी एक संक्षिप्त रूप आहे. त्यानंतर फंक्शनचे नाव दिले जाते. नावानंतर, कंसात, पॅरामीटर्सची सूची निर्दिष्ट केली आहे, जी या प्रकरणात गहाळ आहेत.
फंक्शनचा मुख्य भाग पुढील ओळीतून इंडेंट केला जातो. कृपया लक्षात घ्या की Python मध्ये रिकाम्या शरीरासह फंक्शन्स प्रतिबंधित आहेत, म्हणून वरील फंक्शनचा मुख्य भाग म्हणून “रिक्त ऑपरेटर” पास वापरला जातो.
आता आणखी गंभीर उदाहरण पाहू.

Def safe_div(x, y): """मजेसाठी आणि फायद्यासाठी सुरक्षित विभागणी करा:-) आई ___अर!"
या उदाहरणात अनेक नवकल्पना आहेत. फंक्शन बॉडीनंतर लगेच येणारी डॉक्युमेंटेशन लाइन (डॉक्स्ट्रिंग) ही पहिली गोष्ट तुमच्या डोळ्यांना आकर्षित करते.
सहसा ही ओळ स्त्रोत मजकूराच्या एकापेक्षा जास्त ओळी घेते (श्लेष क्षमा करा) आणि म्हणून तिहेरी अवतरणांमध्ये निर्दिष्ट केली जाते. हे फंक्शन, त्याचा उद्देश, पॅरामीटर्स इत्यादीचे वर्णन करण्यासाठी आहे. सर्व चांगले IDE या ओळीसह कार्य करू शकतात. तुम्ही __doc__ गुणधर्म वापरून प्रोग्राममधून देखील त्यात प्रवेश करू शकता:

सुरक्षित_दिव.__डॉक__ प्रिंट करा
हा गुणधर्म (होय, होय, अगदी एक गुणधर्म, Python मध्ये अगदी फंक्शन्स प्रत्यक्षात क्लासेस आहेत) परस्परसंवादी कन्सोलच्या सत्रादरम्यान वापरण्यास सोयीस्कर आहे.
>>> ftplib वरून FTP आयात करा >>> FTP.__doc__ FTP क्लायंट क्लास प्रिंट करा. कनेक्शन तयार करण्यासाठी, या युक्तिवादाचा वापर करून वर्गाला कॉल करा: होस्ट, वापरकर्ता, passwd, acct या सर्व स्ट्रिंग आहेत आणि डीफॉल्ट मूल्य "" आहे. नंतर पर्यायी होस्ट आणि पोर्ट आर्ग्युमेंटसह self.connect() वापरा. #बाकी मी करतो :-)
चला आपल्या मूळ कार्याकडे परत जाऊया. त्याचे सार अगदी सोपे आहे, यास 2 पॅरामीटर्स लागतात: x आणि y. y 0 नसल्यास, ते x ला y ने विभाजित करते, परिणाम स्क्रीनवर मुद्रित करते आणि परिणाम म्हणून त्याचा भागफल परत करते. रिटर्न कमांड वापरून फंक्शन रिझल्ट परत केला जातो. शेवटच्या धड्यात वर्णन केलेल्या ट्यूपल मेकॅनिझमबद्दल धन्यवाद, Python मधील फंक्शन्स एकाच वेळी अनेक ऑब्जेक्ट्स परत करू शकतात.
भाजक अजूनही शून्य असल्यास, फंक्शन त्रुटी संदेश प्रदर्शित करते. या प्रकरणात फंक्शन काहीही परत करणार नाही असे मानणे चुकीचे आहे. फंक्शन “नथिंग” रिटर्न करेल असे म्हणणे अधिक योग्य ठरेल :) दुसऱ्या शब्दांत, जर फंक्शनमध्ये रिटर्न स्टेटमेंट नसेल, किंवा त्याला पॅरामीटर्सशिवाय कॉल केले असेल, तर फंक्शन काहीही नाही हे विशेष मूल्य परत करेल. तुम्ही प्रिंट safe_div(10, 0) सारखे काहीतरी कॉल करून हे सहजपणे सत्यापित करू शकता.

Guido van Rossum द्वारे सादरीकरण अहवालातून घेतलेले हे थोडे अधिक क्लिष्ट उदाहरण आहे.

Def gcd(a, b): "GCD शोधत आहे" तर a != 0: a,b = b%a,a # समांतर परिभाषा परत b
हे फंक्शन दोन संख्यांचा सर्वात मोठा सामान्य विभाजक शोधते.

सर्वसाधारणपणे, लक्षात ठेवा की पायथन फंक्शन्समधील पॅरामीटर्स संदर्भानुसार पास केले जातात. आणखी एक, कदाचित क्षुल्लक नसलेली वस्तुस्थिती जी तुम्हाला अंगवळणी पडावी लागेल ही वस्तुस्थिती आहे की फंक्शन्स हे एक मूल्य आहे जे नियुक्त केले जाऊ शकते. पुढील प्रयोगांसाठी आम्ही आमचे safe_div फंक्शन वापरल्यास, आम्ही खालील कोड लिहू शकतो.

मिस्टिक_फंक्शन = सुरक्षित_डिव्ह प्रिंट मिस्टिक_फंक्शन(१०, ४)
यावेळेस हेच आहे, अजुनही पायथनमधील फंक्शन्स परिभाषित करण्याचे अनेक पैलू बाकी आहेत "ओव्हरबोर्ड" जे पुढील वेळी कव्हर केले जातील.

चाचणीसाठी व्यायाम.
1. GCD शोधण्यासाठी विद्यमान फंक्शनच्या आधारे, दोन संख्यांचे LCM शोधण्यासाठी फंक्शन लिहा.
2. आर्ग्युमेंट म्हणून पास केलेल्या फंक्शनसाठी टॅब्युलेशन रूटीन लिहा. युक्तिवाद प्रारंभिक, अंतिम मूल्य आणि सारणी चरण देखील निर्दिष्ट करतात.

PS तसे, “धडा” ची इष्टतम लांबी किती आहे? काय चांगले आहे - मोठे अध्याय कमी वारंवार प्रकाशित होतात किंवा "कमी चांगले, अधिक वेळा?"

फंक्शन हा कोडचा एक वेगळा ब्लॉक असतो जो विशिष्ट कार्य करण्यासाठी डिझाइन केलेला असतो आणि त्याचा पुन्हा वापर केला जाऊ शकतो. फंक्शन्स प्रोग्राम कोड मॉड्यूलर आणि अधिक कॉम्पॅक्ट बनवतात.

पायथन अनेक अंगभूत कार्ये ऑफर करतो. आपण कदाचित यासह परिचित आहात:

• print() ऑब्जेक्टला टर्मिनलवर प्रिंट करते.
• int() स्ट्रिंग्स किंवा संख्यांना पूर्णांकांमध्ये रूपांतरित करते.
• len() ऑब्जेक्टची लांबी परत करते.

फंक्शनच्या नावात कंस असतात आणि त्यात पॅरामीटर्स असू शकतात.

हे ट्यूटोरियल तुम्हाला कस्टम फंक्शन्स कसे परिभाषित करायचे ते शिकवेल.

कार्य व्याख्या

प्रथम, एक साधा “हॅलो, वर्ल्ड!” प्रोग्राम रूपांतरित करण्याचा प्रयत्न करा. फंक्शन मध्ये.

नवीन मजकूर फाइल hello.py तयार करा आणि नंतर फंक्शन परिभाषित करा.

फंक्शन परिभाषित करण्यासाठी, def कीवर्ड वापरा, नंतर फंक्शनचे नाव आणि पॅरामीटर्स असलेले कंस निर्दिष्ट करा (कोणतेही पॅरामीटर्स नसल्यास, कंस रिक्त राहतात), त्यानंतर कोलन असेल.

hello() फंक्शन परिभाषित करण्यासाठी, तुमच्या hello.py फाइलमध्ये पुढील गोष्टी जोडा:

ही फंक्शनची मूळ व्याख्या आहे.

def हॅलो():
प्रिंट ("हॅलो, वर्ल्ड!")

फंक्शन आता परिभाषित केले आहे. परंतु आपण या टप्प्यावर प्रोग्राम चालविल्यास, काहीही होणार नाही: कार्य कार्य करण्यासाठी, ते केवळ परिभाषित केले जाणे आवश्यक नाही तर कॉल देखील केले पाहिजे.

फंक्शन परिभाषित केल्यानंतर, त्यास कॉल करा:

def हॅलो():
प्रिंट ("हॅलो, वर्ल्ड!")
नमस्कार()

आता प्रोग्राम चालवा:

ते परत आले पाहिजे:

hello() फंक्शन हे अगदी साधे उदाहरण आहे. लूप, सशर्त अभिव्यक्ती आणि इतर घटकांसह कार्ये अधिक जटिल असू शकतात.

जेव्हा फंक्शन रिटर्न स्टेटमेंटवर पोहोचते तेव्हा ते कार्यान्वित करणे थांबवते.

# फाइल return_loop.py
def loop_five():
श्रेणीतील x साठी(0, 25):
प्रिंट(x)
जर x == 5:
# x == 5 वर फंक्शन थांबवा
परत
प्रिंट ("ही ओळ कार्यान्वित होणार नाही.")
loop_five()

a for loop मधील रिटर्न स्टेटमेंट फंक्शन कार्यान्वित करणे थांबवते, त्यामुळे फंक्शन नंतरच्या ओळी कार्यान्वित केल्या जाणार नाहीत. जर त्याऐवजी ब्रेक स्टेटमेंट वापरले असते, तर प्रोग्रामने फंक्शनऐवजी लूप चालवणे थांबवले असते आणि शेवटचे प्रिंट() स्टेटमेंट प्रोसेस केले असते.

main() फंक्शन

पायथनमध्ये, प्रोग्रामच्या शेवटी फंक्शन कॉल केले जाऊ शकते आणि ते चालेल (मागील उदाहरणांमध्ये दर्शविल्याप्रमाणे), परंतु काही प्रोग्रामिंग भाषांना (जसे की C++ किंवा Java) मुख्य कार्य आवश्यक आहे. Python मधील main() फंक्शन पर्यायी आहे, परंतु ते तुम्हाला तुमच्या Python प्रोग्रामची तार्किक रचना करण्यास आणि त्यातील सर्वात महत्त्वाचे घटक एकाच फंक्शनमध्ये एकत्र करण्यास अनुमती देते. हे इतर भाषांमध्ये काम करणाऱ्या प्रोग्रामरसाठी पायथन प्रोग्राम्स वाचणे सोपे करते.

hello.py फाईलवर परत जा आणि hello() फंक्शन ठेवताना main() फंक्शन जोडा.

def हॅलो():
प्रिंट ("हॅलो, वर्ल्ड!")
def main():

main() फंक्शनमध्ये प्रिंट() स्टेटमेंट जोडा. नंतर main() फंक्शनमध्ये hello() फंक्शनला कॉल करा.

def हॅलो():
प्रिंट ("हॅलो, वर्ल्ड!")
def main():
प्रिंट ("हे मुख्य कार्य आहे")
नमस्कार()

फाईलच्या शेवटी, main() फंक्शनला कॉल करा.

def हॅलो():
प्रिंट ("हॅलो, वर्ल्ड!")
def main():
प्रिंट ("हे मुख्य कार्य आहे.")
नमस्कार()
मुख्य()

आता आपण प्रोग्राम चालवू शकता:

python hello.py
हे मुख्य कार्य आहे.
नमस्कार, जग!

आता अनेक फंक्शन्स वापरून पहा.

प्रोग्रामिंगमधील फंक्शन हा कोडचा एक वेगळा तुकडा आहे ज्याला त्याचे नाव ज्या नावाने दिले आहे त्याचा संदर्भ देऊन कॉल केला जाऊ शकतो. कॉल केल्यावर, फंक्शन बॉडीच्या कमांड्स अंमलात आणल्या जातात.

फंक्शन्सची तुलना लहान प्रोग्राम्सशी केली जाऊ शकते जे स्वतःच कार्यान्वित करत नाहीत, म्हणजेच स्वायत्तपणे, परंतु नियमित प्रोग्राममध्ये एकत्रित केले जातात. त्यांना सहसा सबरूटीन म्हणतात. फंक्शन्स आणि प्रोग्राम्समध्ये इतर कोणतेही महत्त्वाचे फरक नाहीत. फंक्शन्स आवश्यकतेनुसार डेटा प्राप्त आणि परत देखील करू शकतात. फक्त सहसा ते इनपुट (कीबोर्ड, फाइल इ.) वरून नाही तर कॉलिंग प्रोग्राममधून प्राप्त करतात. येथे ते त्यांच्या कामाचे परिणाम परत करतात.

प्रोग्रामिंग लँग्वेजमध्ये अनेक फंक्शन्स अंतर्भूत आहेत. आम्ही यापैकी काही पायथनमध्ये आधीच भेटलो आहोत. हे print(), input(), int(), float(), str(), type() आहेत. त्यांच्या शरीराची संहिता आपल्याला दिसत नाही, ती कुठेतरी "भाषेच्या आत लपलेली आहे." आम्हाला फक्त एक इंटरफेस प्रदान केला जातो - फंक्शनचे नाव.

दुसरीकडे, प्रोग्रामर नेहमीच स्वतःची कार्ये परिभाषित करू शकतो. त्यांना प्रथा म्हणतात. या प्रकरणात, "वापरकर्ता" म्हणजे प्रोग्रामर, जो प्रोग्राम वापरतो तो नाही. आम्हाला या फंक्शन्सची गरज का आहे आणि ते कसे तयार करायचे ते शोधूया.

समजा तुम्हाला संख्यांची जोडी सलग तीन वेळा मागायची आहे आणि ती जोडायची आहे. या उद्देशासाठी, आपण लूप वापरू शकता:

i = 0 तर i< 3 : a = int (input () ) b = int (input () ) print (a+b) i += 1

तथापि, संख्यांसाठी प्रत्येक विनंती करण्यापूर्वी, आपल्याला त्यांची आवश्यकता का आहे हे शिलालेख प्रदर्शित करणे आवश्यक आहे आणि प्रत्येक वेळी हा शिलालेख वेगळा असेल तर काय करावे. आपण एक चक्र खंडित करू शकत नाही आणि नंतर पुन्हा त्याच चक्राकडे परत येऊ शकत नाही. तुम्हाला ते सोडून द्यावे लागेल आणि नंतर तुम्हाला वेगवेगळ्या ठिकाणी समान विभाग असलेला एक लांब कोड मिळेल:

प्रिंट () a = int (इनपुट () ) b = int (इनपुट () ) प्रिंट ("एकूण", a+b, "pcs." ) प्रिंट () a = int (इनपुट () ) b = int (इनपुट () ) प्रिंट ("एकूण", a+b, "pcs." )

कार्यक्रम अंमलबजावणीचे उदाहरण:

माकडांसाठी किती केळी आणि अननस? 15 5 एकूण 20 पीसी. हेजहॉग्जसाठी किती बीटल आणि वर्म्स? 50 12 एकूण 62 पीसी. ओटर्ससाठी किती मासे आणि शेलफिश? 16 8 एकूण 24 पीसी.

फंक्शन्सची ओळख आपल्याला प्रोग्रामच्या वेगवेगळ्या ठिकाणी कोड डुप्लिकेशनची समस्या सोडविण्यास अनुमती देते. त्यांचे आभार, तुम्ही कोडचा समान विभाग तात्काळ कार्यान्वित करू शकता, परंतु जेव्हा आवश्यक असेल तेव्हाच.

फंक्शनची व्याख्या. def ऑपरेटर

पायथन प्रोग्रामिंग भाषेत, def स्टेटमेंट वापरून फंक्शन्स परिभाषित केले जातात. चला कोड पाहू:

def countFood(): a = int (इनपुट () ) b = int (इनपुट () ) प्रिंट ("एकूण", a+b, "pcs.")

हे फंक्शन डेफिनेशनचे उदाहरण आहे. कंडिशनल स्टेटमेंट आणि लूप सारख्या इतर जटिल विधानांप्रमाणे, फंक्शनमध्ये हेडर आणि बॉडी असते. शीर्षक कोलन आणि नवीन ओळीने समाप्त होते. शरीर इंडेंट केलेले आहे.

def कीवर्ड दुभाष्याला सांगते की ही फंक्शनची व्याख्या आहे. def फंक्शनच्या नावानंतर आहे. हे काहीही असू शकते, कोणत्याही अभिज्ञापकाप्रमाणे, उदाहरणार्थ, चल. प्रोग्रामिंगमध्ये, प्रत्येक गोष्टीला अर्थपूर्ण नावे देणे अत्यंत इष्ट आहे. तर या प्रकरणात, फंक्शनला रशियनमध्ये अनुवादित “countFood” म्हणतात.

फंक्शनच्या नावानंतर कंस येतो. दिलेल्या उदाहरणात ते रिकामे आहेत. याचा अर्थ फंक्शन कॉल करणाऱ्या प्रोग्राममधील कोणताही डेटा स्वीकारत नाही. तथापि, ते त्यांना स्वीकारू शकते, आणि नंतर तथाकथित पॅरामीटर्स कंसात सूचित केले जातील.

फंक्शन कॉल केल्यावर अंमलात आणल्या जाणाऱ्या सूचनांचा समावेश असलेल्या शरीराच्या नंतर कोलन येते. फंक्शन परिभाषित करणे आणि कॉल करणे यात फरक करणे आवश्यक आहे. प्रोग्राम कोडमध्ये ते जवळपास नाहीत आणि एकत्र नाहीत. तुम्ही फंक्शन परिभाषित करू शकता, परंतु ते कधीही कॉल करू नका. परिभाषित न केलेले फंक्शन तुम्ही कॉल करू शकत नाही. जर तुम्ही फंक्शन परिभाषित केले परंतु ते कधीही कॉल केले नाही तर तुम्ही त्याचे मुख्य भाग कधीही कार्यान्वित करणार नाही.

फंक्शन कॉल करत आहे

फंक्शनसह प्रोग्रामची संपूर्ण आवृत्ती पाहू:

def countFood() : a = int (इनपुट () ) b = int (इनपुट () ) प्रिंट ("एकूण", a+b, "pcs.") प्रिंट ( "माकडांसाठी किती केळी आणि अननस?") काउंटफूड() प्रिंट ( "हेजहॉग्जसाठी किती बीटल आणि वर्म्स?") काउंटफूड() प्रिंट ( "ओटर्ससाठी किती मासे आणि शेलफिश?") काउंटफूड()

प्रत्येक माहिती संदेश प्रदर्शित झाल्यानंतर, एक फंक्शन कॉल केला जातो, जो फक्त कंसांसह त्याचे नाव नमूद केल्यासारखे दिसते. आपण फंक्शनमध्ये काहीही पास करत नसल्यामुळे, कंस पुन्हा रिक्त आहेत. वरील कोडमध्ये, फंक्शन तीन वेळा म्हटले जाते.

जेव्हा फंक्शन कॉल केले जाते, तेव्हा प्रोग्राम थ्रेड त्याच्या व्याख्येवर जातो आणि त्याचे मुख्य भाग कार्यान्वित करण्यास सुरवात करतो. फंक्शन बॉडी कार्यान्वित झाल्यानंतर, कार्यान्वित करण्याचा थ्रेड फंक्शन कॉल केलेल्या ठिकाणी मुख्य कोडवर परत येतो. पुढे, कॉल खालील अभिव्यक्ती कार्यान्वित केली जाते.

Python मध्ये, फंक्शनची व्याख्या त्याच्या कॉल्सच्या आधी असणे आवश्यक आहे. हे या वस्तुस्थितीमुळे आहे की दुभाषी कोड लाइन ओळीने वाचतो आणि अद्याप डाउनस्ट्रीम काय आहे हे माहित नाही. म्हणून, फंक्शन कॉल त्याच्या व्याख्येच्या आधी असल्यास, एक त्रुटी उद्भवते (एक NameError अपवाद टाकला जातो):

छापा( "माकडांसाठी किती केळी आणि अननस?") काउंटफूड() प्रिंट ( "हेजहॉग्जसाठी किती बीटल आणि वर्म्स?") काउंटफूड() प्रिंट ( "ओटर्ससाठी किती मासे आणि शेलफिश?") countFood() def countFood(): a = int (इनपुट () ) b = int (इनपुट () ) प्रिंट ("एकूण", a+b, "pcs.")

परिणाम:

माकडांसाठी किती केळी आणि अननस? ट्रेसबॅक (सर्वात अलीकडील कॉल शेवटचा): फाइल "test.py" , लाइन 2 , मध्ये< module>countFood() NameError: नाव "countFood" परिभाषित केलेले नाही

अनेक संकलित भाषांसाठी ही आवश्यकता नाही. तेथे तुम्ही प्रोग्राममधील अनियंत्रित ठिकाणी फंक्शन परिभाषित आणि कॉल करू शकता. तथापि, कोड वाचनीयतेसाठी, प्रोग्रामर या प्रकरणात देखील काही नियमांचे पालन करण्यास प्राधान्य देतात.

फंक्शन्स प्रोग्राम स्ट्रक्चर देतात

फंक्शन्सचा फायदा म्हणजे प्रोग्राममधील वेगवेगळ्या ठिकाणांहून एकाच कोडला अनेक वेळा कॉल करण्याची क्षमता नाही. तितकेच महत्त्वाचे, ते कार्यक्रमाला खरी रचना देतात. फंक्शन्स असे दिसते की ते स्वतंत्र भागांमध्ये विभागले जातात, ज्यापैकी प्रत्येक स्वतःचे विशिष्ट कार्य करते.

समजा तुम्हाला एक प्रोग्राम लिहायचा आहे जो वेगवेगळ्या आकृत्यांच्या क्षेत्रांची गणना करतो. वापरकर्ता त्याला कोणत्या आकृतीचे क्षेत्रफळ मोजायचे आहे ते निर्दिष्ट करतो. यानंतर, प्रारंभिक डेटा प्रविष्ट करते. उदाहरणार्थ, आयताच्या बाबतीत लांबी आणि रुंदी. अंमलबजावणीचा धागा एकाधिक शाखांमध्ये विभाजित करण्यासाठी, तुम्ही if-elif-else विधान वापरावे:

आकृती = इनपुट () जर आकृती == "1" : a = फ्लोट (इनपुट ("रुंदी: " ) ) b = फ्लोट (इनपुट ("उंची: " ) ) प्रिंट ("क्षेत्रः %.2f" % (a* b) ) एलिफ आकृती == "2" : a = फ्लोट (इनपुट ("बेस: " ) ) h = फ्लोट (इनपुट ("उंची: " ) ) प्रिंट ("क्षेत्रः %.2f" % (0.5 * a * h) ) एलिफ आकृती == "3" : r = फ्लोट (इनपुट ("त्रिज्या: " ) ) प्रिंट ("क्षेत्रः %.2f" % (3.14 * r**2 ) ) बाकी : प्रिंट ("इनपुट त्रुटी" )

येथे कोणतीही कार्ये नाहीत आणि सर्व काही ठीक आहे. परंतु फंक्शन्ससह आवृत्ती लिहूया:

def rectangle() : a = फ्लोट (इनपुट ("रुंदी: " ) ) b = फ्लोट (इनपुट ("उंची: " ) ) प्रिंट ("क्षेत्र: %.2f" % (a*b) ) def त्रिकोण() : a = फ्लोट (इनपुट ("बेस: " ) ) h = फ्लोट (इनपुट ("उंची: " ) ) प्रिंट ( "क्षेत्रः %.2f" % (0.5 * a * h) ) def सर्कल() : r = फ्लोट (इनपुट ("त्रिज्या: " ) ) प्रिंट ( "क्षेत्रः %.2f" % (3.14 * r**2 ) ) आकृती = इनपुट ( "1-आयत, 2-त्रिकोण, 3-वर्तुळ: ") if आकृती == "1" : आयत() elif आकृती == "2" : त्रिकोण() elif आकृती == "3" : वर्तुळ() else : प्रिंट ("इनपुट त्रुटी")

हे अधिक क्लिष्ट दिसते आणि तीनपैकी प्रत्येक फंक्शन्स फक्त एकदाच कॉल केले जातात. तथापि, कार्यक्रमाच्या सामान्य तर्कातून, क्षेत्रे शोधण्याच्या सूचना काढून टाकल्या आहेत आणि वेगळ्या केल्या आहेत. प्रोग्राममध्ये आता वैयक्तिक "लेगो विटा" आहेत. मुख्य शाखेत आपण आपल्या आवडीनुसार एकत्र करू शकतो. हे नियंत्रण यंत्रणेची भूमिका बजावते.

जर आपल्याला उंचीपेक्षा हेरॉनचे सूत्र वापरून त्रिकोणाचे क्षेत्रफळ काढायचे असेल, तर आपल्याला कोडसाठी संपूर्ण प्रोग्राम शोधण्याची गरज नाही (त्याला वास्तविक प्रोग्राम्सप्रमाणे कोडच्या हजारो ओळी समजा). आम्ही फंक्शन्स परिभाषित केलेल्या ठिकाणी जाऊ आणि त्यापैकी एकाचा मुख्य भाग बदलू.

आम्हाला ही फंक्शन्स इतर प्रोग्राममध्ये वापरायची असल्यास, आम्ही या कोड फाईलचा संदर्भ देऊन ते आयात करू शकतो (हे पायथनमध्ये कसे केले जाते याबद्दल नंतर चर्चा केली जाईल).

व्यावहारिक काम

प्रोग्रामिंगमध्ये, तुम्ही एका फंक्शनमधून दुसरे फंक्शन कॉल करू शकता. ही शक्यता स्पष्ट करण्यासाठी, खालील वर्णनासह प्रोग्राम लिहा.

प्रोग्रामच्या मुख्य शाखेत, फंक्शन हेडरची गणना न करता, कोडची एक ओळ असते. हा test() फंक्शनला कॉल आहे. ते पूर्णांक इनपुटसाठी विचारते. जर ते सकारात्मक असेल, तर सकारात्मक() फंक्शन म्हटले जाते, ज्याच्या मुख्य भागामध्ये स्क्रीनवर "पॉझिटिव्ह" शब्द प्रदर्शित करण्यासाठी कमांड असते. जर संख्या ऋण असेल, तर नकारात्मक() फंक्शन म्हटले जाते, त्याच्या मुख्य भागामध्ये "नकारात्मक" शब्द प्रदर्शित करण्यासाठी एक अभिव्यक्ती असते.