ได้เวลาพูดถึงฟังก์ชั่นแล้ว
นี่คือสิ่งที่น่าสนใจจริงๆ เพราะจนถึงตอนนี้ เราได้เห็นฟังก์ชันเขียนฟังก์ชันต่างๆ
เช่น การพิมพ์ เช่น รายการแท่ง
เรายังเห็นฟังก์ชันอินพุตเพื่อรับอินพุตของสิ่งที่ผู้ใช้ประเภทใดและอนุญาตให้เราดำเนินการกับประเภทข้อมูลของเรา
แต่พลังที่แท้จริงเกิดขึ้นเมื่อเราสามารถเริ่มสร้างฟังก์ชันของเราเองได้
ถูกตัอง.
เราไม่ได้จำกัดแค่สิ่งที่ Python มอบให้เราเท่านั้น
เราสามารถสร้างฟังก์ชันของเราเองและใช้ในโปรแกรมของเราได้
มาเรียนรู้วิธีการทำกัน
วิธีที่เราสร้างฟังก์ชันใน Python และฟังก์ชันมีอยู่ในภาษาโปรแกรมทั้งหมด
พวกเขาสำคัญมาก
หากเราทำ de f ที่ช่วยให้ล่าม python รู้ว่าเรากำลังจะกำหนดฟังก์ชัน
Def ย่อมาจากคำนิยาม
ล่ามจะบอกว่า เอาล่ะ พวกเขากำลังกำหนดฟังก์ชัน
จะทำหน้าที่อะไร?
เราสามารถสร้างอะไรก็ได้ที่เราต้องการ
เราใช้กรณีการตั้งชื่อเดียวกันกับที่เราทำกับตัวแปรเพื่อกำหนดฟังก์ชันของเรา
มาสร้างฟังก์ชันกันอีกครั้ง
เราจะเรียกมันว่า Say Hello
แค่ตัวแปรที่ฉันสร้างขึ้น
แต่คราวนี้เป็นฟังก์ชันเพราะเราใช้ def คีย์เวิร์ดในนี้และกล่าวสวัสดี
นอกจากนี้เรายังเพิ่มวงเล็บเพื่อให้ล่ามรู้ว่านี่คือสิ่งที่เราจะดำเนินการหรือจะดำเนินการกับประเภทข้อมูล
เราใช้โคลอนและภายในบล็อคของโค้ดนี้ เราสามารถพูดได้ว่าพิมพ์
สวัสดี
และนั่นคือหน้าที่
ถ้าฉันคลิกเรียกใช้
อืม.
ไม่มีอะไรเกิดขึ้น.
ทำไมถึงเป็นอย่างนั้น?
เราได้สร้างฟังก์ชัน say hello ขึ้นแล้ว และตอนนี้ก็อยู่ในหน่วยความจำในเครื่องของเราแล้ว
อย่างไรก็ตาม เพื่อที่จะใช้ฟังก์ชัน จำไว้ว่า เช่นเดียวกับที่เราใช้ฟังก์ชันการพิมพ์ เราต้องเรียกมันด้วยวงเล็บ
ดังนั้น หลังจากที่เรากำหนดฟังก์ชันแล้ว เราจะกล่าวสวัสดี
และคุณสังเกตเห็นว่าคลื่นของฉันเป็นอย่างไร
ทันทีที่ฉันพูด
จริงๆแล้วให้คำสั่ง say hello กับฉันเพราะฉันสร้างมันขึ้นมา
แล้วคุณเห็นกล่องสีม่วงนี้ซึ่งแสดงว่ามันเป็นฟังก์ชันหรือไม่?
ตอนนี้เรามีให้ใช้งานได้แล้ว เหมือนกับที่เรามีฟังก์ชันการพิมพ์ให้เราใช้
ดังนั้นถ้าฉันทักทายและเรียกใช้ด้วยวงเล็บแล้วคลิกเรียกใช้
ฉันเข้าใจ.
สวัสดี?
มันเจ๋งแค่ไหน?
จะเกิดอะไรขึ้นถ้าฉันเรียกใช้โดยไม่มีวงเล็บและคลิกเรียกใช้
ไม่มีอะไรเกิดขึ้น เพราะจำไว้ว่า เพื่อให้เราดำเนินการได้ เราต้องแจ้งให้ล่ามทราบ
เฮ้ ฉันอยากวิ่ง
พูดสวัสดี.
ฟังก์ชันเหตุผลมีพลังมากก็เพราะหลักการที่เราพูดถึง
ถูกต้อง.
แนวคิดของ DRI ซึ่งย่อมาจาก Don'tทำซ้ำตัวเอง
ฟังก์ชันมีประโยชน์จริง ๆ เมื่อคุณมีสิ่งที่คุณต้องการทำซ้ำแล้วซ้ำอีก
ตัวอย่างเช่น ฟังก์ชันการพิมพ์ เราใช้บ่อยมาก
ลองนึกภาพว่าถ้าเราต้องเขียนโค้ดเองทุกครั้งและบอกว่าฟังก์ชันการพิมพ์ทำหน้าที่อะไร
โชคดีที่ Python ให้งานพิมพ์แก่เราเพราะเป็นเครื่องมือที่มีประโยชน์
แต่ถ้าในโปรแกรมของเรา เราต้องการกล่าวทักทายหลายครั้ง และคุณสามารถจินตนาการได้ว่าสิ่งนี้ซับซ้อนกว่านั้นมาก
อาจเป็นโค้ดสิบบรรทัด
แทนที่จะเขียนโค้ดสิบบรรทัดนั้นซ้ำแล้วซ้ำเล่า ฉันสามารถกำหนดให้มันเป็นฟังก์ชันและใช้งานได้ทุกที่ที่ต้องการในโปรแกรมของฉัน
ตัวอย่างเช่น จำสิ่งนี้ไว้เมื่อเรามีรูปภาพและเราพิมพ์ต้นคริสต์มาส
ลองนึกภาพว่าถ้าเราต้องการเรียกใช้สิ่งนี้หลายครั้ง
ในการทำเช่นนั้น ฉันจะคัดลอกและวางรหัสนี้
แล้วเพิ่มใหม่อีกครั้ง
และถ้าฉันคลิกเรียกใช้
ตอนนี้ฉันมีต้นคริสต์มาสสองต้น แต่นั่นเป็นรหัส 26 บรรทัดนั้น
ฉันเพิ่งคัดลอกและวางสิ่งเดียวกันซ้ำแล้วซ้ำอีกด้วยฟังก์ชัน
เราสามารถทำสิ่งนี้ได้
ฉันสามารถพูด.
กำหนดการแสดง
ต้นไม้.
โคลินและตอนนี้เรามีฟังก์ชันแล้ว
แต่จำการเยื้องใน Python ได้ไหม?
การเยื้องเป็นสิ่งสำคัญ
เรามีเซมิโคลอน เรากำลังกำหนดฟังก์ชัน
ดังนั้นเราจึงต้องสร้างบล็อคโค้ดนั้นภายใน โดยพูดว่า เฮ้ อะไรก็ตามที่เยื้องที่นี่ นั่นเป็นส่วนหนึ่งของฟังก์ชันนี้
ตอนนี้เรามีต้นไม้แสดงแล้ว ลองดูสิ
ฉันสามารถพูดได้ โชว์ต้นไม้ เรียกใช้อีกครั้ง
อาจจะลองเรียกใช้สามครั้ง
ถ้าฉันคลิกเรียกใช้
มันเจ๋งแค่ไหน?
ฉันสามารถทำสิ่งเดียวกันซ้ำแล้วซ้ำเล่าได้เพียงแค่เรียกใช้ฟังก์ชันนี้
และนั่นคือพลังของฟังก์ชัน
ฟังก์ชันช่วยให้เราเก็บโค้ดของเราไว้ได้
เราไม่ทำซ้ำตัวเองและนำสิ่งต่าง ๆ ที่เครื่องของเราสามารถทำได้ซ้ำแล้วซ้ำอีก
และความสวยงามก็คือสิ่งนี้ยังคงเป็นความทรงจำสำหรับเรา
ดังนั้น Tree จึงมีความหมายต่อโปรแกรมนี้เพราะเราสร้างมันขึ้นมา
ดังนั้นเราจึงมีการดำเนินการของเราเองที่เราสามารถทำได้
จะเกิดอะไรขึ้นถ้าฉันย้าย
แสดงต้นไม้ที่นี่ไปด้านบน
ถ้าฉันเรียกใช้สิ่งนี้
ฉันจะได้ชื่อแอร์
ชื่อของเธอ.
ไม่ได้กำหนดการแสดงต้นไม้
ทำไมถึงเป็นอย่างนั้น?
เพราะล่ามของเราพูดทีละบรรทัด
อย่างแรกมันบอกว่า เอาล่ะ รูปภาพเท่ากับค่านี้
แล้วขึ้นบรรทัดที่ 11 ว่า วิ่งโชว์ต้นไม้
แต่เรายังไม่ได้กำหนดโครงสร้างการแสดง ดังนั้นตัวแปล Python จะเกิดข้อผิดพลาดและพูดว่า เฮ้ ฉันไม่รู้ว่าต้นไม้แสดงคืออะไร
คุณกำลังพูดถึงอะไร
แต่ด้วยฟังก์ชัน เราต้องแน่ใจว่าเรากำหนดฟังก์ชันไว้ที่จุดเริ่มต้น
เพื่อให้ล่าม Python พูดว่า เอาล่ะ
แสดงต้นไม้ตอนนี้หมายความว่านี่
ฉันจะไม่เรียกใช้มัน
ฉันจะยังไม่ใช้มัน
ฉันแค่จะเก็บไว้ในความทรงจำ
และในที่สุดเมื่อฉันเจอ Show Tree ฉันจะรู้ว่ามันมีความหมายบางอย่าง
ฉันจะคว้ามันจากหน่วยความจำโดยใช้ show tree จากนั้นฉันจะเรียกใช้โดยใช้วงเล็บ
ตัวอย่างเช่น ถ้าฉันพิมพ์ show tree โดยไม่มีวงเล็บ ถ้าฉันคลิก run
คุณเห็นว่าฉันได้รับฟังก์ชั่นแสดงต้นไม้ที่ตำแหน่งนี้
นี่เป็นเพียงสถานที่ในความทรงจำ
นี่คือชั้นหนังสือที่เราจัดเก็บที่แสดงฟังก์ชันต้นไม้
เยี่ยมมาก
และฟังก์ชันต่างๆ ก็เป็นแนวคิดที่สำคัญและทรงพลังในการเขียนโปรแกรม
และในวิดีโอหน้า เราจะขยายเรื่องนี้และสำรวจให้มากขึ้นอีกนิด
เจอกันใหม่ตอนหน้าค่ะ