คำอธิบายพื้นฐานง่ายๆของคำสั่ง return คืออะไรใช้อย่างไรใน Python

และอะไรคือความแตกต่างระหว่างมันกับprintคำสั่ง?

print()ฟังก์ชั่นการเขียนคือ "พิมพ์" สตริงในคอนโซล returnคำสั่งที่ทำให้เกิดการทำงานของคุณไปสู่ทางออกและมือกลับค่าโทรของมัน จุดของฟังก์ชันโดยทั่วไปคือรับอินพุตและส่งคืนบางสิ่ง returnคำสั่งจะใช้เมื่อมีฟังก์ชั่นพร้อมที่จะคืนค่าโทรของมัน

ตัวอย่างเช่นต่อไปนี้เป็นฟังก์ชันที่ใช้ทั้งprint()และreturn:

def foo():
    print("hello from inside of foo")
    return 1

ตอนนี้คุณสามารถเรียกใช้รหัสที่เรียกว่า foo ได้ดังนี้:

if __name__ == '__main__':
    print("going to call foo")
    x = foo()
    print("called foo")
    print("foo returned " + str(x))

หากคุณเรียกใช้สิ่งนี้เป็นสคริปต์ (เช่น.pyไฟล์) ซึ่งตรงข้ามกับใน Python interpreter คุณจะได้รับผลลัพธ์ต่อไปนี้:

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ทำให้ฟังก์ชันหยุดการทำงานและส่งค่ากลับไปยังสิ่งที่เรียกว่า

ฉันคิดว่าพจนานุกรมเป็นข้อมูลอ้างอิงที่ดีที่สุดของคุณที่นี่

ส่งคืนและพิมพ์

ในระยะสั้น:

return ให้บางอย่างกลับมาหรือตอบกลับไปยังผู้เรียกใช้ฟังก์ชันในขณะที่print สร้างข้อความ

คิดว่าคำสั่งพิมพ์เป็นสาเหตุของผลข้างเคียงซึ่งทำให้ฟังก์ชันของคุณเขียนข้อความบางส่วนถึงผู้ใช้ แต่ฟังก์ชันอื่นไม่สามารถใช้งานได้

ฉันจะพยายามอธิบายสิ่งนี้ให้ดีขึ้นด้วยตัวอย่างบางส่วนและคำจำกัดความสองสามข้อจาก Wikipedia

นี่คือคำจำกัดความของฟังก์ชันจาก Wikipedia

ฟังก์ชันในคณิตศาสตร์เชื่อมโยงปริมาณหนึ่งอาร์กิวเมนต์ของฟังก์ชันหรือที่เรียกว่าอินพุตกับปริมาณอื่นค่าของฟังก์ชันหรือที่เรียกว่าเอาต์พุต ..

ลองคิดดูสักวินาที หมายความว่าอย่างไรเมื่อคุณบอกว่าฟังก์ชันมีค่า?

ความหมายก็คือคุณสามารถแทนที่ค่าของฟังก์ชันด้วยค่าปกติได้! (สมมติว่าทั้งสองค่าเป็นค่าประเภทเดียวกัน)

ทำไมคุณถึงต้องการที่คุณถาม?

แล้วฟังก์ชันอื่น ๆ ที่อาจรับค่าประเภทเดียวกันกับอินพุตล่ะ?

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

มีคำศัพท์ทางคณิตศาสตร์ที่สวยงามสำหรับฟังก์ชันที่ขึ้นอยู่กับอินพุตเพื่อสร้างเอาต์พุตเท่านั้น: Referential Transparency อีกครั้งคำจำกัดความจาก Wikipedia

ความโปร่งใสในการอ้างอิงและความโปร่งใสในการอ้างอิงเป็นคุณสมบัติของส่วนต่างๆของโปรแกรมคอมพิวเตอร์ นิพจน์ถูกกล่าวว่ามีความโปร่งใสในการอ้างอิงหากสามารถแทนที่ด้วยค่าของมันได้โดยไม่ต้องเปลี่ยนพฤติกรรมของโปรแกรม

อาจจะยากสักหน่อยที่จะเข้าใจว่านี่หมายถึงอะไรหากคุณเพิ่งเริ่มเขียนโปรแกรม แต่ฉันคิดว่าคุณจะได้รับมันหลังจากการทดลองบางอย่าง โดยทั่วไปแล้วคุณสามารถทำสิ่งต่างๆเช่นพิมพ์ในฟังก์ชันและคุณสามารถมีคำสั่ง return ในตอนท้าย

เพียงจำไว้ว่าเมื่อคุณใช้ return คุณจะพูดว่า "การเรียกใช้ฟังก์ชันนี้เหมือนกับการเขียนค่าที่ได้รับกลับมา"

Python จะแทรกค่าส่งคืนให้คุณหากคุณปฏิเสธที่จะใส่ค่าของคุณเองเรียกว่า "ไม่มี" และเป็นประเภทพิเศษที่ไม่มีความหมายหรือเป็นโมฆะ

ใน python เราเริ่มกำหนดฟังก์ชันด้วย "def" และโดยทั่วไป แต่ไม่จำเป็นต้องลงท้ายฟังก์ชันด้วย "return"

ฟังก์ชันของตัวแปร x แสดงเป็น f (x) ฟังก์ชั่นนี้ทำอะไร? สมมติว่าฟังก์ชันนี้เพิ่ม 2 เป็น x ดังนั้น f (x) = 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" ข้าง return แปลว่า (x + 2) ไม่ใช่ x ของ "A_function (x)"

ฉันเดาว่าจากตัวอย่างง่ายๆนี้คุณจะเข้าใจความหมายของคำสั่ง return

return หมายความว่า "ส่งออกค่านี้จากฟังก์ชันนี้"

print หมายความว่า "ส่งค่านี้ไปที่ (โดยทั่วไป) stdout"

ใน Python REPL การส่งคืนฟังก์ชันจะถูกส่งออกไปยังหน้าจอตามค่าเริ่มต้น (ซึ่งไม่เหมือนกับการพิมพ์)

นี่คือตัวอย่างการพิมพ์:

>>> 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)

หลังจากคำสั่งเงื่อนไขถูกเรียกใช้ret()ฟังก์ชันจะถูกยกเลิกเนื่องจากreturn temp(บรรทัดที่ 4) ดังนั้นจึงprint("return statement")ไม่ได้รับการดำเนินการ

เอาท์พุต:

two digits   

รหัสนี้จะปรากฏหลังงบเงื่อนไขหรือสถานที่การไหลของการควบคุมไม่สามารถเข้าถึงเป็นรหัสที่ตายแล้ว

การส่งคืนค่า
ในบรรทัดหมายเลข 4 และ 8 คำสั่ง return จะถูกใช้เพื่อส่งคืนค่าของตัวแปรชั่วคราวหลังจากที่เงื่อนไขถูกดำเนินการแล้ว

เพื่อดึงความแตกต่างระหว่างการพิมพ์และการส่งคืน :

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'

เพียงเพื่อเพิ่มคำตอบที่ยอดเยี่ยมของ @Nathan Hughes:

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!

ดูส่วนCode Styleของ Python Guide สำหรับคำแนะนำเพิ่มเติมเกี่ยวกับวิธีการใช้งานreturnนี้

ความแตกต่างระหว่าง "return" และ "print" สามารถพบได้ในตัวอย่างต่อไปนี้:

กลับ:

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

ดังนั้นโค้ดง่ายๆนี้จึงนับจำนวนเหตุการณ์ที่เกิดขึ้น ตำแหน่งของผลตอบแทนมีความสำคัญ จะบอกโปรแกรมของคุณว่าคุณต้องการค่าไหน ดังนั้นเมื่อคุณพิมพ์คุณจะส่งผลลัพธ์ไปที่หน้าจอ เมื่อคุณกลับมาคุณบอกค่าที่จะไปที่ไหนสักแห่ง ในกรณีนี้คุณจะเห็นว่า count = 0 ถูกเยื้องกับ return - เราต้องการให้ค่า (count + 1) แทนที่ 0 หากคุณพยายามทำตามตรรกะของโค้ดเมื่อคุณเยื้องคำสั่ง return ออกไปผลลัพธ์จะเป็น 1 เสมอ เพราะเราจะไม่บอกให้การนับเริ่มต้นเปลี่ยนแปลง ฉันหวังว่าฉันจะทำให้ถูกต้อง โอ้และผลตอบแทนอยู่ในฟังก์ชันเสมอ

returnเป็นส่วนหนึ่งของนิยามฟังก์ชันในขณะที่printส่งข้อความไปยังเอาต์พุตมาตรฐาน (โดยปกติคือคอนโซล)

ฟังก์ชันคือโพรซีเดอร์ที่ยอมรับพารามิเตอร์และส่งคืนค่า สำหรับหลังขณะที่อดีตจะทำกับreturndef

ตัวอย่าง:

def timestwo(x):
    return x*2

สิ่งที่ดีที่สุดเกี่ยวกับ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สิ่งสำคัญที่ต้องสังเกตคือบรรทัดสุดท้ายที่เราพูดว่า return a + b(in add) สิ่งนี้มีดังต่อไปนี้:

1. ฟังก์ชันของเราถูกเรียกด้วยสองอาร์กิวเมนต์: aและb.
2. เราพิมพ์สิ่งที่ฟังก์ชันของเราทำในกรณีนี้คือ "ADDING"
3. จากนั้นเราก็บอกให้ Python ทำอะไรบางอย่างย้อนกลับ: เราส่งคืนการเพิ่มของa + b. คุณอาจจะพูดแบบนี้ว่า "ฉันจะเพิ่มaและbจากนั้นกลับมาพวกเขา."
4. Python เพิ่มตัวเลขสองตัว จากนั้นเมื่อฟังก์ชันสิ้นสุดบรรทัดใด ๆ ที่รันก็จะสามารถกำหนดa + bผลลัพธ์นี้ให้กับตัวแปรได้

returnควรใช้สำหรับฟังก์ชัน / วิธีการเรียกซ้ำหรือคุณต้องการใช้ค่าที่ส่งคืนสำหรับแอปพลิเคชันในภายหลังในอัลกอริทึมของคุณ

print ควรใช้เมื่อคุณต้องการแสดงผลลัพธ์ที่มีความหมายและเป็นที่ต้องการแก่ผู้ใช้และคุณไม่ต้องการเกะกะหน้าจอด้วยผลลัพธ์ระดับกลางที่ผู้ใช้ไม่สนใจแม้ว่าจะมีประโยชน์สำหรับการดีบักโค้ดของคุณก็ตาม

รหัสต่อไปนี้แสดงวิธีการใช้งานreturnและprintถูกต้อง:

def fact(x):
    if x < 2:
        return 1
    return x * fact(x - 1)

print(fact(5))

คำอธิบายนี้เป็นจริงสำหรับภาษาโปรแกรมทั้งหมดไม่ใช่เฉพาะภาษาไพธ อน