रिटर्न स्टेटमेंट क्या है, इसका सरल मूल स्पष्टीकरण क्या है, इसे पायथन में कैसे उपयोग किया जाए?
और इसके और printकथन में क्या अंतर है ?
जवाबों:
print()समारोह लेखन, यानी, "प्रिंट", कंसोल में एक स्ट्रिंग। यह returnकथन आपके फ़ंक्शन को उसके कॉलर के मान से बाहर निकलने और वापस भेजने का कारण बनता है। सामान्य रूप से कार्यों का बिंदु इनपुट में लेना और कुछ वापस करना है। returnबयान जब एक समारोह अपने फोन करने वाले के लिए एक मूल्य के वापस जाने के लिए तैयार है प्रयोग किया जाता है।
उदाहरण के लिए, यहां एक फ़ंक्शन दोनों का उपयोग कर रहा है print()और return:
def foo():
print("hello from inside of foo")
return 1
अब आप कोड को चला सकते हैं जो फू को कॉल करता है, जैसे:
if __name__ == '__main__':
print("going to call foo")
x = foo()
print("called foo")
print("foo returned " + str(x))
यदि आप इसे स्क्रिप्ट (उदाहरण के लिए .pyफ़ाइल) के रूप में चलाते हैं , तो पाइथन इंटरप्रेटर के विपरीत, आपको निम्न आउटपुट मिलेगा:
going to call foo
hello from inside foo
called foo
foo returned 1
मुझे उम्मीद है कि यह स्पष्ट हो जाएगा। दुभाषिया कंसोल को रिटर्न मान लिखता है ताकि मैं देख सकूं कि किसी को भ्रमित क्यों किया जा सकता है।
यहाँ दुभाषिया का एक और उदाहरण है जो प्रदर्शित करता है कि:
>>> def foo():
... print("hello from within foo")
... return 1
...
>>> foo()
hello from within foo
1
>>> def bar():
... return 10 * foo()
...
>>> bar()
hello from within foo
10
आप देख सकते हैं कि कब foo()से कहा जाता है bar(), 1 कंसोल पर नहीं लिखा है। इसके बजाय इसका उपयोग उस मूल्य से गणना करने के लिए किया जाता है bar()।
print()एक फ़ंक्शन है जो एक साइड इफेक्ट का कारण बनता है (यह कंसोल में एक स्ट्रिंग लिखता है), लेकिन निष्पादन अगले बयान के साथ फिर से शुरू होता है। returnफ़ंक्शन को निष्पादित करने से रोकने और जो भी इसे कहा जाता है उसे वापस मूल्य सौंपने का कारण बनता है।
"foo returned " + str(x)या फिर आपको मिलेगा TypeError: cannot concatenate 'str' and 'int' objects।
एक साइड-इफ़ेक्ट के कारण प्रिंट स्टेटमेंट के बारे में सोचें , यह आपके फ़ंक्शन को उपयोगकर्ता के लिए कुछ पाठ लिखने देता है, लेकिन इसका उपयोग दूसरे फ़ंक्शन द्वारा नहीं किया जा सकता है।
मैं कुछ उदाहरणों और विकिपीडिया से कुछ परिभाषाओं के साथ इसे बेहतर ढंग से समझाने का प्रयास करूँगा।
यहाँ विकिपीडिया से एक फ़ंक्शन की परिभाषा दी गई है
एक फ़ंक्शन, गणित में, एक मात्रा को जोड़ता है, फ़ंक्शन का तर्क, जिसे इनपुट के रूप में भी जाना जाता है, एक अन्य मात्रा के साथ, फ़ंक्शन का मूल्य, आउटपुट के रूप में भी जाना जाता है।
एक सेकंड के लिए इसके बारे में सोचिए। जब आप कहते हैं कि फ़ंक्शन का मान है तो इसका क्या मतलब है?
इसका मतलब यह है कि आप वास्तव में एक फ़ंक्शन का मान सामान्य मान के साथ स्थानापन्न कर सकते हैं! (मान दो मान एक ही प्रकार के हैं)
आप क्यों चाहेंगे कि आप पूछें?
अन्य कार्यों के बारे में क्या जो इनपुट के रूप में एक ही प्रकार के मूल्य को स्वीकार कर सकते हैं ?
def square(n):
return n * n
def add_one(n):
return n + 1
print square(12)
# square(12) is the same as writing 144
print add_one(square(12))
print add_one(144)
#These both have the same output
फ़ंक्शंस के लिए एक फैंसी गणितीय शब्द है जो केवल उनके आउटपुट का उत्पादन करने के लिए उनके इनपुट पर निर्भर करता है: रेफ़रेंशियल ट्रांसपेरेंसी। फिर से, विकिपीडिया से एक परिभाषा।
रेफ़रेंशियल ट्रांसपेरेंसी एंड रेफ़रेंशियल अपारदर्शिता कंप्यूटर प्रोग्राम के कुछ हिस्सों के गुण हैं। एक अभिव्यक्ति को संदर्भित रूप से पारदर्शी कहा जाता है यदि इसे किसी प्रोग्राम के व्यवहार को बदले बिना इसके मूल्य के साथ प्रतिस्थापित किया जा सकता है
यह समझ पाना थोड़ा मुश्किल हो सकता है कि इसका मतलब क्या है अगर आप प्रोग्रामिंग में नए हैं, लेकिन मुझे लगता है कि आपको इसे कुछ प्रयोग के बाद मिलेगा। सामान्य तौर पर, आप किसी फ़ंक्शन में प्रिंट जैसी चीजें कर सकते हैं, और अंत में आपका रिटर्न स्टेटमेंट भी हो सकता है।
बस याद रखें कि जब आप रिटर्न का उपयोग करते हैं तो आप मूल रूप से कह रहे हैं "इस फ़ंक्शन के लिए एक कॉल वैसा ही है जैसा कि मूल्य लिखा जाता है"
पायथन वास्तव में आपके लिए एक वापसी मूल्य सम्मिलित करेगा यदि आप अपने आप में डालने के लिए अस्वीकार करते हैं, तो इसे "कोई नहीं" कहा जाता है, और यह एक विशेष प्रकार है जिसका सीधा अर्थ है कुछ भी नहीं, या अशक्त।
अजगर में, हम "डिफ" के साथ एक फ़ंक्शन को परिभाषित करना शुरू करते हैं और आम तौर पर, लेकिन जरूरी नहीं कि "वापसी" के साथ फ़ंक्शन को समाप्त करें।
चर x के एक कार्य को f (x) के रूप में निरूपित किया जाता है। यह कार्य क्या करता है? मान लीजिए, यह फ़ंक्शन 2 से x जोड़ता है। तो, एफ (एक्स) = एक्स + 2
अब, इस फ़ंक्शन का कोड होगा:
def A_function (x):
return x + 2
फ़ंक्शन को परिभाषित करने के बाद, आप किसी भी चर के लिए उपयोग कर सकते हैं और परिणाम प्राप्त कर सकते हैं। जैसे कि:
print A_function (2)
>>> 4
हम कोड को थोड़ा अलग तरीके से लिख सकते हैं, जैसे:
def A_function (x):
y = x + 2
return y
print A_function (2)
वह भी "4" देगा।
अब, हम इस कोड का उपयोग भी कर सकते हैं:
def A_function (x):
x = x + 2
return x
print A_function (2)
यह भी 4 देगा। देखें कि, "x" वास्तव में रिटर्न का मतलब है (x + 2), न कि "A_function (x)" का।
मैं इस सरल उदाहरण से अनुमान लगाता हूं, आप रिटर्न कमांड का अर्थ समझेंगे।
return का अर्थ है, "इस फ़ंक्शन से यह मान आउटपुट करें"।
print का अर्थ है, "इस मान को (आम तौर पर) stdout को भेजें"
पायथन आरईपीएल में, एक फ़ंक्शन रिटर्न डिफ़ॉल्ट रूप से स्क्रीन पर आउटपुट होगा (यह प्रिंट के समान नहीं है)।
यह प्रिंट का एक उदाहरण है:
>>> n = "foo\nbar" #just assigning a variable. No output
>>> n #the value is output, but it is in a "raw form"
'foo\nbar'
>>> print n #the \n is now a newline
foo
bar
>>>
यह वापसी का एक उदाहरण है:
>>> def getN():
... return "foo\nbar"
...
>>> getN() #When this isn't assigned to something, it is just output
'foo\nbar'
>>> n = getN() # assigning a variable to the return value. No output
>>> n #the value is output, but it is in a "raw form"
'foo\nbar'
>>> print n #the \n is now a newline
foo
bar
>>>
यह उत्तर उन मामलों में से कुछ पर चला गया है जिनकी ऊपर चर्चा नहीं की गई है। वापसी बयान आप के लिए अनुमति देता समाप्त एक समारोह के निष्पादन से पहले आप अंत तक पहुँचते हैं। यह कॉल करने वाले को तुरंत लौटने के लिए निष्पादन के प्रवाह का कारण बनता है।
पंक्ति संख्या 4 में:
def ret(n):
if n > 9:
temp = "two digits"
return temp #Line 4
else:
temp = "one digit"
return temp #Line 8
print("return statement")
ret(10)
सशर्त विवरण निष्पादित होने के बाद (4 लाइन) के ret()कारण फ़ंक्शन समाप्त हो जाता है return temp। इस प्रकार print("return statement")निष्पादित नहीं होता है।
आउटपुट:
two digits
यह कोड जो सशर्त बयानों के बाद दिखाई देता है, या जिस स्थान पर नियंत्रण का प्रवाह नहीं पहुंच सकता है, वह मृत कोड है ।
लौटाने का मूल्य
लाइनों नंबर 4 और 8 में, रिटर्न स्टेटमेंट का उपयोग एक अस्थायी चर के मान को वापस करने के लिए किया जा रहा है, जब स्थिति निष्पादित की गई है।
प्रिंट और रिटर्न के बीच का अंतर बाहर लाने के लिए :
def ret(n):
if n > 9:
print("two digits")
return "two digits"
else :
print("one digit")
return "one digit"
ret(25)
आउटपुट:
two digits
'two digits'
बस @ नातान ह्यूजेस के उत्कृष्ट उत्तर को जोड़ने के लिए:
returnबयान नियंत्रण प्रवाह का एक प्रकार के रूप में इस्तेमाल किया जा सकता। एक (या अधिक) लगाकरreturnएक फ़ंक्शन के बीच में स्टेटमेंट , हम कह सकते हैं: "इस फ़ंक्शन को निष्पादित करना बंद करें। हमें या तो वह मिला है जो हम चाहते थे या कुछ गलत हो गया है!"
यहाँ एक उदाहरण है:
>>> def make_3_characters_long(some_string):
... if len(some_string) == 3:
... return False
... if str(some_string) != some_string:
... return "Not a string!"
... if len(some_string) < 3:
... return ''.join(some_string,'x')[:,3]
... return some_string[:,3]
...
>>> threechars = make_3_characters_long('xyz')
>>> if threechars:
... print threechars
... else:
... print "threechars is already 3 characters long!"
...
threechars is already 3 characters long!
उपयोग करने के इस तरीके के बारे में अधिक सलाह के लिए पायथन गाइड का कोड स्टाइल अनुभाग देखें return।
"रिटर्न" और "प्रिंट" के बीच अंतर भी निम्न उदाहरण में पाया जा सकता है:
वापसी:
def bigger(a, b):
if a > b:
return a
elif a <b:
return b
else:
return a
उपरोक्त कोड सभी इनपुट के लिए सही परिणाम देगा।
प्रिंट:
def bigger(a, b):
if a > b:
print a
elif a <b:
print b
else:
print a
नोट: यह कई परीक्षण मामलों के लिए विफल हो जाएगा।
त्रुटि:
----
FAILURE: Test case input: 3, 8.
Expected result: 8
FAILURE: Test case input: 4, 3.
Expected result: 4
FAILURE: Test case input: 3, 3.
Expected result: 3
You passed 0 out of 3 test cases
मुझे लगता है कि वास्तव में सरल उत्तर यहां उपयोगी हो सकता है:
returnकॉलर द्वारा उपयोग के लिए मूल्य (एक चर, अक्सर) उपलब्ध करता है (उदाहरण के लिए, एक फ़ंक्शन द्वारा संग्रहीत किया जाना है जो फ़ंक्शन का उपयोग कर रहा returnहै)। बिना return, आपका मूल्य या चर कॉलर को स्टोर / पुनः उपयोग करने के लिए उपलब्ध नहीं होगा।
print स्क्रीन पर प्रिंट करता है, लेकिन कॉलर द्वारा उपयोग के लिए मूल्य या चर उपलब्ध नहीं कराता है।
(पूरी तरह से स्वीकार करते हैं कि अधिक गहन उत्तर अधिक सटीक हैं।)
यहाँ मेरी समझ है। (आशा है कि यह किसी की मदद करेगा और यह सही है)।
def count_number_of(x):
count = 0
for item in x:
if item == "what_you_look_for":
count = count + 1
return count
तो यह सरल कोड कुछ की घटनाओं की संख्या को गिनता है। वापसी का स्थान महत्वपूर्ण है। यह आपके कार्यक्रम को बताता है कि आपको मूल्य की आवश्यकता कहां है। इसलिए जब आप प्रिंट करते हैं, तो आप स्क्रीन पर आउटपुट भेजते हैं। जब आप लौटते हैं तो आप कहीं जाने का मूल्य बताते हैं। इस स्थिति में आप देख सकते हैं कि गणना = 0 रिटर्न के साथ इंडेंटेड है - हम चाहते हैं कि वैल्यू (काउंट + 1) को रिप्लेस किया जाए। 0. यदि आप रिटर्न कमांड का पालन करने की कोशिश करते हैं जब आप रिटर्न कमांड को इंडेंट करते हैं तो आउटपुट हमेशा 1 होगा। , क्योंकि हम बदलने के लिए प्रारंभिक गिनती कभी नहीं बताएंगे। मुझे उम्मीद है कि मुझे यह सही लगी। ओह, और वापसी हमेशा एक फ़ंक्शन के अंदर होती है।
returnफ़ंक्शन के बारे में सबसे अच्छी बात यह है कि आप फ़ंक्शन से मान वापस कर सकते हैं लेकिन आप printअंतर के साथ ऐसा ही कर सकते हैं ? मूल रूप से returnइसे वापस करने के बारे में नहीं है, यह ऑब्जेक्ट फॉर्म में आउटपुट देता है ताकि हम उस रिटर्न वैल्यू को फंक्शन से किसी भी वैरिएबल में सेव कर सकें लेकिन हम ऐसा नहीं कर सकते printक्योंकि इसके जैसा ही stdout/coutहै C Programming।
बेहतर समझ के लिए नीचे दिए गए कोड का पालन करें
def add(a, b):
print "ADDING %d + %d" % (a, b)
return a + b
def subtract(a, b):
print "SUBTRACTING %d - %d" % (a, b)
return a - b
def multiply(a, b):
print "MULTIPLYING %d * %d" % (a, b)
return a * b
def divide(a, b):
print "DIVIDING %d / %d" % (a, b)
return a / b
print "Let's do some math with just functions!"
age = add(30, 5)
height = subtract(78, 4)
weight = multiply(90, 2)
iq = divide(100, 2)
print "Age: %d, Height: %d, Weight: %d, IQ: %d" % (age, height, weight, iq)
# A puzzle for the extra credit, type it in anyway.
print "Here is a puzzle."
what = add(age, subtract(height, multiply(weight, divide(iq, 2))))
print "That becomes: ", what, "Can you do it by hand?"
हम अब add, subtract, multiply,और के लिए अपने स्वयं के गणित कार्य कर रहे हैं divide। ध्यान देने योग्य बात यह है कि अंतिम पंक्ति जहां हम कहते हैं कि रिटर्न a + b(इन add) है। यह निम्नलिखित है:
aऔर b।a + b। आप इसे इस तरह कह सकते हैं, "मैं जोड़ता हूं aऔर bफिर उन्हें वापस करता हूं।"a + bपरिणाम को एक चर के लिए आवंटित करने में सक्षम होगी ।returnपुनरावर्ती कार्यों / विधियों के लिए उपयोग किया जाना चाहिए या आप अपने एल्गोरिथ्म में बाद के अनुप्रयोगों के लिए दिए गए मान का उपयोग करना चाहते हैं।
print उपयोग किया जाना चाहिए जब आप उपयोगकर्ता को एक सार्थक और वांछित आउटपुट प्रदर्शित करना चाहते हैं और आप मध्यवर्ती परिणामों के साथ स्क्रीन को अव्यवस्थित नहीं करना चाहते हैं जो उपयोगकर्ता में रुचि नहीं रखता है, हालांकि वे आपके कोड को डीबग करने के लिए सहायक हैं।
निम्न कोड दिखाता है कि कैसे returnऔर printठीक से उपयोग किया जाए:
def fact(x):
if x < 2:
return 1
return x * fact(x - 1)
print(fact(5))
यह स्पष्टीकरण सभी प्रोग्रामिंग भाषाओं के लिए सही है, न कि केवल अजगर ।