(ล่าม) ฮัลโหลครับ
ฝั่งล่ามไหมครับผม
(อาจารย์สุธิรา) ได้ยินค่ะ (ล่าม) โอเคครับ
(อาจารย์สุธิรา) สวัสดีค่ะ พี่ล่ามไม่ได้ยินเรานะ
(ล่าม) ได้ยินครับ ได้ยินครับ
(อาจารย์สุธิรา) ได้ยินไหม ได้ยินนะคะ โอเค นึกว่าไม่ได้ยิน
นะคะ
สำหรับวันนี้นะคะ ในสัปดาห์นี้จะเป็น
เรื่องเกี่ยวกับ
ฟังก์ชันนะ
ใน Python
เราจะต้องมาเรียนเบื้องต้นนี่ ก็คือต้องมารู้จัก
สิ่งที่เรียกว่า Function ก่อนนะคะ
นะคะ หัวข้อที่
เราจะเรียนในสัปาดาห์นี้นะคะ จะเป็น
หัวข้อสุดท้ายของปีนี้
เทอมนี้นะคะ ภาคเรียนนี้ ก็คือฟังก์ชัน
วันนี้เราจะพูดถึงการ
นะคะ การเรียกใช้งาน
แล้วก็พูดถึง
Default Argument Values แล้วก็ Keyword Argument
นะคะ อ้าวทำไมหน้าจอไม่ขึ้น
อีกแล้ว...
โอเคนะคะ ก่อนอื่น
ก่อนจะรู้วิธีการสร้าง
การเลือกใช้งานนี่ เราก็ต้องรู้ก่อนว่าฟังก์ชันมันคืออะไรนะคะ
คือ ถ้าพูดถึงโดยทั่วไปนะคะ
ก็คือถ้าเราเป็นโปรแกรมเมอร์หรือ
ในวิธีการเขียนโปรแกรมคอมพิวเตอร์นี่ ฟังก์ชันมันจะเป็น
สั่งพิเศษ
ีที่ให้ทำงานเฉพาะสิ่งใดสิ่งหนึ่งนะคะ
ซึ่งแต่เดิมนี่ฟังก์ชันมันจะเป็น
ที่เขาพัฒนาไว้แล้วก็มี แต่ใน Python นะคะ
ในส่วนของภาษา python
ฟังก์ชันจะเป็นโค้ด หรือโปรแกรมที่เรา
สร้างขึ้นได้เองนะคะ
เพื่อเอาไปใช้กับ...
เหมือนตั้งขึ้นมาว่าฟังก์ชันนี้จะตั
นะคะ เช่น
เหมือนบางครั้งนี่ การคำนวณบางอย่าง
ไม่จำเป็นต้องไปเขียนโค้ดใหม่ทุกครั้ง เราก็เลยสร้างฟังก์ชันไว้เลย
แล้วไปเรียกฟังก์ชันนี้มาเพื่อให้มัน
ทำกาารคำนวณค่านี้ให้อย่างนี้นะคะ นั่นคือจุดประสงค์
จะนำไปใช้ในสิ่งใดสิ่งหนึ่งนะคะ
เป็นการเฉพาะ โดยใน
บอกแล้วว่าในสัปดาห์นี้เราจะสร้าง
ขึ้นมาใช้งานเองนะคะ แล้วเมื่อสร้างเสร็จแล้วนี่
จะต้องรู้ว่า
มันจะต้องเรียกฟังก์ชันที่เราใช้งานนี่จะถูกเรียก
มาใช้โดยวิธีการใด
หรือเรียกใช้อย่างไรนะคะ แล้วก็จะพูดถึง 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
นั่นก็คือชื่อ ชื่อ
ของฟังก์ชันที่เราจะไว้เรียกใช้ในครั้งต่อไป เราจะเป็นคนตั้งเอง
ให้นึกถึงฟังก์ชันเนม
ตั้งชื่อให้ตัวแปร แต่อันนี้เป็นการตั้งชื่อ
ฟังก์ชันนี้คือฟังก์ชันอะไรนะคะ เสร็จ
แล้วก็จะมีวงเล็บ พอใส่คำว่า "def" แล้วก็
ใส่ชื่อฟังก์ชันเราต้องต้องพิมพ์วงเล็บ
เสมอนะคะ แต่ถ้าเราพิมพ์ใน Colab ตัววงเล็บนี้จะ
ขึ้นมานะคะ แล้วส่วนข้างในนี่
นะคะ เขาบอกว่ามันเป็นการกำหนดค่า Paramiter
พารามิเตอร์
ถ้าเป็นเขียนโค้ดปกติ มันก็จะหมายถึงตัวแปร
นะคะ แต่ในฟังก์ชันนี่เราจะ
เรียกว่า "พารามิเตอร์" เพื่อไว้สำหรับ
อะไรล่ะ เขาเรียก
นี่ เขาบอกว่าพารามิเตอร์ของฟังก์ชันนี่
มีจำนวนเท่าไรก็ได้ ก็คือในฟังก์ชันนี้
เราจะมีการเก็บค่าของอะไรบ้าง
พารามิเตอร์ตัวนั้นก็จะเป็นตัวเก็บให้เรา
สมมตินะคะ สมมติเราต้องการตำนวณหาค่า
พื้นที่
วงกลมอย่างนี้นะคะ ค่าพารามิเตอร์ที่จะเก็บก็อาจจะมี
ค่าของรัศมีวงกลม
หรือมีค่าของอะไรนะ
เส้นรอบวงอะไรอย่างนี้เข้ามานะคะ นั่นก็คือ
ค่าพารามิเตอร์ที่เราจะไว้เก็บข้อมูลในฟังก์ชัน
นี้นะคะ เสร็จแล้ว
เมื่อพิมพ์ function_name ใส่ค่าพารามิเตอร์
อะไรเสร็จ เราจะปิดคำสั่ง
การประกาศฟังก์ชันด้วยโคลอนเสมอนะคะ
สังเกตนะคะ เมื่อใดที่
ตัวนั้นจะต้องปิดด้วยเสมอ แล้วขึ้นบรรทัด
ใหม่มันจะเข้าสู่ย่อหน้าใหม่
ตัว statements ในที่นี้หมายถึงคำสั่งอื่น ๆ นะคะ
แล้วเด็ก ๆ สังเกต
ดูนะคะ ว่าในการประกาศฟังก์ชันตัวที่ 1
นะคะ กับตัวที่ 2 ตัวที่ 2
จะมีคำว่า return value return ก็
คือการคืนส่งค่าคืนกลับ
ซึ่งฟังก์ชันที่เราเขียน อาจจะ
เขียนแล้วมี return หรือ
ไม่มีก็ได้นะคะ แต่ที่เขียนให้ดูเป็นตัวอย่างนี่ ให้เห็น
รูปแบบนี้ให้เห็นทั้ง 2 แบบ
เป็นแบบที่ไม่มีการ return ค่า
แต่แบบที่ 2 นี่มี มีการส่งคืน
ค่ากลับ ก็เลยจะมีคำว่า "return value" ก็คือ
เราต้องพิมพ์คำว่า return ด้วย
ตามด้วยค่าที่เราต้องการให้ส่งกลับ เช่น เดี๋ยวดู
ในตัวอย่างจะเห็นชัดนะคะ เดี๋ยวยกตัวอย่าง
แล้วจะมองภาพไม่ออก ซึ่งเขาบอกว่า
ค่าที่ส่งกลับนั้นจะเรียกว่า
นะคะ
ทีนี้เรามาดูตัวอย่างแรกก่อน
เพื่อจะให้เห็นว่าถ้าเราต้องการประกาศ
ตัวแปรแลลไม่มีการ return
ไม่มีคำสั่ง return เพื่อคืนค่านี่ ใน
ตัวอย่างนี้เราจะประกาศตัวแปร
ชื่อ เห็นไหมคะ ตรง def แล้วตามด้วย
hello()
def ก็คือ definition
ก็คือคำสั่งเพื่อใช้
และติดประกาศตัวแปร ประกาศฟังก์ชัน ขอโทษทีนะคะ
คือ def
แล้วก็ตามด้วย function_name ซึ่งในที่นี้ตั้งชื่อว่า
hello นะคะ ฟังก์ชัน hello ก็คือ
ฟังก์ชันที่เราต้องใช้เพื่อแสดงคำทักทายออกมานั่นเอง
นะคะ แล้วทีนี้
พอเวลาเรียกใช้ฟังก์ชันนี้นะคะ มันจะสั้น
นึกออกนะ การเขียนโค้ดมันจะสั้น
กว่าที่เราเคยทำ
แล้วตามด้วย พารามิเตอร์หรือ
ที่เราไว้เก็บค่า ก็คือ name นะคะ เสร็จแล้ว ตาม
ด้วย statement ตามด้วยข้อความหรือคำสั่ง
หรือโค้ดอะไรก็แล้วแต่นะคะ ซึ่งในทีนี้เราต้องการให้แสดง
นะคะ แสดงคำทักทาย
ชื่อที่เรารับค่าเข้าไปนี่ หรือพารามิเตอร์ที่เรา
ส่งเข้าไป ก่อนอื่น เด็ก ๆ
เปิด Colab หรือยังคะ เปิด Colab ด้วย
ไปที่ web browser
แล้วเปิดเหมือนเดิมนะคะ พิมพ์คำว่า "Colab" น่ะ
c-o ต้องบอกว่า co สิ
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
ด้วยตัวพิมพ์เล็กนะคะ h-
e-
l-l-o แล้วก็ใส่วงเล็บเข้าไป
แล้วก็ตามด้วย
พารามิเตอร์ ในวงเล็บพารามิเตอร์ของเรา ก็คือคำว่า "
name นะคะ ตัวพิมพ์เล็ก
เพราะมันเป็นตัวแปรชื่อว่า name เมื่อ
เสร็จฟังก์ชันใช่ไหม
เสร็จคำสั่งฟังก์ชันต้องปิดด้วยเครื่องหมายโคลอนเสมอ
แล้วกด Enter 1 ครั้ง
ใช้วิธีกด Enter นะ ไม่ใช่เลื่อนเมาส์
ลงไป สังเกตบอกแล้วพอกด Enter นี่
ตำแหน่งของเคอร์เซอร์มันจะ Tab เข้าไปนะ
Stagement
หรือคำสั่งต่อไปที่เราจะใช้ ก็คือคำสั่งแสดง
ผลนะคะ ก็คือคำสั่ง print
p-r-i
n-t
print แล้วก็ตามด้วยวงเล็บเหมือนเดิม print อะไร
สิ่งที่อยู่ในวงเล็บอย่าลืมนะคะ เมื่อใดที่
บอกให้พิมพ์วงเล็บนี่ สังเกตมันจะมี () ขึ้นมานะ
เดี๋ยว
อ๋อ ขอโทษ ไม่ได้สลับหน้า
มันไม่สลับหน้า
ตลอดเลย
เราก็ว่าอยู่แต่เด็ก
พิมพ์ตามใน PowerPoint แต่อยากให้เห็นใน Colab
เพราะว่าเมาส์หาย
เมาส์จ๋า เมาส์จ๋า
นั่นน่ะสิ
เดี๋ยวเลื่อนไอ้นี่เอาก็ได้นะ
โอเคนะคะ นะ
ในนี้จะพิมพ์คำว่า "print" นะคะ เดี๋ยวจะโชว์
ไอ้ตัวข้อความด้วย
เดี๋ยวสิ้นสุดการนำเสนอก่อน
เดี๋ยวให้เห็น 2 หน้า
ด้วยกัน ไม่สิ ไม่สิ
โอเคไหม
เดี๋ยวนะ กำลัง
หามุม มุมให้เธออยู่
โอเคน่า
จะได้เห็น 2 อย่างนะ เห็นไหมคะ จะมาที่คำสั่ง print ของเรานะ
แล้วในวงเล็บของ print
ลืมทำให้มันขึ้น 2 หน้าคู่กัน เดี๋ยวนะคะ
แป๊บหนึ่ง
ขยับ
ได้ไหม
ไม่เห็นหน้านี้อีก
ขอ 2 ทำไมได้ 4 นี่
เดี๋ยวนะ เดี๋ยวจะ
กระเถิบ
แล้วก็
ไม่เห็นในสไลด์อีกสิ
ส่วนแบ่งทางการตลาดเยอะ
โอเคไหม
อีกหน่อยหนึ่ง นะคะ
วงเล็บในวงเล็บของคำว่า "print"
เราจะ print คำว่า "hello" นะคะ
แล้วตามด้วย
เห็นไหม ตรงก่อน... ตรงก่อน Hello มี
เครื่องหมายคำพูดนะดูดี ๆ อาจจะเห็นไม่ชัด
ใส่เครื่องหมายคำพูดนะคะ Single Quote หรือ
แล้วค่อยพิมพ์ Hello ด้วยตัวใหญ่
แล้วก็ตามด้วย
เครื่องหมาย % %s
นั่นคือ ข้อความนี้เป็น String นะคะ
แล้วหลังเครื่องหมายคำพูด
เด็ก ๆ ต้องเลื่อนไอ้ตัวนี้ไปหลังเครื่องหมายคำพูดนะ
พิมพ์ % name
แล้วก็พิมพ์เปอร์เซ็นต์ แล้วตามด้วย
name ตัวเล็กนะ ดูดี ๆ นะ เราเรียกใช้ เราสร้าง
พารามิเตอร์ด้วย name ตัวเล็กเวลาเรียกใช้ก็ต้องใช้ตัวเล็ก
นะคะ
นี่คือเสร็จฟังก์ชันนี้แล้ว
ลองเรียกใช้งาน ลองกด Play ก่อน
ขอโทษ เราจะได้รู้นะคะ
การกดตัวนี้นะ เพื่อจะได้เช็กว่า
ที่เรา code
ที่เราเขียนไปนี่มันถูกไหม ถ้าผิดมันจะขึ้น Error ใช่ไหมคะ
ครั้งแรกเวลาโค้ดมันก็จะช้านิดหนึ่ง
มันก็จะยังหมุนติ้ว ๆ อยู่นะคะ เราก็ต้องรอนะคะ
แสดงว่าไม่มีอะไรผิดนะคะ
ไม่ทำอะไรนะ เพราะฟังก์ชันสร้างขึ้นมา สร้างแล้ว
แล้วอย่าลืมว่ามันจะต้องมีการเรียกใช้ นึกออกนะ
ต้องสร้าง สร้างเพื่อให้มันไปโดนเรียกก่อน มันถึงจะทำงาน
นะคะ ตอนนี้คือสร้าง
เพื่อให้คอมพิวเตอร์มันจำ จำไว้ว่าตอนนี้เราสร้าง
ฟังก์ชันชื่อว่า hello แล้วนะคะ
ที่ให้กด Run นี่
เพื่อจะให้ตรวจสอบว่า
โค้ดที่เราเขียนไปมันถูกหรือเปล่า ถ้าผิดมันจะแสดง Error
นะ ถ้าเขียนไม่ผิดมันก็ไม่แสดงใช่ไหมคะ
นี่ลอง Run แล้วนะคะ Error ไม่ขึ้นนะคะ
ของใครขึ้น Error ยกมือ
สิ่งที่ต้องเช็ก ก็คือ 1. คำสั่ง
d-e-f นะคะ definition
การประกาศฟังก์ชัน ตัวที่ 2
ก็คือชื่อฟังก์ชัน
ใช้ตัวเล็ก และตัวที่ 3 พารามิเตอร์ พามิเตอร์จะ
มีค่าอยู่ในวงเล็บเสมอ
นะคะ เสร็จแล้วต้องปิด
การประกาศฟังก์ชันด้วย
โคลอนเสมอนะคะ
ทีนี้เมื่อกี้
ประกาศฟังก์ชันที่ 1 ไปแล้ว
มาดูแบบที่ 2 นะคะ ฟังก์ชัน
ที่มีการ return หรือส่งกลับค่า
เดี๋ยวขยายหน้าไอ้นี่ให้ก่อน
สลับไปสลับมา
กันอยู่นี่ล่ะเรา อันนี้ อันนี้แบบไม่มี
return ค่านะ
ในตัวอย่างนี่เราสร้างฟังก์ชันชื่อ hello นะคะ
เราใช้เราสร้างฟังก์ชันนี้
ขึ้นมาเพื้อต้องการให้มันแสดงข้อความ เอา
อีกแล้วอะไรอีกหว่า
สลับจอไม่ได้เลย น่าจะเป็นกับไอ้
ตัวนี้
ทำไมหนก่อนไม่เห็นมี หรือเพราะเป็น
ไอ้นี่บ่ะ Windows 11 นี่บ่ มันถึงขึ้น
ไอ้สลับไอ้จอไอ้นี่ทุกทีเลย แล้วก็
เป็นปัญหาในการใช้งาน
จะได้ใช้ Windows อื่นเสียล่ะมั้ง
สลับไอ้จอไอ้นี่
นะคะ มาดูตัวอย่างที่ 2 นะคะ
เราจะประกาศฟังก์ชัน
มีการใช้ return value หรือการคืนค่ากลับ
ในตัวอย่างที่ 2 เป็นการประกาศ
ฟังก์ชันที่ชื่อว่า area()
โดยมีพารามิเตอร์ 2 ตัว
width แล้วก็ความ... width แล้วก็
height ซึ่ง area ในที่นี้ึ
พื้นที่ สูตรการหาพื้นที่สี่เหลี่ยม ก็คือ
กว้างคูณยาว
เพราะฉะนั้น ค่าพารามิเตอร์ที่ไว้ใช้สำหรับเก็บค้า
ก็คือค่าความยาวกับความกว้าง
นั่นเองนะคะ ก็เลยตั้งชื่อตัวพารามิเตอร์ 2 ตัวนี้
ว่า width
นั่นเองนะคะ เสร็จแล้วปิดด้วยโคลอน
Statement ต่อมาสร้างตัวแปร
ชื่อว่า C ตัวแปร C
สำหรับคำนวณ
ความกว้างคูณความยาว ก็คือคำนวณ
หาพื้นที่ของสี่เหลี่ยมนั่นเองนะคะ
แล้วทำการ return ค่า c
นะคะ ก็คือให้ส่งกลับค่าของ c
ก็คือเมื่อเอาพารามิเตอร์มาคำนวณแล้วนี่ c จะได้เท่าไหร่
ส่งกลับค่าให้ c นะคะ
นี่คือการประกาศฟังก์ชัน
แบบมีการ return ค่า
เพราะฉะนั้น บางคน
คีย์ใน Colab ไปเรียบร้อยแล้วนะคะ
เรามาเริ่มคีย์ของเราด้วยนะคะ
แล้วมันก็จะไม่ขึ้นไอ้หน้านี้
อีกแล้ว มันเป็น
อะไรกับ...
มันไม่สลับ Extend หรือ
มันไม่ขึ้นหน้าจออีกแล้วน่ะ
โอเค ต้องสลับ
2 รอบเชียวหรือนะคะ
เอาไว้ก่อน
อย่างนั้นก็ต้องมาจัดไอ้นี่ใหม่อีกแล้วนี่
ไม่เห็นตัวหลังอีก เอา
เห็นไหม
ไม่เห็นอีก มัน
น่านักเชียว
แป๊บนึงนะสลับหน้าก่อน
โอเคไหม
Colab
ไปไหนแล้ว
นะคะ
เราประกาศฟังก์ชัน
ที่ 2 ต่อด้วยฟังก์ชันแรกได้เลยนะคะ
เมื่อหลังฟังก์ชันแรกเรากด Enter กดลงไป
2 อันเลยก็ได้เด็ก ๆ สังเกตตำแหน่งมันจะ
Tab เข้าไปนะ เรากดย้อนคืน 1 ครั้ง
ตำแหน่งตรงกับชิดขอบ
แล้วก็เริ่มพิมพ์คำสั่ง definition
d-e-f เพื่อประกาศใช้คำสั่งฟังก์ชัน
ที่ชื่อว่า... ชื่อฟัง์ชันของเราชื่อว่า area() นะคะ
วรรคตามด้วย area
ตัวเล็กนะคะ
แล้วก็
ตามด้วยเครื่องหมายวงเล็บ เพราะบอกแล้วมีชื่อฟังก์ชัน เสร็จแล้ว
จะต้องมีพารามิเตอร์อยู่ในวงเล็บ
ก็คือพารามิเตอร์ตัวที่ 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 เป็นการสร้างแล้วนะ ต่อมา
เมื่อสร้างเสร็จแล้ว
มันต้องเรียกใช้เสียก่อนนะคะ เราถึงจะรู้ว่าฟังก์ชันที่เราสร้าง
มันใช้งานได้จริงไหมนะคะ
การเรียกใช้งานฟังก์ชันนะคะ
ก็คือในนี้
พอเราสร้างฟังก์ชันแล้วนะคะ เราต้องเรียกใช้งานมัน วิธีการเรียก
ใช้ ก็คือเราจะใช้ชื่อของ
ฟังก์ชัน เห็นไหมคะ
และส่ง อาร์กิวเมนต์
อะไร เมื่อกี้มีพารามิเตอร์ มามี Argument อีก
Argument กับ Parame
เดี๋ยวมีคำอธิบายนะคะ ว่า Argument
ก็เป็นคำ ไม่ใช่คำ
เป็นค่าที่เราส่งเข้าไปในฟังก์ชันนะคะ
ตอนที่เราใช้งานนะคะ
ส่วนพารามิเตอร์น่ะ คือ ตัวแปรที่เรากำหนด
ในฟังก์ชันเพื่อรับค่า
เมื่อกี้พารามิเตอร์ที่เรามีตัวที่ 1 ชื่อว่า
name นั่นคือตัวแปรที่เราใช้รับค่า
เพราะฉะนั้น Argument ก็คือชื่อที่เราจะพิมพ์เพื่อให้ตัวแปร
มันรับค่านั่นเองนะคะ
มาดูตัวอย่างวิธีการเรียกใช้ฟังก์ชันนะคะ
มาดูตัวอย่างกันก่อน
การจะเรียกใช้ฟังก์ชันที่เราสร้างขึ้น ไม่ได้มี
อะไรพิศดาลเลยเพียงแต่เราพิมพ
ชื่อฟังก์ชันนั้น แล้วตามด้วย
เห็นไหมคะ ตามด้วย Argument
ในที่นี้ ก็คือ
ชื่อเพราะในวงเล็บนี่
ิสิ่งที่เป็นตัวแปรชื่อว่า name นะคะ พารามิเตอร์
น่ะชื่อว่า name แล้วพอเราเรียกใช้นี่
ก็คือเราพิมพ์ชื่อฟังก์ชันนั้น แล้วตามด้วยค่า
ที่เราจะให้
มันเก็บเลยนะ นะคะ ลองดูนะคะ
ลองเลย ลองเลย เพื่อให้เห็นภาพ
หรือมันช้า พอ... พอสลับมา Colab มันจะช้า
นิดหนึ่งหรือ ไม่สลับ
อีกแล้วนะ อะไรนะ
โอเค เรา
ก็จะต้องสลับกันอย่างนี้นะคะ นี่นะ เราไปประกาศไปแล้วนี่
นี่คือฟังก์ชันเวลาเรียกใช้
ไม่ได้มีอะไรพิสดารเลยนะคะ ใส่ Hashtag ก่อน
เพื่อจะให้รู้ว่าตรงนี้เป็นส่วนของ
เราเรียกการใช้ฟังก์ชันนี้ ก็เลย
ใส่เครื่องหมา chap หรือ hahtag
อันนี้คือคอมเมนต์นั่นเองนะคะ เพื่อจะบอกให้รู้ว่า
ตรงนี้เราจะเรียกใช้ฟังก์ชันที่เราสร้างแล้วนะ calling
calling นะคะ calling ก็
แล้วก็ตามด้วยฟังก์ชัน f-u-n เด็ก ๆ ไม่ต้องพิมพ์ ไอ้นี
ก็ได้นะคะ
ฟังก์ชันแรกที่
เราจะเรียกใช้ชื่อ ก็คือเวลาจะเรียกใช้มัน
พิมพ์ชื่อฟังก์ชันนั้นนะคะ พิมพ์ hello เลยนะคะ
ฟังก์ชันแรกของเรา
ชื่อว่า hello ใช่ไหมคะ แล้วตามด้วยเครื่องหมายวงเล็บ
นะคะ เห็นไหมคะ มันจะขึ้นมาบอกเลย name
name คืออะไร name ในที่นี้ ในตัวอย่าง ก็คือ Danny นะคะ
ทีนี้เราไม่อยากใส้ Danny เราใส่ชื่อเราเองไปก็ได้
ชื่อนึกออกนะ เช่น
เนื่องจาก name เป็น string อย่าลืมใส่เ
เครื่องหมายคำพูด
หรือ Double Quote นะคะ name
ใส่ชื่อเราแทน Danny ก็ได้นะคะเด็ก ๆ
จะใส่ชื่อเล่นหรือชื่อจริง
ก็ได้ แล้วแต่นะคะ
สมมติ
เรียกฟังก์ชัน hello ไปแล้ว ฟังก์ชันต่อมา
ที่เราจะเรียกใช้นะคะ
ก็คือ area() แต่ area() ที่เรา
เราอยากให้มันแสดงค่าพื้นที่
นะคะ ก็เลยใช้คำสั่ง
print ก่อน แล้วไปเรียกฟังก์ชัน
นั้นไว้ใน print นะคะ ให้ print แสดงนะคะ ดูตัวอย่าง
ทำให้ดูก่อน
p-r-i-n-t
ลืมแก้ภาษาขอโทษที
ตำแหน่งของฟังก์ชันชิดนะคะ
ไม่วรรคนะคะ นี่ ไม่ต้อง Tab เข้าไปนะ
ตัวที่ 2 นะคะ
เราจะใช้คำสั่ง print
ฟังก์ชันนะคะ เพื่อให้แสดงแล้วก็เรียกใช้ฟังก์ชัน
ด้วยแสดงคำว่า
เป็นข้อความนะคะ เพราะฉะนั้น
เมื่อเป็นข้อความ พิมพ์เป็นภาษาไทยก็ได้
ไม่ต้องใช้คำว่า "area" ในภาษาอังกฤษ ก็คือพื้นที่
สี่เหลี่ยม
=
ใส่เครื่องหมายเท่ากับนะคะ เปลี่ยนภาษา
ก่อน =
%d นะคะ %d เท่ากับ แล้วก็
เปอร์เซ็นต์แล้วก็ d
แล้วหลังเครื่องหมายคำพูด
ตามด้วย % แล้วเรียกใช้
ฟังก์ชัน area นะคะ ตามด้วยเครื่องหมายเปอร์เซ็นต์
แล้วก็
พิมพ์ฟังก์ชัน area a-
r ปุ๊บ ขึ้นหรือยัง
A-r-
e-a นะคะ
แล้วก็วงเล็บ
ทีนี้ใส่ Argument
ให้ 2 ตัว ก็คือ 8 นะคะ กว้าง 8
เอามากกว่านั้นก็ได้นะ
ในตัวอย่างบอกว่าความกว้าง คือ 8 ความสูง คือ 4
ถ้าพื้นที่ที่มี
ความกว้าง พื้นที่สี่เหลี่ยมที่มีความกว้าง 8
ความสูง 4 นี่ความสูงนี้
เท่าไหร่ ตอนนี้เราพิมพ์คำสั่งหรือโค้ด
เสร็จหมดแล้วนะคะ
เด็ก ๆ ลองกด Play ดูได้เลยนะคะ ถ้าใครพิมพ์เสร็จแล้ว
จะแสดงผลอย่างไร
Error เด้งขึ้นมา ณบัด Now
บรรทัดที่ 9
เกิดอะไรขึ้น
print
ตัวแปร ตัวแปรผิด เดี๋ยวนะ ค่อย ๆ ไล่นะคะ
พอขยายแล้วของตัวเองก็เล็ก
แบบนี้นะ เดี๋ยว
สังเกตนะคะ เมื่อขึ้น Error
เด็ก ๆ ดู เห็นไหม มันจะชี้ไปที่บรรทัดผิด
พิมพ์ตัวแปรผิดหรือ ฟังก์ชันชื่อฟังก์ชัน
ถูกแล้วนะ hello ถูกต้องนะคะ
เสร็จแล้ว
มันบอกว่าในบรรทัดที่
2 % name
value error ค่า error ตรง...
ไม่อยู่ใน Index
S ตัวใหญ่หรือ s เล็กใช่ไหม ขอโทษที
พิมพ์ s ผิดใช่ไหมนี่
%s
แก้ได้ ๆ
เห็นไหมคะ
เมื่อกี้ตรงลืมพล็อต
ให้ดูก่อน เมื่อกี้ตอนแม่พิมพ์ %s
แม่ไม่ได้ดู s มันเป็นตัวมหญ่ตาม
คือ ไอ้พวก % d % อะไรนี่
พิมพ์เล็กมันไม่ใช่ตัวพิมพ์ใหญ่ แม่ไปพิมพ์ใหญ่
ถ้าเด็ก ๆ ผิดตำแหน่งนี้ แก้แค่ตัว S จากตัวพิมพ์ใหญ่ เป็น
ตัวพิมพ์เล็เกแค่นั้นเอง
การขึ้น Error นะ เดี๋ยวแก้ให้ดูนะคะ
พอมาไล่ฟังก์ชัน
มันจะขึ้นลูกศรชี้ไปที่บรรทัดไหน นั่นหมายความว่า
มันหมายความผิดพลาดที่
%s' name
ตรง value error เห็นไหม ค่าที่มัน error ค่ามัน
อยู่ที่คำว่า s อ๋อ
ย้อนกลับไปดู อ๋อ s ฉันพิมพ์ผ
ฉันต้องพิมพ์เป็นตัวเล็กนะคะ พอแม่แก้
จากตัวใหญ่เป็นตัวเล็ก
เรากด Play น่ะ Error มันก็หาย แล้วผลลัพธ์
มันก็จะแสดงขึ้นมา เห็นไหม มันก็จะพิมพ์คำว่า...
มันก็จะไปเรียกใช้ ไอ้ตัวนี้
ออกมาเลย ทั้ง ๆ ที่ ตอนเรียกนี่ เราพิมพ์แค่
ฟังก์ชัน แล้วก็ตามด้วยค่า Argument
ที่จะให้มันแสดงแต่
ตอนที่ทำงานน่ะ มันมาทำงานที่ตัวนี้เห็นไหมคะ
ตัวคำว่า "print" แต่ตรง area นี่
นะคะ ตรงฟังก์ชัน area
คำว่า "print" ไว้
พอเวลามาเรียกใช้เธอ เราก็เลยมาพิมพ์คำว่า...
มีแถมตัว r มาจากไหนนี่
สามเหลี่ยม = %d'
สามเหลี่ยม 8 x 4 = 32 ถูกต้องนะคะ
มันก็จะส่งค่า c ที่มาคำ
มาแสดงตรงนี้เห็นไหมคะ
เป็น 32 นะคะ มันก็เลย print คำว่า "
พื้นที่ สี่เหลี่ยม
ของเรานี่นะคะ มีค่า =
%d นั่นหมายถึง
ให้แสดงเป็นเลขจำนวณเต็มนี่
แสดงทศนิยมออกมานะคะ
ลองดูอีกสักตัวอย่างหนึ่งไหมคะ
ลอง ลองเรียกใช้
ฟังก์ชัน hello อีกนะคะ
เด็ก ๆ ลองนะคะ ทีนี้ให้
ใส่ชื่อเล่นตัวเองลงไป
เอาแต่ hello อย่างเดียวให้เห็น
ใส่ชื่อเล่นเรานะ
เห็นไหมคะ มันจะขึ้นมาเป็น
ตัวต่อไปอันนี้ไม่มันก็จะ
ทำซ้ำไง เพราะเรายังอยู่ในตัวเดิมนะ
ไม่แน่ใจว่ามันจะไปเรียกใช้ได้อีกไหม
มันจะไปเรียกใช้ได้อีกไหม
มีตัวใหม่ใช่ไหม แล้วลองเรียกใหม่
จากโค้ดที่เราเพิ่มเข้ามา ลองเรียกนะคะ
ไม่ได้ไปเรียกต่อจากเมื่อกี้
ลองพิมพ์ฟังก์ชัน hello ที่เราสร้างไว้
ก่อนหน้า ลืมแก้ภาษาอีกแล้ว
พิมพ์เรียกใช้ฟังก์ชัน
ทีนี้ลองใส่ชื่อเล่น
หลาย ๆ คน ใส่ชื่อเพื่อนลงไปด้วยสัก 3 คน
ลองดูสิ มันจะขึ้นอย่างไร ลองดูนะคะ
เพราะบอกแล้วว่า Argument นะคะ
มีกี่คนก็ได้ ลองสิขึ้นไหม
Syntax error เพราะอะไรคะ
เพราะไอ้ตัวนี้มันมีพารามิเตอร์ใ
ตัวเดียว แต่เราไปใส่หลายตัวนะคะ มันจะใส่ได้
ตามจำนวนพารามิเตอร์ด้วยนะคะ เพราะฉะนั้น ในกรณีนี้
ถ้าเราจะเพิ่มให้มันมีหลายคน
ถ้าเราจะเพิ่ม
ให้มันมีหลายคนนะคะ เราต้องไปแก้ที่ฟังก์ชันเรา
เข้าใจแล้ว
แล้วลอง ลองมาใส่ที่ตัวนี้ใหม่
แสดงว่าไม่เรียก อ๋อ
มัน มันข้ามไปสร้างตัวใหม่
นี่ไง ๆ มันขึ้นเตือนว่ามาว่า
Type Error ชนิดไม่ถูกต้องนะคะ เพราะ
ฟังก์ชัน Hello เราน่ะ
Position ให้แค่ 1 ตำแหน่ง
นะคะ ใน Argument แต่
เราไปใส่ 3 ก็คือถ้าเราต้องการให้มีหลายตค
ไปเพิ่มตัวนี้นะคะ เพิ่มขึ้น
เพราะฉะนั้น
ไปวิธีแก้ไม่ได้ยากเลยนะคะ
ถ้าจะ... เรามาเปลี่ยนที่ตัวฟังก์ชันหลัก
เพราะตอนเรีกยใช้ไอ้ตัวนี้มันเรียกแค่
ใช่หรือเปล่าอย่างนี้เป็นต้นนะคะ
นี่คือเมื่อ... จำไว้เลยว่าเมื่อ
ตอนจะเรียกใช้แค่พิมพ์ชื่อ
แล้วในวงเล็บนี่ เราพิมพ์
ค่าของ... เขาเรียกว่า "
Argument ลงไปแค่นั
มันชื่อนี้เวลาเราเรียกใช้มันนี่ เราเอามา
ทั้งชื่อฟังก์ชันกับวงเล็บ แต่สิ่งที่อยู่ใน
วงเล็บนี่ ก็คือเราใส่เข้าไปได้เลย
มัน... พอมันโดนเรียกใช้นี่มันจะกลายเป็น
Argument แต่ตอนที่มันเป็นฟังก์ชันนี่
ตรงในวงเล็บนี่คือ
หรือตัวแปรที่จะไว้รับค่านะคะ แต่พอ
เราเอาฟังก์ชันนั้นมาใช้งาน สิ่งที่อยู่ใน
วงเล็บจะกลายเป็น
รับเข้าไปนั่นเอง
นะคะ
นี่ นี่คือส่วนของการสร้าง
ฟังก์ชันและการเรียกใช้ฟังก์ชันนะคะ มาดูหัวข้อ
ต่อมาของเราก่อนดีกว่านะคะ เดี๋ยวเด็ก ๆ จะได้
ไปเดินงานวันวิทยาศาสตร์ต่อ
เหลืออีก 2 หัวข้อ
เดี๋ยวนะ เดี๋ยวนะ
สลับหน้าจอก่อนไม่สลับไม่ได้
โอเค
ดูส่วนต่อมานะคะ ส่วนที่เรียกว่า
"Default Argument Value"
คืออะไร มันเป็นการกำหนด
Default Argument นี่
กำหนดค่าเริ่มต้นนะคะ เป็นการกำหนดค่าเริ่มต้นให้
กับไอ้ค่า
ค่าที่เราจะส่งเข้ามาในฟังก์ชันตอนแรกนะ
ทำให้สามารถเรียกใช้งานฟังก์ชัน
โดยส่ง Argument ที่น้อยกว่าจำนวนที่กำหนดไว้ก็ได้นะคะ
ดูตัวอย่างจะเห็นภาพชัด
เห็นไหม
นี่นะคะ ในตัวอย่างนี่ สร้างฟังก์ชัน
ชื่อว่า show_info
ไม่ได้ใส่เป็นพารามิเตอร์
เห็นไหม ใส่ Argument เข้าไปด้วยเลย มี พ
Salary มี Argument =
84360 เห็นไหมคะ
นี่คือการ Defal
แล้วกำหนด Argument ให้มันด้วยเลยนะคะ แล้วก็
สร้างพารามิเตอร์ตัวที่ 2 ชื่อว่า lang
หรือ Language นะคะ มาจากคำว่า "Language"
แล้วใส่ Argument ที่ชื่อว่า Python
แล้วก็สั่งให้ print
print ที่ 1 บอกให้ print เฉพาะแค่ชื่อ
print ที่ 2
ก็คือ Argument ที่ชื่อ...
ไม่ใช่ print Argument print parameter
นะคะ ที่ชื่อ Salary เห็นไหม print Name print Salary
แล้วก็ print
ตอนเราเรียกใช้ ให้เด็ก ๆ ดูตอน Calling Function
ใน name นี่เราไม่ได้กำหนด Argument ให้เหมือน salary
กับ Lang Language
เห็นไหมคะ
พอ พอเราเรียกนะคะ เรียกใช้มันปุ๊บนี่
อันนี้ผิดนะนี่ พิมพ์ผิดขอโทษ มันต้องเป็น
Python ขึ้นมา ไม่ใช่ JAVA
เดี๋ยว ๆ ขอแก้ก่อน
ไหง มือบอกไปพิมพ์ Java สะงั้น
สะอย่างนั้น เพราะ Argument ที่เราใส่เข้าไป
ชื่อ Python นะคะ
ไม่สลับอีกแล้ว ไม่เป็นไร
เมื่อกี้กลับมาแก้
ดูนะคะ เดี๋ยว
เราจะลองทำฟังก์ชันแบบกำหนด Argument ด้วย
นะคะ
นะ เพราะฉะนั้น เปิด Colab ของเรา
ขึ้นมาไว้นะคะ
แล้วเราก็ต้องสลับ
โอเคสลับได้
โอเค สลับได้ เดี๋ยวสลับไป เดี๋ยวสลับไม่ได้ เดี๋ยวจะตีมือ
นะคะ โอเค
ทีนี้ สร้างโค้ดใหม่เลยนะ
เด็ก ๆ กด + เพิ่มโค้ดใหม่ไปเลย
จะได้ไม่ไปงงกับอันแรกนะคะ อันแรกเป็นการสร้างฟังก์ชันแบบปกติ
ที่ไม่ได้กำหนดค่า Argument ให่
มาดูแบบที่ 2 ที่เราสร้างฟังก์ชันที่มีการ...
มันทะลุจอไป
จอไป
นะคะ ฟังก์ชันแบบที่ 2
ชื่อว่า Default Argument Value
นี่นะคะ แบบที่มีการกำหนดค่า
ให้ Argument ในฟังก์ชันเลยนะคะ ก่อนอื่น เราก็ต้องพิมพ์
คำสั่ง def
d-e-f เพื่อประกาศตัวแปร... เพื่อประกาศ
ฟังก์ชัน แล้วก็ตามด้วย
ชื่อฟังก์ชัน ซึ้งในตัวอย่างใช้คำว่า "show_info"
นะคะ ไม่อยาก
ตั้งชื่อยาวกว่านี้ก็...
สังเกตนะคะ เวลาตั้งชื่อ ฟังก์
ถ้าชื่อมันเป็น 2 ประโยคนี่ เขาจะใช้ Under sco
แยกประโยคที่ 1 กับประโยคที่ 2 เห็นไหมคะ s-
h-o-w show คือ ประโยคที่ 1
show คือแสดงนะคะ แล้วตามด้วย
ประโยคที่ 2 คือ คำว่า "info"
ก็คือโชว์ข้อมูลนั่นเองนะคะ info ย่อมาจาก
information นั่นเองนะคะ
ตอนนี้เราสร้างฟังก์ชันที่ชื่อ
สร้างฟังก์ชันที่ชื่อว่า show_info นะคะ โดย
ในนั้นนี่ กำหนดพารามิเตอร์
ตัวที่ 1 ชื่อว่า name n-a-m-e
name นะคะ
แล้วมีพารามิเตอร์ที่ 2 คั่นด้วย
โคลอน ไม่ใช่โคลอน คอมมา
เรียกผิด เรียกถูกตลอดเลย
นะคะ
แล้วก็ตามด้วยชื่อพารามิเตอร์ตัวที่ 2 ซึ่งพารามิเตอร์ตัวที่ 2 นี่
เราจะกำหนดค่า
Argument ให้เขาไปเลยนะคะ เพราะฉะนั้น พารามิเตอร์
ตัวที่ 2 ชื่อว่า
ซึ่งแปลว่าเงินเดือนนั่นเองนะคะ salary
ซึ่งแปลว่าเงินเดือน อยากได้เงินเดือนเท่าไหร่เด็ก ๆ
ตรงเครื่องหมายเท่ากับใส่เข้าไปนะลูก
อันนี้กำหนดเองได้เลยนะคะ เด็ก ๆ อยากได้เม่าไหร่ เด็ก ๆ กำหนดเอง
ใส่เข้าไปเองเลย
อันนี้
เขาบอกว่าค่าเริ่มต้นที่ให้ สมมติ 20,000
หน่วย หน่วย
สิบ ร้อย พัน หมื่น นะคะ 20,000
ปุ๊บนะคะ เสร็จแล้ว
เพิ่มพารามิเตอร์ตัวที่ 3 ชื่อว่า
lang ซื้อมาจากคำว่า
ืn-g lang นะคะ
แล้วตามด้วยเครื่องหมาย =
แล้วก็ตามด้วยชื่อ...
คำว่า Python lang
ในที่นี้ภาษาเริ่มต้นเข้าบอกว่า Python
เมื่อเสร็จ
เมื่อจบ เมื่อจบ
การประกาศฟังก์ชัน ปิดด้วยเครื่องหมาย :
เสมอนะคะเด็ก ๆ
ตอนนี้เรามีฟังก์ชันที่
ชื่อว่า show_info นะคะ ดูไปด้วย
อธิบายไปด้วย มีพารามิเตอร์ทั้งหมด 3 ตัว
คือ name salary นะคะ โดยที่ salary นี่
กำหนด Argument เริ่มต้นด้วยที่ 20,000
แล้วก็มี lang โดยกำหนด Argument
ของ
Language นี่นะคะ ว่า Python
เมื่อประกาศฟังก์ชันเสร็จ
หลังจากนี้ ก็คือ 1. นะคะ print ค่ะ ให้ใช้คำสั่ง
print
print อะไรบ้าง print แรก ก็คือต้องการ
ให้ print ชื่อ
ก็จะอยู่ในเครื่องหมายคำพูด แล้วตามด้วย
ข้อความ ซึ่งในที่นี้
เราจะไม่พิมพ์เป็นภาษาไทยแล้วนะ เพื่อให้รู้ว่าตรงนี้คือสิ่งที่เราต้องการให้
ก็คือชื่อนะคะ
แล้วก็ตามด้วยเครื่องหมาย :
: ชื่อ
เปลี่ยนเป็นภาษาไทย
ใส่ %s
อย่าลืมว่าเมื่อเราใช้เปอร์เซ็นต์ ตัวอักษร
จะเป็นตัวเล็กเสมอ ไม่ใช่ตัวใหญ่ เพราะเราผิดไปแล้ว 1 ครั้งนะคะ
เราต้องจำให้ได้
แล้วไปที่หลังเครื่องหมาย
คำพูดนะคะ อยู่หลัง
เครื่องหมายคำพูดนะ เด็ก ๆ ดูดี ๆ เลื่อนตำแหน่งมานะ แล้วก็
ใส่เปอร์เซ็นต์แล้วก็เรียกพารามิเตอร์
name มาใช้นะคะ แล้วก็พิมพ์คำว่า "name"
เสร็จ
statemat ที่ 1 statemet ที่ 2
print ชื่อค่ะ พิมพ์ค่ะ
print พิมพ์ print เหมือนเดิม
แล้วบอกไม่ใช่ชื่อสิ
Salary คือ เงินเดือน ขอโทษ ในเครื่องหมายคำพูด
ใส่คำว่า "เงินเดือน" ค่ะ แปลเป็นไทยเลย
เด็ก ๆ น่าจะพิมพ์ง่ายขึ้น
นะคะ เมื่อเราต้องการ
เลขที่เป็นจำนวนเต็มนะคะ ไม่มีทศนิยมนี่ เรา
ก็ใช้ %d
พิมพ์ % แล้วก็ตามด้วย d ตัวเล็กนะคะ
โอเคไหมคะ
เราก็จะได้ Statenert
ก็คือให้แสดง... ให้ print ข้อความเพื่อแสดง
เงินเดือนนะ และตัวที่ 4 ค่ะ
เอ้ย ตัวที่ 2 ตัวที่ 3 ค่ะ
พูดผิดตัวที่ 3
ก็คือ print ภาษามันเองนะคะ
Language มาจากภาษานั่นเองนะคะ
statements ที่ 3
เราต้องการให้แสดงภาษา
เพราะฉะนั้น ในเครื่องหมายคำพูด พิมพ์คำว่า "ภาษา"
ว่าภาษา... เดี๋ยวจะงงนะ
ภาษา Python
แล้วก็ตามด้วยเครื่องหมาย Colon
ถ้าเป็นข้อความหรือ string นะคะ
สิ่งที่จะกำหนด
เพื่อให้แสดงข้อความนะคะ
ลืม
เห็นไหม รูปแบบมันจะเหมือนกัน พอหลังเครื่องหมายคำพูด
เราต้องใส่อะไรคะ % แล้วตาส
ค่าพารามิเตอร์ เช่น อันที่ 1 % name
ก็เป็นเปอร์เซ็นต์ salary เปอร์เซ็นต์ที ่
ชื่อว่า salary จำได้นะ อันที่ 3 ก็ทำ
เหมือนกันใส่เครื่องหมาย %
ใส่เครื่องหมาย % แล้วตามด้วย
ชื่อพารามิเตอร์ตัวที่ 3 คือ lang
หรือ Language ของเรานั่นเอง l-a-n-g นะคะ
เช็กนะคะ เช็ก
ตัวอย่าง เช็กจากโค้ดที่เขียนนี่ เห็นไหม ทุกตัว
จะระบุว่าเมื่อมีข้อความ
แสดงแล้ว แล้วสิ่งที่จะให้แสดง ก็คือพารามิเตอร์ที่ชื่อว่า name
พารามิเตอร์ที่ขื่อว่า na
แล้วก็พารามิเตอร์ที่ชื่อว่า lang นะคะ
แล้วในตัวอย่างมันมีบอก
print ช่องว่างอีก 1 อัน
ดูสิมันจะขึ้นชื่อว่าอะไร
p-r-i-n-t print แล้วก็ตามด้วยเครื่องหมายวงเล็บ
เมื่อเราทำการประกาศฟังก์ชันแล้วนะคะ บอกแล้วว่า
ประกาศเสร็จจะต้องมีการทำอะไรคะ เรียกใช้
ใช่ไหม callingfunction
แต่ทีนี้ตำแหน่งในการเรียก
เคอร์เซอร์เราขยับเข้ามาอยู่ตำแหน่ง print ไม่ได้
นะคะ กด Enter ลงไป 2 ครั้ง เสร็จแล้ว
กดเครื่องหมาย Backspace หรือ
ลูกศิษย์ย้อนหลัง
เห็นไหม ให้เคอร์เซอร์มันมาอยู่ตรง
ชิดขอบน่ะนะ แล้วก็
เรียกฟังก์ชัน show_info
นะคะ เราจะเรียกฟังก์ชัน show
ขึ้นมาเลย
show_
show แล้วก็ _ แล้วก็ตามด้วย info
ดูในตัวอย่างที่ 1 นะคะ show_info
แล้วก็ใส่พารามิเตอร์ชื่อลงไปให้
เดี๋ยวเผื่อไม่เห็น ขยายให้ดูก่อน อย่าลืม
นะคะพอเรียกใช้ฟังก์ชันมันจะต้องมี
วงเล็บเสมอ เห็นไหมคะ อยากให้
show พารามิเตอร์ชื่อว่า name o
นะคะ ในเครื่องหมายคำพูด
ชื่อเรา ชื่อเล่นก็ได้นะคะ ใส่ชื่อเล่นลงไป
อันนี้พารามิเตอร์แรกนี่
ตอนเรียก show... เรียกฟังก์ชัน show_ info
แสดงเฉพาะพารามิเตอร์ชื่อนะคะ
ในตัวอย่าง
เรียกฟังก์ชัน show_info
แสดงชื่อ แล้วก็เงินเดือนนะคะ
ดูนะคะ
ทำเหมือนเดิม
พมิ์ชื่อฟังก์ชันที่เราจะเรียก
ก็คือคำว่า "show" ลืมแก้ภาษษอังกฤษอีกแล้ว
s-h-o-w
show_info นะคะ
แล้วตามด้วยค่าพารามิเตอร์
ที่ต้องการให้มันแสดง ก็คือชื่อ
ขี้เกียจสลับแล้วนะ
แล้วต้องการให้มีพารามิเตอร์ตัว
ที่ 2 ก็คือขั้นด้วยลูกน้ำ
หรือ Comma นะคะ
แล้วก็ตามด้วย