(ล่าม) ฮัลโหลครับ
ฝั่งล่ามไหมครับ ผม
(อาจารย์สุธิรา) ได้ยินค่ะ (ล่าม) โอเคครับ
(อาจารย์สุธิรา) สวัสดีค่ะ พี่ล่ามไม่ได้ยินเรานะ
(ล่าม) ได้ยินครับ ได้ยินครับ
(อาจารย์สุธิรา) ได้ยินไหม นึกว่าไม่ได้ยิน
นะคะ
สำหรับวันนี้นะคะ ในสัปดาห์นี้จะเป็น
เรื่องเกี่ยวกับ
ฟังก์ชันนะ
ใน Python
เราจะต้องมาเรียนเบื้องต้นนี่ ก็คือต้องมารู้จัก
สิ่งที่เรียกว่า ฟังก์ชันก่อนนะคะ
นะคะ หัวข้อที่
เราจะเรียนในสัปาดาห์นี้นะคะ จะเป็น
หัวข้อสุดท้ายของปีนี้
เทอมนี้นะคะ ภาคเรียนนี้ ก็คือฟังก์ชัน
วันนี้เราจะพูดถึงการ
นะคะ การเรียกใช้งาน
แล้วก็พูดถึง
Default Argument Values แล้วก็ Keyword Argument
นะคะ อ้าวทำไมหน้าจอไม่ขึ้น
อีกแล้ว...
โอเคนะคะ ก่อนอื่น
ก่อนจะรู้วิธีการสร้าง
การเลือกใช้งานนี่ เราก็ต้องรู้ก่อนว่าฟังก์ชันมันคืออะไร นะคะ
คือ ถ้าพูดถึงโดยทั่วไปนะคะ
ก็คือถ้าเราเป็นโปรแกรมเมอร์หรือ
ในวิธีการเขียนโปรแกรมคอมพิวเตอร์นี่ ฟังก์ชันมันจะเป็น
สั่งพิเศษ
ีที่ให้ทำงานเฉพาะสิ่งใดสิ่งหนึ่งนะคะ
ซึ่งแต่เดิมนี่ฟังก์ชันมันจะเป็น
ที่เขาพัฒนาไว้แล้วก็มี แต่ใน Python www.google.com นะคะ
อ
ในส่วนของภาษา python
ฟังก์ชันจะเป็นโค้ด หรือโปรแกรมที่เรา
สร้างด้เองนะคะ
เพื่อเอาไปใช้กับ...
เหมือนตั้งขึ้นมาว่าฟังก์ชันนี้จะตั1
นะคะ เช่น
เหมือนบางครั้งนี่ การคำนวณบางอย่าง
ไม่จำเป็นต้องไปเขียนโค้ดใหม่ทุกครั้ง เราก็เลยสร้างฟังก์ชันไว้เลย
แล้วไปเรียกฟังก์ชันนี้มาเพื่อให้มัน
ทำกาารคำนวณค่านี้ให้อย่างนี้นะคะ นั่นคือจุดประสงค์
จะนำไปใช้ในสิ่งใดสิ่งหนึ่งนะคะ
เป็นการเฉพาะ โดยใน
บอกแล้วว่าในสัปดาห์นี้เราจะสร้าง
ขึ้นมาใช้งานเองนะคะ แล้วเมื่อสร้างเสร็จแล้วนี่
จะต้องรู้ว่า
มันจะต้องเรียกฟังก์ชันที่เราใช้งานนี่จะถูกเรียก
มาใช้โดยวิธีการใด
หรือเรียกใช้อย่างไรนะคะ แล้วก็จะพูดถึง Default Argument
ด้วยว่ามันคืออะไร แล้วก็ Keyword Argument ด้วย
ว่ามันคืออะไร นะคะ ทีนี้ก็จะเริ่มเข้าสู่
กระบวนการที่เราจะต้องทำ
ก็คือเมื่อเราจะทำฟังกชันขึ้นมา
เราจะสร้างมันอย่างไรนะคะ
การสร้างฟังก์ชันใน Python นะคะ
ใน python
เราสามารถสร้างขึ้นเองได้นะคะ โดย
วิธีการนี้นะคะ จะเป็น
ให้นึกถึงว่าเราจะเป็นคนเขียนโค้ด
ที่ที่บอกแล้วว่ามันสามารถ
ทำงานสิ่งใดสิ่งหนึ่งได้
แล้วเอาไปเรียกใช้ซ้ำได้อีกนะคะ จะเรียกว่า
"การนำโค้ดนี้กลับมาใช้" นี้ว่า "Code Reuse"
ใช้ code นี้ซ้ำได้
ถ้าจะทำฟังก์ชันมาใช้งาน มันควรเป็น
ตัวที่เหมือน
สามารถเรียกใช้ได้บ่อย ๆ เช่น สมมตินะคะ
เราจะหาค่า vad นี่
คือ ถ้ามาเขียนโค้ด เราต้องมานั่งเขียนว่า Vat เกิดจากการ
ที่เอา
7 เปอร์เซ็นต์น่ะค่ะ Vat ก็คือ 7 เปอร์เซ็นต์ใช่ไหมคะ
การที่เอาราคาสินค้ามาคูณกับ
ปริมาณที่ 7 เปอร์เซ็นต์เท่ากับเท่าไหร่ แล้วจะทำอย่างไร
เราจะให้รู้ว่าตัวนี้เป็นค่า Vat เราก็อาจจะ
สร้างฟังก์ชันสำหรับการคิด Vat ขึ้นมาอย่างนี้
นะคะ แล้วพอครั้งหน้าจะใช้ก็
เอาไปใช้ได้ หรืออย่างอื่น หรือคนอื่นจะเอาไปใช้ได้
เมื่อรู้ว่าแต่ต้องรู้ด้วยนะว่า
มีฟังก์ชันนี้อยู่ อย่างนี้นะคะ ทีนี้
ขั้นตอนในการสร้างนะคะ
ก็คือมันจะมีรูปแบบ เราจะต้องเขียนโค้ด
น่ะค่ะ เขียนโค้ดให้ฟังก์ชันเราโดยตามรูปแบบ
ในที่เห็นนะคะ จะต้องมีคำว่า "def"
de
นั่นก็คือการประกาศตัวแปรนะคะ
บอกให้รู้ว่านี่นะ ฉันจะประกาศ
จะประกาศค่า ประกาศฟังก์ชัน ไม่ใช่ประกาศตัวแปร พูดผิด
แล้วตามด้วย function_name
เราต้องพิมพ์ d-e-f พิมพ์ด้วย
ตัวเล็กเสมอ ถึงได้ทำเป็นสีแดง
ให้เห็นว่าคำว่า def นะคะ
ตัวเล็กเท่านั้นนะคะ ไม่ใช่พิมพ์ด้วยตัวพิมพ์ใหญ่
นึกออกนะนะคะ
ก็คือทุกครั้งที่พอจะมีการสร้างฟังก์ชัน
เราต้องพิมพ์คำว่า def
เป็นตัวแรกนะคะ แล้วตามด้วย function_name function_name
นั่นก็คือชื่อ ชื่อ
ของฟังก์ชันที่เราจะไว้เรียกใช้ในครั้งต่อไป เราจะเป็นคนตั้งเอง
ให้นึกถึงฟังก์ชัน Name
ตั้งชื่อให้ตัวแปร แต่อันนี้เป็นการตั้งชื่อ
ฟังก์ชันนี้คือฟังก์ชันอะไรนะคะ เสร็จ
แล้วก็จะมีวงเล็บ พอใส่คำว่า "def" แล้วก็
ใส่ชื่อฟังก์ชันเราต้องต้องพิมพ์วงเล็บ
เสมอนะคะ แต่ถ้าเราพิมพ์ใน Colab ตัววงเล็บนี้จะ
ขึ้นมานะคะ แล้วส่วนข้างในนี่
นะคะ เขาบอกว่ามันเป็นการกำหนดค่า Paramiter
scsaพารามิเตอร์
ถ้าเป็นเขียนโค้ดปกติ มันก็จะหมายถึงตัวแปร
นะคะ แต่ในฟังก์ชันนี่เราจะ
เรียกว่า "พารามิเตอร์" เพื่อไว้สำหรับ
อะไรล่ะ เขาเรียก
นี่ เขาบอกว่าพารามิเตอร์ของฟังก์ชันนี่
มีจำนวนเท่าไรก็ได้ ก็คือในฟังก์ชันนี้
เราจะมีการเก็บค่าของอะไรบ้าง
พารามิเตอร์ตัวนั้นก็จะเป็นตัวเก็บให้เรา
สมมตินะคะ สมมติเราต้องการตำนวณหาค่า
พื้นที่
วงกลมอย่างนี้นะคะ ค่าพารามิเตอร์ที่จะเก็บก็อาจจะมี
ค่าของรัศมีวงกลม
หรือมีค่าของอะไรนะ
เส้นรอบวงอะไรอย่างนี้เข้ามานะคะ นั่นก็คือ
ค่าพารามิเตอร์ที่เราจะไว้เก็บข้อมูลในฟังก์ชัน
นี้นะคะ เสร็จแล้ว
เมื่อพิมพ์ function_name ใส่ค่าพารามิเตอร์
อะไรเสร็จ เราจะปิดคำสั่ง
การประกาศฟังก์ชันด้วยโคลอนเสมอนะคะ
สังเกตนะคะ เมื่อใดที่
ตัวนั้นจะต้องปิดด้วยเสมอ แล้วขึ้นบรรทัด
ใหม่มันจะเข้าสู่ย่อหน้าใหม่
ตัว statements ในที่นี้หมายถึงคำสั่งอื่น ๆ นะคะ
แล้วเด็ก ๆ สังเกต
ดูนะคะ ว่าในการประกาศฟังก์ชันตัวที่ 1
นะคะ กับตัวที่ 2 ตัวที่ 2
จะมีคำว่า return value return ก็
คือการคืนส่งค่าคืนกลับ
ซึ่งฟังก์ชันที่เราเขียน อาจจะ
เขียนแล้วมี return หรือ
ไม่มีก็ได้นะคะ แต่ที่เขียนให้ดูเป็นตัวอย่างนี่ ให้เห็น
รูปแบบนี้ให้เห็นทั้ง 2 แบบ
เป็นแบบที่ไม่มีการ return ค่า
แต่แบบที่ 2 นี่มี มีการส่งคืน
ค่ากลับ ก็เลยจะมีคำว่า "return value" ก็คือ
เราต้องพิมพ์คำว่า return ด้วย
ตามด้วยค่าที่เราต้องการให้ส่งกลับ เช่น เดี๋ยวดู
ในตัวอย่างจะเห็นชัดนะคะ เดี๋ยวยกตัวอย่าง
แล้วจะมองภาพไม่ออก ซึ่งเขาบอกว่า
ค่าที่ส่งกลับนั้นจะเรียกว่า
นะคะ
ทีนี้เรามาดูตัวอย่างแรกก่อน
เพื่อจะให้เห็นว่าถ้าเราต้องการประกาศ
ตัวแปรแลลไม่มีการ return
ไม่มีคำสั่ง return เพื่อคืนค่านี่ ใน
ตัวอย่างนี้เราจะประกาศตัวแปร
ชื่อ เห็นไหมคะ ตรง def แล้วตามด้วย
hello()
def ก็คือ definition
function_name ซึ่งในที่นี้ตั้งชื่อว่า
ello นะคะ ฟังก์ชัน hello ก็คือ
ฟังก์ชันที่เราต้องใช้เพื่อแสดงคำทักทายออกมานั่นเอง
นะคะ แล้วทีนี้
พอเวลาเรียกใช้ฟังก์ชันนี้นะคะ มันจะสั้น
นึกออกนะ การเขียนโค้ดมันจะสั้น
กว่าที่เราเคยทำ
แล้วตามด้วย พารามิเตอร์หรือ
ที่เราไว้เก็บค่า ก็คือ name นะคะ เสร็จแล้ว ตาม
ด้วย statement ตามด้วยข้อความหรือคำสั่ง
หรือโค้ดอะไรก็แล้วแต่นะคะ ซึ่งในทีนี้เราต้องการให้แสดง
นะคะ แสดงคำทักทาย
ชื่อที่เรารับค่าเข้าไปนี่ หรือพารามิเตอร์ที่เรา
ส่งเข้าไป ก่อนอื่น เด็ก ๆ
เปิด Colab หรือยังคะ เปิด Colab ด้วย
ไปที่ web browser
แล้วเปิดเหมือนเดิมนะคะ พิมพ์
สิ
Colab l-a-b นะคะ พิมพ์ l-a-b
แล้วกด Enter เลย
เพราะสังเกตว่าเว็บไหนที่เราเปิดมันจะ
อัตโนมัติเด็ก ๆ กด Enter ได้เลนย
มันก็จะเข้ามาหน้า
ที่เราใช้งานนะ แล้วก็คลิก
Code นะคะ ลืมไป
อย่าลืมทำอะไรก่อน เข้าสู่ระบบนะ ไม่อย่างนั้นเราจะ
run มันไม่ได้นะคะ เด็ก ๆ อย่าลืม
ลงชื่อเข้าสู่ระบบด้วย Login เข้าไปด้วย
นะคะ
ของเราให้เรียบร้อยด้วย
โอเคนะคะ เสร็จแล้วเราก็เริ่ม
ไปที่เขียน code เหมือนเดิมนะคะ เด็ก ๆ
กดที่คำว่า "code" นะคะ ในบรรทัด
แรกของเรานะคะ เราก็เริ่ม
ประกาศฟังก์ชัน โดยพิมพ์คำว่าอะไรคะ
de แล้วกฌ f
ใช่ไหมคะ พิมพ์ด้วยตัวพิมพ์เล็กเสมอนะคะ
ไม่ใช่พิมพ์ใหญ่แบบนี้นะ ไม่ใช่พิมพ์ D-e-f
Def แบบนี้ ตัวใหญ่นี่ถือว่าไม่ถูกต้องนะคะ
ตัวใหญ่นี่ถือว่าไม่ถูกต้องนะคะ
def นะคะ แล้วก็กด
Space bar เพื่อวรรค 1 ครั้งนะคะ
บอกแล้วว่าวิธีการประกาศฟังก์ชัน ก็คือพิมพ์คำว่า "def"
แล้วตามด้วชื่อของฟังก์ชัน
ชื่อของฟังก์ชัน ในตัวอย่างเรา ชื่อว่า Hello
ทีนี้มาดูชื่อ ชื่อของฟังก์ชันนี่
ก็ต้องใช้ตัวพิมพ์เล็กเหมือนกัน
นะคะ ไม่ใช่ตัวพิมพ์ใหญ่นะคะ
ดูดี ๆ นะคะ เพราะ
พ์เล็กนะคะ h-
e-
l-l-o แล้วก็ใส่วงเล็บเข้าไป
แล้วก็ตามด้วย
พารามิเตอร์ ในวงเล็บพารามิเตอร์ของเรา ก็คือคำว่า "
name นะคะ ตัวพิมพ์เล็ก
เพราะมันเป็นตัวแปรชื่อว่า
แล้ว
วพอกด Enter นี่
ตำแหน่งของเคอร์เซอร์มันจะ Tab เข้าไปนะ
Stagement
หรือคำสั่งต่อไปที่เราจะใช้ ก็คือคำสั่งแสดง
ผลนะคะ dsads dasกฟหก ฟก ก็คือคำสั่ง
ปริ้น แล้วก็ตามด้วยวงเล็บเหมือนเดิม print อะไร
สิ่งที่อยู่ในวงเล็บอย่าลืมนะคะ เมื่อใดที่
บอกให้พิมพ์วงเล็บนี่ สังเกตมันจะมี () ขึ้นมานะ
เดี๋ยว
อ๋อ ขอโทษ ไม่ได้สลับหน้า
มันไม่สลับหน้า
ตลอดเลย
เราก็ว่าอยู่แต่เด็ก
พิมพ์ตามใน PowerPoint แต่อยากให้เห็นใน Colab
เพราะว่าเมาส์หาย
เมาส์จ๋า เมาส์จ๋า
นั่นน่ะสิ
เดี๋ยวเลื่อนไอ้นี่เอาก็ได้นะ
โอเคนะคะ นะ
ในนี้จะพิมพ์คำว่า "print" นะคะ เดี๋ยวจะโชว์
ไอ้ตัวข้อความด้วย
เดี๋ยวสิ้นสุดการนำเสนอก่อน
เดี๋ยวให้เห็น 2 หน้า
ด้วยกัน ไม่สิ ไม่สิ
โอเคไหม
เดี๋ยวนะ กำลัง
หามุม มุมให้เธออยู่
โอเคน่า
จะได้เห็น 2 อย่างนะ เห็นไหมคะ จะมาที่คำสั่ง print ของเรานะ
แล้วในวงเล็บของ print
ลืมทำให้มันขึ้น 2 หน้าคู่กัน เดี๋ยวนะคะ
แป๊บหนึ่ง
ขยับ
ได้ไหม
ไม่เห็นหน้านี้อีก
ขอ 2 ทำไมได้ 4 นี่
เดี๋ยวนะ เดี๋ยวจะ
กระเถิบ
แล้วก็
ไม่เห็นในสไลด์อีกสิ
ส่วนแบ่งทางการตลาดเยอะ
โอเคไหม
อีกหน่อยหนึ่ง นะคะ
วงเล็บในวงเล็บของคำว่า "print"
เราจะ print คำว่า "hello" นะคะ
แล้วตามด้วย
เห็นไหม ตรงก่อน... ตรงก่อน Hello มี
เครื่องหมายคำพูดนะดูดี ๆ อาจจะเห็นไม่ชัด
ใส่เครื่องหมายคำพูดนะคะ Single Quote หรือ
แล้วค่อยพิมพ์ Hello ด้วยตัวใหญ่
แล้วก็ตามด้วย
เครื่องหมาย % %s
นั่นคือ ข้อความนี้เป็น String นะคะ
แล้วหลังเครื่องหมายคำพูด
เด็ก ๆ ต้องเลื่อนไอ้ตัวนี้ไปหลังเครื่องหมายคำพูดนะ
พิมพ์ % name
แล้วก็พิมพ์เปอร์เซ็นต์ แล้วตามด้วย
name ตัวเล็กนะ ดูดี ๆ นะ เราเรียกใช้ เราสร้าง
พารามิเตอร์ด้วย name ตัวเล็กเวลาเรียกใช้ก็ต้องใช้ตัวเล็ก
นะคะ
นี่คือเสร็จฟังก์ชันนี้แล้ว
ลองเรียกใช้งาน ลองกด Play ก่อน
ขอโท
อร์มันจำ จำไว้ว่าตอนนี้เราสร้าง
ฟังก์ชันชื่อว่า hello แล้วนะคะ
ที่ให้กด Run นี่
เพื่
return หรือส่งกลับค่า
เดี๋ยวขยายหน้าไอ้นี่ให้ก่อน
สลับไปสลับมา
กันอยู่นี่ล่ะเรา อันนี้ อันนี้แบบไม่มี
return ค่านะ
ในตัวอย่างนี่เราสร้างฟังก์ชันชื่อ hello นะคะ
เราใช้เราสร้างฟังก์ชันนี้
ขึ้นมาเพื้อต้องการให้มันแสดงข้อความ เอา
อีกแล้วอะไรอีกหว่า
สลับจอไม่ได้เลย น่าจะเป็นกับไอ้
ตัวนี้
ทำไมหนก่อนไม่เห็นมี หรือเพราะเป็น
ไอ้นี่บ่ะ Windows 11 นี่บ่ มันถึงขึ้น
ไอ้สลับไอ้จอไอ้นี่ทุกทีเลย แล้วก็
เป็นปัญหาในการใช้งาน
จะได้ใช้ Windows อื่นเสียล่ะมั้ง
สลับไอ้จอไอ้นี่
นะคะ มาดูตัวอย่างที่ 2 นะคะ
เราจะประกาศฟังก์ชัน
มีการใช้ return value หรือการคืนค่ากลับ
ในตัวอย่างที่ 2 เป็น
ะคะ
แล้วมันก็จะไม่ขึ้นไอ้หน้านี้
อีกแล้ว มันเป็น
อะไรกับ...
มันไม่สลับ Extend หรือ
มันไม่ขึ้นหน้าจออีกแล้วน่ะ
โอเค ต้องสลับ
2 รอบเชียวหรือนะคะ
เอาไว้ก่อน
อย่างนั้นก็ต้องมาจัดไอ้นี่ใหม่อีกแล้วนี่
ไม่เห็นตัวหลังอีก เอา
เห็นไหม
ไม่เห็นอีก
ล้ว
จะต้องมีพารามิเตอร์อยู่ในวงเล็บ
ก็คือพารามิเตอร์ตัวที่ 1 ชื่อว่า width w-
i-d-
t-h นะคะ คั่น
ขั้นพารามิเตอร์
ตัวต่อไป ด้วยเครื่องหมาย
Comma
นะ คอมมาหรือไอ้ลูกน้ำเรา
นะคะ แล้วก็ตามด้วย
ชื่อพารามิเตอร์ตัวที่ 2 นะคะ ก็คือ h
-i-
h-e-i-g-h-t height หรือสูง
นั้นเองนะคะ มีพารามิเตอร์
สำหรับเก็บความยาวกับความกว้างนะคะ ก็คือ width กับ height
ปิดการ
ประกาศฟังก์ชันของเราด้วยเครื่องหมายโคลอน
เสมอ
เมื่อเราประกาศฟังก์ชันเสร็จแล้วนะคะ เรา
กด Enter เพื่อไปพิมพ์
Statements ใหม่นะคะ เคอร์เซอร์มันจะ Tab เข้าไป
อัตโนมัตินะคะ
เสร็จแล้วเราประกาศตัวแปร ชื่อว่า c เพื่อ
ทำการคำนวณค่าพารามิเตอร์ 2 ตัวของเรา
ก็คือเอา width
เพราะสูตรการหาพื้นที่สี่เหลี่ยม
กว้างคูณยาวนะ เพราะฉะนั้น เราอยากรู้พื้นที่สี่เหลี่ยม
เอากว้างไปคูณกับยาว เพราะฉะนั้น ก็ต้องเอาพารามิเตอร์ width
ตัวนี้เด็ก ๆ ดูนะ
เมื่อเราพิมพ์นี่ ให้เรา
width w-i-d-t-h เพราะอย่างนี้ทำให้เรา
พิมพ์พารามิเตอร์หรือตัวแปรที่เราสร้างไว้
ไม่ผิดนะคะ แล้วใส่เครื่องหมายคูณ
เครื่องหมาย คูณในที่นี้ก็คือเครื่องหมายดอ
ตัวแปรทางคณิตศาสตร์ของโปรแกรม
คอมพิวเตอร์เครื่องหมายคูณ ก็คือเครื่องหมายดอกจันนะคะ
แล้วตามด้วย
พารามิเตอร์ตัวที่ 2
h รอสักพัก แล้วหาคำว่า "height" นะคะ
h-e-i-g-h-t
อาจจะพิมพ์ h-e ก็ได้ น่าจะขึ้น
เห็นไหมคะ เจอตัวนี้ปุ๊บ
คลิกเลย เพราะบางคนจะมีปัญหา เมื่อ
ชื่อตัวแปรหรือพารามิเตอร์เริ่มยาวหรือยาก
จะพิมพ์ผิด แล้วพอพิมพ์ผิด พอไป Run โค้ดมันจะเกิด
Error
เพราะฉะนั้น ตัว Colab นะคะ
ที่ดีเลย คือ เมื่อเราพิมพ์
ตัวแรกขึ้นมา ตัวแปรตัวนั้นมันก็จะขึ้นมาให้
เห็นนะคะ พอเราเห้นเราคลิกเลือกมันได้เลย
นะคะ เมื่อได้
Statement เพื่อการคำนวณแล้ว
ต่อไปเราจบ
คำสั่งหรือ code ของ
นะคะ แล้วในบรรทัดต่อไป เราจะใช้
คำสั่งในการคืนค่าหรือ return value
โดยการพิมพ์คำว่า "return"
พิมพ์ด้วยตัวเล็กนะคะ
ค่าที่เราต้องการให้แสดง หรือ...
หรืออะไรก็แล้วแต่ ซึ่ง
ค่าที่เราต้องการให้มันแสดงหรือเห็นนี่ ก็คือ
ค่าของการที่เราคำนวณพื้นที่
c นั่นเองนะคะ เพราะฉะนั้น return c ตามด้วย c
ไม่มั่นใจก็คลิก c
ที่มันขึ้นมาอย่างนี้นะคะ
เหมือนเดิมนะคะ
เพื่อเป็นการเช็กโค้ดของเรา ก็คือกดตัว
Play ที่เป็นรูปเหมือนเป็น
Play Video Play Music อะไรพวกนี้ ให้มันเช็ก
ว่า code ที่เราเขียนนี่
ถูกต้องแล้วนะคะ มีใคร
ขึ้น Error ไหมคะ
ไม่มีนะคะ แสดงว่าเริ่มมีความชำนาญในการโค้ดแล้ว
แล้วนี่คือ
การประกาศใช้ฟังก์ชัน หรือการสร้างฟังก์ชัน ทีนี้
บอกแล้วว่าเมื่อสร้างเสร็จแล้วนี่
ไม่เห็นผลอะไรเลยใช่ไหม พอเรากด Play นี่
เราต้องไปเรียกใช้งาน
มันถึงจะแสดงไอ้ผลพวกนี้ออกมาได้
เพราะฉะนั้น เราจะมาดูเนื้อหา
ต่อไปนะคะ ก็คือ...
ไม่สลับโหมดแล้วนะ
เดี๋ยวสลับไปสลับมา เราก็ เราก็แก้
ไม่ได้อีก เดี๋ยวเสียเวลาในการแก้โหมด
หน้าจอนะคะ
ขอย่อให้มันพอดีหน่อย
โอเค
ก็จะเล็กไปอีกใช่ไหมถ้าย่อ แล้วสลับ
โหมดเป็นยังไงนี่
ขึ้นไหม ขึ้นอยู่ โอเค สลับได้
นะคะ เมื่อกี้บอกแล้วว่าถ้าเรา
ทำใน Colab เป็นการสร้างแล้วนะ ต่อมา
เมื่อสร้างเสร็จแล้ว
มันต้องเรียกใช้เสียก่อนนะคะ เราถึงจะรู้ว่าฟังก์ชันที่เราสร้าง
มันใช้งานได้จริงไหมนะคะ
การเรียกใช้งานฟังก์ชันนะคะ
ก็คือในนี้
พอเราสร้างฟังก์ชันแล้วนะคะ เราต้องเรียกใช้งานมัน วิธีการเรียก
ใช้ ก็คือเราWorldจะใช้ชื่อ'ของ
ฟังก์ชัน เห็นไหมคะ
และส่ง
Argument อะไร เมื่อกี้มีพารามิเตอร์ มามี Argument อีก
Argument กับ Parame
ter เดี๋ยวมีคำอธิบายนะคะ ว่า Argument
ก็เป็นคำ ไม่ใช่คำ
เป็นค่าที่เราส่งเข้าไปในฟังก์ชันนะคะ
ตอนที่เราใช้งานนะคะ
ส่วนพารามิเตอร์น่ะ คือ ตัวแปรที่เรากำหนด
ในฟังก์ชันเพื่อรับค่า
เมื่อกี้พารามิเตอร์ที่เรามีตัวที่ 1 ชื่อว่า
name นั่นคือตัวแปรที่เราใช้รับค่า
เพราะฉะนั้น Argument ก็คือชื่อที่เราจะพิมพ์เพื่อให้ตัวแปร
มันรับค่านั่นเองนะคะ
มาดูตัวอย่างวิธีการเรียกใช้ฟังก์ชันนะคะ
มาดูตัวอย่าง
การจะเรียกใช้ฟังก์ชันที่เราสร้างขึ้น ไม่ได้มี
อะไรพิศดาลเลยเพียงแต่เราพิมพ
์ชื่อฟังก์ชันนั้น แล้วตามด้วย
เห็นไหมคะ ตามด้วย Argument
ในที่นี้ ก็คือ
ชื่อเพราะในวงเล็บนี่
ิสิ่งที่เป็นตัวแปรชื่อว่า name นะคะ พารามิเตอร์
น่ะชื่อว่า name แล้วพอเราเรียกใช้นี่
ก็คือเราพิมพ์ชื่อฟังก์ชันนั้น แล้วตามด้วยค่า
ที่เราจะให้
มันเก็บเลยนะ นะคะ ลองดูนะคะ
ลองเลย ลองเลย เพื่อให้เห็นภาพ
หรือมันช้า พอ... พอสลับมา ...Colab มันจะช้า
นิดหนึ่งหรือ ไม่สลับ
อีกแล้วนะ อะไรนะ
ะดด
โอเค เรา
ก็จะต้องสลับกันอย่างนี้นะคะ นี่นะ เราไปประกาศไปแล้วนี่
นี่คือฟังก์ชันเวลาเรียกใช้
ไม่ได้มีอะไรพิสดารเลยนะคะ ใส่ Hashtag ก่อน
เพื่อจะให้รู้ว่าตรงนี้เป็นส่วนของ
เราเรียกการใช้ฟังก์ชันน
ใส่เครื่องหมา chap หรือ hahtag
อันนี้คือคอมเมนต์น