ยินดีต้อนรับกลับ.
ในวิดีโอนี้ ฉันต้องการพูดคุยเกี่ยวกับแนวคิดที่สำคัญซึ่งก็คือการกลับมา
เป็นคีย์เวิร์ดในภาษา Python ที่เราจะได้เห็นกันมากเมื่อทำงานกับฟังก์ชัน
มาดูกันเลย
ถ้าฉันสมมติว่าฉันต้องการสร้างฟังก์ชันที่เรียกว่า sum ซึ่งมีอยู่แล้วใน Python แต่เราจะสร้างขึ้นเองและฉันจะบอกว่าอันดับหนึ่งเป็นอันดับหนึ่ง
และข้อที่สอง ฟังก์ชันผลรวมของเราจะบวก num หนึ่ง บวก num 2 ฟังก์ชันที่ดีและเรียบง่าย
ตอนนี้ถ้าฉันวิ่งด้วยหมายเลขสี่และห้า เดาว่าจะเกิดอะไรขึ้น?
ฉันจะวิ่งชน
และไม่มีอะไรเกิดขึ้น ซึ่งฉันหมายถึง อาจไม่น่าแปลกใจสำหรับคุณ เพราะเราไม่ได้พิมพ์อะไรเลย
ถูกต้อง.
แต่ถ้าฉันเรียกใช้งานพิมพ์ที่นี่
การเปลี่ยนแปลงนี้
มาดูกัน.
อืม.
ฉันไม่ได้รับ
นั่นคือสิ่งที่คุณคาดหวัง?
และเราไม่เคยเห็นมาก่อนใช่ไหม?
ฉันหมายถึง จำได้ว่าตอนที่เรามีรายชื่อ สมมติว่าหนึ่ง สอง สาม แล้วเราก็ทำอะไรที่ชัดเจนในนั้น
ใน ED ของเรา
มันให้ลูกศรเล็ก ๆ นี้แก่เราและบอกว่าไม่มี
และเราได้พูดถึงแนวคิดของ on list บางอย่างเช่น clear เปลี่ยนแปลงรายการจริง และล้างทุกอย่างและล้างรายการ
แต่จะไม่ส่งกลับรายการใหม่
มันเพียงแค่แก้ไขรายการที่มีอยู่ แต่กลับไม่มีรายการกลับมาให้เรา
ฟังก์ชั่นก็เป็นเช่นนั้น
พวกเขาต้องส่งคืนบางสิ่งเสมอ และเมื่อพวกเขาไม่ส่งคืนสิ่งใดที่เหมือนกับว่าไม่มีคีย์เวิร์ดส่งคืนที่นี่
มันจะไม่ส่งคืนโดยอัตโนมัติ
ดังนั้นถ้าเราไม่มีสิ่งที่เหมือนกลับมาที่นี่ มันก็จะไม่คืนอะไรเลย
แต่ถ้าเราบวก return มันจะบอกว่าทันทีที่เราไปถึงบรรทัดที่สอง
เฮ้.
ฉันต้องการให้คุณออกจากฟังก์ชันนี้
และเมื่อคุณออกจากฟังก์ชันนี้ ฉันต้องการให้คุณส่งคืนค่าที่พจน์นี้ให้เรา
ถ้าฉันคลิกเรียกใช้
ฉันได้รับเก้า?
ถ้าเราเปลี่ยนเป็นสิบบวกห้า เราจะได้ 15
และนี่เป็นกฎทั่วไปที่ดีที่มีฟังก์ชัน เพราะฟังก์ชันสามารถทำงานสองอย่างได้ ใช่แล้ว
หนึ่ง มันสามารถคืนบางสิ่งได้
ดังนั้น ที่ส่วนท้ายของฟังก์ชัน อะไรก็ตาม หลังจากที่ฟังก์ชันเริ่มทำงาน เราจะคืนค่าบางอย่างที่ไม่มีหรือค่าประเภทใดประเภทหนึ่ง
หรือเราสามารถมีฟังก์ชันที่ไม่ส่งคืนสิ่งใดๆ ก็ได้แต่อาจปรับเปลี่ยนได้ บางสิ่งบางอย่าง.
ตัวอย่างเช่น ฉันสามารถพิมพ์
สวัสดี.
และถ้าฉันได้วิ่งมาที่นี่
ฉันไม่ส่งคืนเพราะฉันไม่มีคำสั่งส่งคืนนั้น
อย่างไรก็ตาม ฟังก์ชันของฉันทำบางสิ่งที่ปรับเปลี่ยน
หน้าตาของข้อความนี้ใช่ไหม?
มันพิมพ์สวัสดีสำหรับเรา
ดังนั้นฟังก์ชันจะแก้ไขบางสิ่งในโปรแกรมของเราหรือส่งคืนบางสิ่ง
และนี่คือหัวข้อที่ค่อนข้างสูงที่เราจะพูดถึงในภายหลังเมื่อเราพูดถึงการเขียนโปรแกรมเชิงฟังก์ชัน
แต่กฎทั่วไปที่ดีของฟังก์ชันคือฟังก์ชันนี้ควรทำสิ่งหนึ่งได้ดีจริงๆ
และโดยปกติแล้วฟังก์ชันควรส่งคืนบางสิ่ง
นี่ไม่ได้หมายความว่าฟังก์ชันใด ๆ ที่อาจทำหลายสิ่งหลายอย่างหรือฟังก์ชันใด ๆ ที่ไม่ส่งคืนบางสิ่งนั้นไม่ดี
แต่โดยทั่วไปแล้ว แนวปฏิบัติที่ดีคือการทำให้โค้ดของคุณเรียบง่ายและอ่านได้โดยมีกฎสองข้อนี้
ตัวอย่างเช่น ที่นี่ ถ้าฉันมีการพิมพ์และการบวก ฟังก์ชันนี้ทำหลายอย่าง
มันกังวลเกี่ยวกับการพิมพ์และก็กังวลเกี่ยวกับบางสิ่งบางอย่างด้วย
และคำนิยาม
ฟังก์ชันนี้เรียกว่าผลรวม
ฉันหมายความว่าถ้าฉันไม่รู้หรือไม่เห็นสิ่งนี้และทั้งหมดที่ฉันทำคือเรียกใช้
ฉันคิดว่าการพิมพ์สูงจะน่าประหลาดใจเพราะชื่อไม่ได้อธิบายสิ่งที่มันทำจริงๆ
ฉันหมายความว่าฉันคาดหวังว่าสิ่งนี้จะสรุปได้
ทำไมโปรแกรมของฉันถึงพูดว่าสวัสดี
ดังนั้นเราจึงต้องการให้แน่ใจว่าฟังก์ชันของเราทำสิ่งหนึ่งและสิ่งเดียวเท่านั้นได้ดีจริงๆ เพราะอย่างที่เราจะเห็นในภายหลัง
เราสามารถรวมและเรียกใช้ฟังก์ชันต่างๆ ร่วมกันได้
แล้วเรายังต้องการให้แน่ใจว่าเราคืนค่าบางอย่าง เพราะวิธีนี้ สิ่งที่เราทำได้คือเราสามารถกำหนดค่าที่ส่งคืนนี้ให้กับตัวแปรได้
ตัวอย่างเช่น ฉันสามารถพูดได้ว่าผลรวมเท่ากับผลรวมสิบ
ห้า.
และเนื่องจากฟังก์ชันนี้ส่งคืนบางสิ่ง และเมื่อเสร็จสิ้น การรันจะมีค่าเป็น 15
นั่นก็เหมือนกับที่เราทำที่นี่
และนี่คือส่วนเด็ด
ตอนนี้ฉันสามารถวิ่งได้ประมาณสิบบวก
ทีนี้มาผ่านเรื่องนี้กันทีละคน
ฉันกำหนดฟังก์ชันของฉัน ตัวแปลไพ ธ อนจะพูดว่า เอาล่ะ ฉันรู้ว่าบางอย่างคืออะไร
ตอนนี้คุณได้กำหนดมันแล้ว
ฉันจะเก็บมันไว้ในความทรงจำ
มันจะดำเนินต่อไปเรื่อยๆ จนถึงบรรทัดที่เจ็ด และมันจะบอกว่า เฮ้ ฉันต้องการผลรวมของตัวแปร
และฉันต้องการให้ตัวแปรทั้งหมดนั้นเท่ากับสิบห้า
และก่อนที่เราจะกำหนดอะไรให้กับ Total python ล่ามจะพูดบ้าง
อะไรอีก.
โอ้ ฉันจำได้ มันอยู่ในหน่วยความจำ OC ในบางส่วน ฉันจะให้ข้อโต้แย้งสิบห้าข้อ
มันจะไปรันฟังก์ชันนั้น
ทันทีที่เราจบวงเล็บปิดนี้ มันจะเข้าสู่ผลรวม
จะบอกว่า เฮ้ หมายเลขหนึ่งจะเท่ากับสิบ เฮ้ หมายเลขสองจะเท่ากับห้า
ตอนนี้เราไปที่บรรทัดที่สอง และมันบอกว่า เฮ้ ผมอยากให้คุณบวกสิบบวกห้า เพราะผมรู้ว่าตัวแปรเหล่านี้คืออะไร
แล้วพอคุณทำเสร็จแล้วนี่กลายเป็น 15 ฉันอยากให้คุณกลับมา
ดังนั้น ล่าม Python ในที่สุด เมื่อเสร็จสิ้นการเรียกบางคนจะบอกว่า เฮ้ กำหนดค่า
15 ให้กับผลรวมของตัวแปร แล้วมันจะไปที่บรรทัดถัดไป
เฮ้ ฉันต้องการพิมพ์อะไรบางอย่าง
คุณต้องการพิมพ์อะไร
ดีฉันต้องการพิมพ์นี้
มันจะพูดว่า เฮ้ อะไรนะ?
ฉันรู้ว่าบางอย่างคืออะไร
ฉันมีมันในความทรงจำ
แล้วอีกอย่าง มันจะบอกว่าสิบ
แล้วอาร์กิวเมนต์ต่อไปจะเป็นผลรวม
เฮ้ มารวมกันเถอะ
ให้ฉันเข้าไปในความทรงจำแล้วหาว่า โอ้ นี่มัน 15 แล้ว
มันก็เหมือนกับว่า 15
และนี่คือพลังของฟังก์ชันใช่ไหม?
ฉันสามารถส่งคืนสิ่งต่าง ๆ และกำหนดให้กับตัวแปรและเรียกพวกมันแบบนี้
และผมสามารถรันมันต่อไปได้ ถ้าผมอยากจะทำ ถ้าผมอยากทำให้มันง่ายกว่านี้ ผมสามารถไปบ้าง แทนที่จะเป็นจำนวนรวมทั้งหมดจะอยู่ตรงนี้
และดูนั่นสิ
ตอนนี้ฉันมีทุกอย่างในบรรทัดเดียวและถ้าฉันคลิกเรียกใช้
อีกครั้ง.
มันยังคงทำงาน
ตกลง.
แต่ถ้าเราทำอะไรแบบนี้ล่ะ?
ถ้าฉันพูดว่า define Some แล้วฉันจะพูดว่า "definition" ในที่นี้ อีกอันหนึ่ง
ฟังก์ชัน และฟังก์ชันนี้ใช้หมายเลขหนึ่งและหมายเลขสอง
และที่นี่ ในที่สุดเราก็กลับมา อันดับหนึ่ง
และอันดับสอง
อืม.
มาทดสอบกัน
คุณคิดว่าจะเกิดอะไรขึ้น?
อย่างแรก สมมุติว่าผลรวมเท่ากับสิบบวก 20
แล้วฉันจะพิมพ์ทั้งหมด
ถ้าฉันคลิกเรียกใช้
ฉันไม่ได้รับ
ตอนนี้.
ทำไมถึงเป็นอย่างนั้น?
และนี่ควรจะชัดเจนสำหรับคุณ เพราะในที่นี้ ฉันกำลังพูดว่า เฮ้ ฉันต้องการให้คุณนิยามบางอย่าง แล้วเราจะทำอะไรกับฟังก์ชันนี้?
ข้างในนี้ฉันจะกำหนดฟังก์ชันอื่น แต่คำสั่ง return นี้ทำงานไม่ถูกต้อง
เพราะทั้งหมดที่เรากำลังทำอยู่ในบล็อกนี้ บล็อกโค้ดนี้
คือส่วนนี้
เรากำลังกำหนดฟังก์ชัน แต่ไม่เคยเรียกใช้ฟังก์ชันอื่น
ดังนั้นสิ่งนี้จึงไม่มีผลตอบแทน
และเราสูญเสียความสามารถในการเรียกฟังก์ชันนี้
แล้วเราจะแก้ปัญหานี้ได้อย่างไร?
วิธีหนึ่งคือการกลับมาใช่ไหม?
สุดท้ายนี้ เราต้องแน่ใจว่าการเยื้องนั้นถูกต้อง และเราจะคืนค่า func
อื่น
ลองเพิ่มผลตอบแทนและดูว่าเกิดอะไรขึ้นที่นี่
ถ้าฉันคลิกเรียกใช้
เอาล่ะ ฉันได้รับฟังก์ชันนี้แล้ว
ดังนั้น Total จะเท่ากับฟังก์ชันนี้ที่เราส่งคืน และมันอยู่ในหน่วยความจำ
ตกลง.
แต่ฉันไม่ได้รับผลลัพธ์ที่ฉันต้องการ
ถูกต้อง.
และทำไมถึงเป็นอย่างนั้น?
เพราะ.
เราไม่ได้เรียกฟังก์ชันนี้
มีสองสามวิธีที่เราทำได้
เราสามารถให้พารามิเตอร์หรืออาร์กิวเมนต์ในที่นี่ก็ได้
สมมติว่า 1020 และถ้าฉันคลิกเรียกใช้
ฉันได้ 30 หรือถ้าเราต้องการเก็บสิ่งที่เราให้ไว้ที่นี่ ฉันสามารถพูดได้ว่า func อื่น
ดังนั้นถ้าเราให้หมายเลขหนึ่งและสอง และผมคลิกเรียกใช้
เฮ้ ดูนั่นสิ
ฉันได้รับ 30
ตอนนี้วิดีโอนี้ที่คุณอาจต้องดูซ้ำแล้วซ้ำอีก เพราะมันช่วยยืดความคิดของคุณได้เล็กน้อย
และบอกตามตรงว่าฟังก์ชั่นนี้ไม่ค่อยดีเท่าไหร่เพราะว่ามันดี มันสับสนมาก
หน้าที่ของคุณควรเข้าใจง่าย
เราจึงอาจต้องการเปลี่ยนสิ่งนี้เล็กน้อย, บางทีแทนที่จะมีชื่อพารามิเตอร์เหมือนกัน
เพียงเพื่อชี้แจง
บางทีเราสามารถพูดได้หนึ่งและสอง
แล้วที่นี่เราทำกับหนึ่งบวกและสองเพื่อชี้แจงว่าเมื่อเรากลับมา ฟังก์ชันอื่นนี้ ฉันกำลังใช้พารามิเตอร์
นัมเบอร์ 1 และหมายเลข 2 ที่เราเรียกที่นี่
เพราะนิยามของฟังก์ชันนี้ไม่ได้สนใจว่าสิ่งเหล่านี้คืออะไร
มันสนใจเฉพาะเมื่อมีการเรียกฟังก์ชันอื่น
ทีนี้ ถ้าคุณต้องหยุดวิดีโอชั่วคราวแล้วดูนี่ และอาจฝึกมันสักหน่อย นั่นก็เข้าใจได้ทั้งหมด
แต่ฉันต้องการแสดงให้คุณเห็นถึงพลังแห่งการกลับมา
คุณสามารถมีฟังก์ชันที่ซ้อนกันได้เหมือนกับที่คุณทำกับเงื่อนไขต่างๆ แต่คุณต้องระวังว่าฟังก์ชันของคุณจะส่งคืนค่าบางอย่าง
มิฉะนั้น ฟังก์ชันจะไม่ส่งคืน
และโดยมากแล้ว คุณจะต้องการคืนค่าบางอย่างจากฟังก์ชัน เพื่อให้เราทำสิ่งนี้ได้
โดยที่เรากำหนดให้ตัวแปรนั้นใช้ในภายหลังในโปรแกรมของเรา
เจอกันใหม่ตอนหน้าค่ะ
ลาก่อน.
สิ่งสุดท้าย.
คีย์เวิร์ด return ออกจากฟังก์ชันโดยอัตโนมัติ ดังนั้นในที่นี้ ถ้าฉันเพิ่มโค้ดอื่น เช่น การพิมพ์
สวัสดี
หรืออาจจะได้กลับมาห้าที่นี่
เห็นว่ายังใช้ได้อยู่
แต่ถ้าฉันเรียกใช้สิ่งนี้
ฉันยังได้ 30 เพราะล่ามไม่เคยไปถึงบรรทัดที่ 5 และ 6 เพราะทันทีที่เราส่งคืนบางสิ่งจากฟังก์ชัน
มันก็จะออกจากฟังก์ชันนั้น
และเหตุผลที่ส่วนนี้ไม่ออกจากฟังก์ชันก็เพราะว่า จำไว้ว่า เรากำลังกำหนดภายในฟังก์ชันนี้
ดังนั้นเราจึงไม่ได้ใช้งานส่วนนี้จริงๆ
เราแค่พูดว่า เฮ้ เมื่อเราเห็นฟังก์ชันอื่นในโค้ดของเรา เรารู้ว่ามันคืออะไร
แต่เราจะไม่รันมัน
มันจะออกมาเป็นแบบนี้
และทันทีที่เห็นคำสั่ง return เมื่อมันถูกเรียก มันจะบอกว่า
เอาล่ะ ผมจะออกจากฟังก์ชันนี้ด้วยค่านี้
แค่หัวขึ้นเล็กน้อย