(ล่าม) ฮัลโหลครับ
ฝั่งล่ามไหมครับผม
(อาจารย์สุธิรา) ได้ยินค่ะ (ล่าม) โอเคครับ
(อาจารย์สุธิรา) สวัสดีค่ะ พี่ล่ามไม่ได้ยินเรานะ
(ล่าม) ได้ยินครับ ได้ยินครับ
(อาจารย์สุธิรา) ได้ยินไหม ได้ยินนะคะ โอเค นึกว่าไม่ได้ยิน
นะคะ
สำหรับวันนี้นะคะ ในสัปดาห์นี้จะเป็น
เรื่องเกี่ยวกับ
ฟังก์ชันนะ
ใน 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
ตัวนี้เด
(ล่าม) ฮัลโหลครับ
ฝั่งล่ามไหมครับผม
(อาจารย์สุธิรา) ได้ยินค่ะ (ล่าม) โอเคครับ
(อาจารย์สุธิรา) สวัสดีค่ะ พี่ล่ามไม่ได้ยินเรานะ
(ล่าม) ได้ยินครับ ได้ยินครับ
(อาจารย์สุธิรา) ได้ยินไหม ได้ยินนะคะ โอเค นึกว่าไม่ได้ยิน
นะคะ
สำหรับวันนี้นะคะ ในสัปดาห์นี้จะเป็น
เรื่องเกี่ยวกับ
ฟังก์ชันนะ
ใน 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 แ
(ล่าม) ฮัลโหลครับ
ฝั่งล่ามไหมครับผม
(อาจารย์สุธิรา) ได้ยินค่ะ (ล่าม) โอเคครับ
(อาจารย์สุธิรา) สวัสดีค่ะ พี่ล่ามไม่ได้ยินเรานะ
(ล่าม) ได้ยินครับ ได้ยินครับ
(อาจารย์สุธิรา) ได้ยินไหม ได้ยินนะคะ โอเค นึกว่าไม่ได้ยิน
นะคะ
สำหรับวันนี้นะคะ ในสัปดาห์นี้จะเป็น
เรื่องเกี่ยวกับ
ฟังก์ชันนะ
ใน 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 นะคะ
แล้วก็ตามด้วย
ค่าพารามิเตอร์ในตัวที่ 2 เช่น เงินเดือน เงินเดือนนี่
ในในฟังก์ชันนี่
ในฟังก์ชันนี่ เรากำหนดที่ 20,000 แต่ใน
ตอนที่เรามาเรียกนี่ สมมติว่าเงินเดือนเราเพิ่มขึ้น
หรือเงินเดือนของคนคนนี้มีมากกว่า 20,000 มี 23,000
เป็น 23,000
ลงไปนะคะ ถ้า
เราต้องการให้มีฟังก์ชัน เอ้ย แสดง
พารามิเตอร์ตัวที่ 3 เราก็พิมพ์
ค่าพารามิเตอร์ตัวที่ 3 แต่เราไม่ได้เอา
= Python นี่ เราจะเอา
ภาษาอื่น เช่น ภาษา C นะคะ
ก็ใส่คำว่า c ลงไป
พร้อมจะดูผลลัพธ์หรือยังคะ
ก็คือในกรณีที่เรียงฟังก์ชันที่ 1 นี่ โชว์เฉพาะ
พารามิเตอร์เดียว เราก็พิมพ์แค่
ชื่อฟังก์ชันแล้วก็ตามด้วยพารามิเตอร์ที่เราต้องการให้แสดงพอ
แต่ใรกรณีที่
เรียกฟังก์ชันในอันที่ 2 นี่ แม่อยากให้
มันแสดงทุกพารามิเตอร์เลย แม่ก็เลยใส่เข้าไปครบ
3 อัน เห็นไหมคะ เดี๋ยวเล่นให้ดูนะคะ ว่าผลลัพธ์
ออกมาจะเป็นยังไง
นี่ เห็นไหมคะ ชื่อ เงินเดือน
เห็นไหม แบบที่ 1
แบบที่ 1 ตอนเรียกนี่
ให้แสดงแต่ชื่อ แต่มันก็จะแสดง
ที่มีอยู่แล้วขึ้นมาด้วย เห็นไหมคะ เพราะ
เมื่อเรียกฟังก์ชันนี้ปุ๊บ สิ่งที่มันจะแสดงมีอะไรบ้าง ชื่อ
มีเงินเดือน แล้วก็มีภาษา เห็นไหม
พอใส่ print แล้ววงเล็บ
มันจะเว้นให้ 1 บรรทัด เด็ก ๆ ดู
พออันที่ 2 มามันเว้นก่อนบรรทัดหนึ่ง
เด็ก ๆ ไปดูความแตกต่างกับอันแรก ที่ไม่มีเว้นบรรทัด
พอเราสั่ง print Hello
พื้นที่สี่เหลี่ยมมันก็ติดกัน เห็นไหมคะ แต่พอ
ตัวอย่างนี้ นี่
มันมี print ในวงเล็บ
เห็นไหมขั้นมาก 1 อัน
ิสิ่งที่มันแสดงมีชื่อเหมือนกัน มีเงินเดือนเหมือนกัน ภาษา
แสดง 3 อย่างเห็นไหมคะ นั่นก็คือฟังก์ชัน
ีที่ชื่อว่า show_info นี่ มันจะแสดงข้อมูลของชื่อ
ของเงินเดือนแล้วก็ของภาษาขึ้นมาทุกครั้ว
นะคะ แต่มันจะแสดงตาม
อะไรเช่น เหมือนตัวแรก แสดงเฉพาะชื่อแรก
เพราะฉะนั้น เงินเดือนกับภาษานี่มันจะไปแสดงตามค่าที่เรา
ตั้งไว้ในครั้งแรก
เห็นไหมคะ แต่พออันที่ 2 show_info อันที่ 2
แม่ไปเปลี่ยนไป แม่ไปเปลี่ยนว่า
คนนี้คนใหม่ไม่ใช่คนเดิม นิวคนละนิว
เพราะฉะนั้นเงินเดือนคนนี้
ก็เลยเปลี่ยนเป็น 23,000 ภาษาของเขา ก็เปลี่ยนเป็นภาษา C เห็นไหม
แต่มันจะรู้ว่าพารามิเตอร์ตัวที่ 2 นี่
คือ เงินเดือน มันก็จะไปแสดงที่ตำแหน่งเงินเดือน เห็นไหม
พารามิเตอร์ตัวที่ 3
มันก็ไปแสดงที่คำว่า "ภาษา" เห็นไหมคะ นี่ก็เป็น
ใช้งานฟังก์ชันที่มีการ
กำหนดค่า ค่า Argument ไว้แล้ว
นะคะ ค่าเริ่มต้นไว้แล้วนะคะ
ดูเอาแล้วกัน ว่า
แบบไหนใช้งานง่ายกว่าให้ศึกษา
ให้มองเห็นความแตกต่างนะคะ
แล้วก็มาสู่หัวข้อสึดท้ายของเรา
นะคะ เห็นไหมคะ เรา
กำหนดค่า Argument
ไปได้แล้วนะคะ ต่อมา เรื่องต่อมา
ของเราเรื่องสุดท้าย
Keyword Argument ยังเกี่ยวกับ Argument อีก มันคืออะไรกัน
keyword ชื่อก็บอกอยู่แล้ว
คือ คำสำคัญนะคะ มันจะเป็นฟังก์ชัน
ที่มีรูปแบบ
เขาบอกว่าใช้ชื่อของ
พารามิเตอร์ในการส่ง Argument
โดยพารามิเตอร์นั้นต้องมีการกำหนด
Default Argument ก่อน
เราจะต้องไปกำหนดค่าให้พารามิเตอร์ของเราก่อน ตัวแรกนะคะ
ดูตัวอย่างตัวนี้ เห็นไหมคะ
มันจะคล้ายกับอะไร คล้ายกับเมื่อกี้นี้ แต่มีข้อแตกต่าง
คือตรงไหน Keyword
สังเกต สังเกตที่อะไรเด็ก ๆ นี่ เห็นไหม
Color น่ะค่ะ
ค่าสี คือ ไปเรียก
ใช้ค่าสี
ที่เป็นรหัส เขาเรียกว่าเป็นรหัสหรือเป็นคีย์น่ะค่ะ
เช่น fff นี่ น่าจะเป็นสีขาว
หรือไม่ได้เติมสีนี่ล่ะ ถ้าจำไม่ผิดนะ ให้นึกถึงนะ
นี่คือ
มันจะไม่ใช่ค่าตัว ที่เป็นแบบข้อความ หรือ
เป็นตัวเลข
เหมือนปกตินะ ไอ้ตัวนี้ คือ สิ่งที่เรียกว่า "Keyword"
นึกออกนะ Keyword Argument
Argument ที่เป็นลักษณะ Keyword นะคะ
ไม่เป็นไร ถ้าอยากรู้มันคืออะไร
เดี๋ยวจะลองให้ดูนะคะเด็ก ๆ
ดูนะคะ ค่าสีใน... ในคอมพิวเตอร์
ดูนะคะ ค่าสี ค่าสี
ในคอมพิวเตอร์นี่มันมีหลายแบบ
นี่ เห็นไหม
ไม่สลับอีกแล้ว
ไม่ต้องการอะไรแบบนี้
เด็ก ๆ ดูนคะ
นี่คือคีย์เวิร์ดของค่าสีในคอมพิวเตอร์ โดยปกตินี่
เวลาถ้าเราเขียนโค้ดนี่
โปรแกรมมันจะรับค่าสีที่เป็นค่าสี
ฐาน 16 นะคะ RGB
แล้วก็... ค่า
สี 3 ฐาน 16 มันจะไม่รับ มันจะรับค่าสี
ตัว 0000 ff นี่ เหมือนตัวอย่างนี่ ตัวนี้
คือเป็น Keyword Argument
ก็คือมันต้องมาอ่านค่าของตัวนี้ก่อน แล้วมา
แสดงให้เห็นสีที่เราต้องการจะรู้ เดี๋ยว
ทำให้ดูนะคะ ตัวอย่างนี้ เดี๋ยวนะ
ไอ้ 00 สีอะไร
อยากรู้ว่าเป็นสีอะไร เดี๋ยวเปิด paint ให้ดูนะคะ โปรแกรม paint
จะเห็นชัดกว่า
โปรแกรม Paint นะ
เดี๋ยวไอ้นี่ไม่เห็นสิ
ไม่ใช่ paint สิ อะไรนะ Microsoft Word ก็เห็นแล้ว
เดี๋ยวนะคะ
เปิดให้ดูว่าเราจะรู้ได้อย่างไรว่าค่าสีนี้สีอะไร
เปิดใน Word ให้ดูนะคะ
ดูสีนะ เด็ก ๆ ดูที่สีนะคะ
นี่เห็นไหม
ตรงนี้จะเป็นค่าสี มันจะมีแบบ
มาตรฐานกับกำหนดเองนี่
ไอ้ตัวนี้ก็ไม่ขึ้นแบบนี้
ไม่ใช่สิ อย่างนั้นเปิดให้ดู
ตารางค่าสีเลยแล้วกันนะคะ
ชักงงเอง ตารางค่าสี
ดูนะคะ ตารางค่าสีจะเป็นอย่างนี้
อันไหนที่จะเห็นชัด
อย่างนี้นะคะ สมมติสีชมพู
นี่เห็นไหมตัวเลขสีมันก็จะเปลี่ยนไป
ลักษณะนี้นะ อันนี้จะเห็นชัดนะคะ ว่าถ้า
สีชมพูเข้มขนาดนี้
ค่าสีจะเป็นตัวนี้ อย่างนี้นะคะ
ตัวนี้ขึ้นไหม
มันก็ขึ้นอยู่ข้างในนี่
ตัวเลขที่แสดงค่าสีมันน่ะ
ถ้าอยากรู้ว่าสีไหนเป็นสีอะไร อย่างเล็ก
ไม่เอาน่ะ
ไม่โชว์แล้วน่ะ เดี๋ยวเทสต์ให้ดูเลยนะคะ
ขอเพิ่มโค้ดให้ จะทำโค้ด
แค่สร้างสีตัวเดียวเลย
เอาแค่นี้พอ
ปุ๊บ print color ขอก๊อปก่อน
ขี้เกียจน่ะ ขี้เกียจพิมพ์
copy ให้
เราไหมนี่
ไม่วางให้นะคะ ไม่เป็นอะไร
สมมติ สมมตินะคะ สร้างฟังก์ชัน
เดี๋ยวสร้างให้ดูเด็ก ๆ ไม่ต้อวง
อันนี้เป็นตัวอย่างให้เห็นว่า Key
Argument def ฟังก์ชันนี้
จะใช้ในการสร้างสีนั่นเองนะคะ
c-r-e-a-t-e create color
ใส่พารามิเตอร์ ชื่อ color นะคะ โดย
มีค่าเท่ากับ
1, 2, 3, 4,
5, 6 6 นะ
โดย
กำหนด Default Argument ที่
เครื่องหมาย # F1 F2 F3 F4
f5
ตัวที่บอกว่า f นี่ มันเป็นคีย์เวิร์ดของ
ค่าสีที่บอก เพราะฉะนั้น พอเรา
สร้างฟังก์ชันนี้ มันจะแสดงอะไรออกมา
ดูนะคะ ทำไมเผลอไปลบ
ขอโทษที มือไวจริง ๆ เลย
4
เราจะ
ให้มัน print สีนั้นออกมาให้ดูนะคะ
print color
ดูนะคะ เห็นไหม นี่
print อะไร ต้องการให้ print
=
่
ขอเพิ่มพารามิเตอร์อีกตัวหนึ่ง
คือ id นะคะ id คือ ลำดับที่นั่นเอง
เพื่อให้เห็นว่าอันที่ 1
ใส่สีนี้อะไรจะเกิดขึ้น อันนี้ประกาศตัวแปรจะเสร็จแล้ว จะเรียกใช้
มันนะคะ เรียกใช้
Create color พิมพ์ชื่อฟังก์ชัน
a-t-e
เราก็คลิกเลือก แล้วตามด้วย id ลำดับ
ที่ 1 นะคะ
ขอลอง print ก่อน
เหมือนเดิมนะคะ
ลำดับที่แล้วก็ตามด้วย :
ใช้ colon แทน
แล้วก็ % เหมือนเดิม
% ลำดับที่เป็น % อะไรนะ
%d นะคะ ตัวเลข เป็นตัวเลข
แล้วก็ตามด้วย
% แล้วก็ค่าพารามิเตอร์ ก็คือ id
พิมพ์อะไรผิดนี่ p-r-
i
p-r-i-n-t print
เดี๋ยว Run ให้ดูเลยนะคะ
syntax error ผิดตรงไหนนี่
อ๋อ
ตำแหน่ง เดี๋ยวนะ Enter เข้าไป เอาใหม่สิ
+
แม่พิมพ์อะไรผิด
p-r-i-n-t
print เอาใหม่
ลบก็ได้
ลบแล้ว print ใหม่ p-
i-n-t
print
Syntax Error Invalid
ผิดได้อย่างไรล่ะ
เดี๋ยวนะ 1
เขาก็ไม่ได้พิมพ์ผิดนี่
ทำไมมันขึ้น Error ล่ะ
1, 2, 3, 4,
เดี๋ยวนะ ขอ
ขยายก่อนนะ
1 2 3 4 5 6
ก็ตรง
อะไรนะ
ทำไม Syntax นี้ Error ล่ะ
ผิดตรงไหนนี่
ลืมอะไร ไม่ได้ลืมนี่
เอาอีกแล้ว
Syntax Error Print
print บรรทัดที่ 3 ไม่ได้ colors หรือ
มันบอกว่า print ไม่ได้น่ะ
มันจะ Error ได้ยังไงน่ะ
ถ้าลบ
จะขึ้น Error อีกไหม
ไม่รู้จัก
รันผ่าน รันไม่ผ่าน
ผิดตรงไหน
อ๋อ รู้แล้ว
อะไร
ผิดตรงไหนหรือเปล่านี่
print คำสัง Prit
โอเคนะคะ
รู้แล้ว
ตรงนิดเดียว มองไม่เห็น
ลืมใส่เครื่องหมายคำพูดตรงคาบ
ของ color นะคะ
มันก็เลยคำสั่ง print สี
นะคะ เดี๋ยวจะขอลองดู
อันนี้ถูกแล้วนะคะ
ผลลัพธ์ก็จะออกอย่างนี้ คือ พิมพ์ลำดับที่ 1 เสร็จ
มันก็จะ print สี่ที่มีค่า
คิคือ fff ขึ้นมาอย่างนี้นะคะ
ก็คือจะแสดงเป็น
Argument ที่เป็น Keyword นั่นเองนะคะ
นี่
อยากโกรธโปรแกรมดีหรือไม่ก็ไม่รู้
พอเปลี่ยนฟอนต์น่ะ มันก็มาจัด
ตัวนี้ตัวเล็กตัวใหญ่ดูยากมาก
สาเหตุ ก็คือนี่มันมี
เครื่องหมายคำพูดนี่ แต่ไม่ได้ใส่ให้มันนี่นะคะ
นะคะ
ก็คือการกำหนดค่า Argument
เหมือนกันนั้นล่ะค่ะ default
ดี ๆ แค่นั้นเอง ว่าจะให้มันเป็น
Default ที่เป็นลักษณะ... Argument ที่ให้มันแสดง
มันเป็นลักษณะไหนถ้าเป็น
ก็ต้องมาใช้รูปแบบนี้นะคะ
เขาบอก
เขาเป็น Keyword
นี่มันต้องใส่เครื่องหมายที่เป็นคำพูด
ข้างหน้าตัวนี้
พอ Run แล้วถึงจะผ่าน
ถึงจะขึ้นนะคะ
ขึ้นค่าให้
ก็คือแสดงลักษณะที่เป็นคีย์เวิร์ดแบบนี้ออกมา
สงสัย
ตรงไหนหรือเปล่าคะเด็ก ๆ ความแตกต่าง แทบไม่แตกต่าง
ว่าไม่แตกต่างกัน มันต่างกันตรงค่า
ไอ้ค่าที่เราจะใส่เข้าไปนี่ล่ะค่ะ เพราะตัวนี้ ลักษณะ
คือมันเป็นค่าของเขาเรียกว่าอะไรนะ
เขาเรียกว่า "
เป็น code สีนะ
รหัสสี ซึ่งความจริง ก็คือถ้าเราใส่สีแดง
สีชมพูอะไรอย่างนี้ แต่อย่าลืมว่าสีในคอมพิวเตอร์น่ะ
มันแยกเฉดอีก เหมือน
อย่างนี้ ชมพูเข้ม
มันก็จะเป็น #ec407a
เปลี่ยนไปตามความเข้มความอะไรอย่างนี้ด้วยนะคะ
เหมือนสีฟ้านี่ ค่าเขาก็จะเปลี่ยนไปตาม
ที่เห็นนนะคะ
นั่นก็คือเป็นคีย์เวิร์ดหรือคำสำคัญ
คือคอมพิวเตอร์น่ะจะรู้นะ คอมพิวเตอร์
เขาจะรู้จัก ว่าอย่างนั้นเถอะนะคะ
ถ้าไม่มีใครสงสัย
ในฟังก์ชันนะคะ คือ ที่เราจะทำจริง ๆ นะ
มันก็จะมีแบบที่ 1 น่ะ
กำหนดฟังก์ชันขึ้นมานะคะ อย่างนี้ แล้วก็ตามด้วยพารามิเตอร์
กับแบบที่ 2 ที่มีการกำหนด
ฟังก์ชัน มีพารามิเตอร์ แล้วในพารามิเตอร์
กำหนด Argument ลงไปเลยอย่างนี้ก็ได้
ได้ทั้ง 2 แบบ แล้วแต่จะเลือกใช้งาน แล้วแต่วัตถุประสงค์
การที่จะสร้างฟังก์ชัน
สำหรับสัปดาห์นี้นะคะ เราก็จะจบ
บทเรียนหลักการเขียนโปรแกรม
ของเราในเทอมนี้เพียงเท่านี้นะคะ
สัปดาห์หน้าจะให้เบรก
เดี๋ยวสอบแล้วจะนัดแนะอีกทีหนึ่งนะคะเด็ก ๆ
มีใครสงสัยไหม ถามได้
ถ้าไม่มีจะปล่อยแล้วนะคะ
อย่าลืมออกจากระบบทุกครั้งด้วย
เพราะอย่าลืมว่าแล็บไม่ได้แต่เราใช้คนเดียวนะ
เมื่อเลิกใช้เราต้องออกจากระบบของเราทุกครั้งนะคะ
ขอบคุณพี่ล่ามค่ะ สำหรับการเรียนในวันนี้ขอบคุณค่ะ
มันชอบมาเปลี่ยนฟอนต์ให้
เครื่องที่มี
-
(ล่าม) ฮัลโหลครับ
(อาจารย์สุธิรา) สวัสดีค่ะ พี่ล่ามไม่ได้ยินเรานะ
ฝั่งล่ามไหมครับผม
(อาจารย์สุธิรา) ได้ยินค่ะ (ล่าม) โอเคครับ
นะคะ
สำหรับวันนี้นะคะ ในสัปดาห์นี้จะเป็น
(ล่าม) ได้ยินครับ ได้ยินครับ
(อาจารย์สุธิรา) ได้ยินไหม ได้ยินนะคะ โอเค นึกว่าไม่ได้ยิน
ใน Python
เราจะต้องมาเรียนเบื้องต้นนี่ ก็คือต้องมารู้จัก
เรื่องเกี่ยวกับ
ฟังก์ชันนะ
นะคะ หัวข้อที่
เราจะเรียนในสัปาดาห์นี้นะคะ จะเป็น
สิ่งที่เรียกว่า Function ก่อนนะคะ
วันนี้เราจะพูดถึงการ
นะคะ การเรียกใช้งาน
หัวข้อสุดท้ายของปีนี้
เทอมนี้นะคะ ภาคเรียนนี้ ก็คือฟังก์ชัน
นะคะ อ้าวทำไมหน้าจอไม่ขึ้น
แล้วก็พูดถึง
Default Argument Values แล้วก็ Keyword Argument
โอเคนะคะ ก่อนอื่น
อีกแล้ว...
คือ ถ้าพูดถึงโดยทั่วไปนะคะ
ก่อนจะรู้วิธีการสร้าง
การเลือกใช้งานนี่ เราก็ต้องรู้ก่อนว่าฟังก์ชันมันคืออะไรนะคะ
สั่งพิเศษ
ีที่ให้ทำงานเฉพาะสิ่งใดสิ่งหนึ่งนะคะ
ก็คือถ้าเราเป็นโปรแกรมเมอร์หรือ
ในวิธีการเขียนโปรแกรมคอมพิวเตอร์นี่ ฟังก์ชันมันจะเป็น
ในส่วนของภาษา python
ฟังก์ชันจะเป็นโค้ด หรือโปรแกรมที่เรา
ซึ่งแต่เดิมนี่ฟังก์ชันมันจะเป็น
ที่เขาพัฒนาไว้แล้วก็มี แต่ใน Python นะคะ
เหมือนตั้งขึ้นมาว่าฟังก์ชันนี้จะตั
นะคะ เช่น
สร้างขึ้นได้เองนะคะ
เพื่อเอาไปใช้กับ...
แล้วไปเรียกฟังก์ชันนี้มาเพื่อให้มัน
ทำกาารคำนวณค่านี้ให้อย่างนี้นะคะ นั่นคือจุดประสงค์
เหมือนบางครั้งนี่ การคำนวณบางอย่าง
ไม่จำเป็นต้องไปเขียนโค้ดใหม่ทุกครั้ง เราก็เลยสร้างฟังก์ชันไว้เลย
บอกแล้วว่าในสัปดาห์นี้เราจะสร้าง
ขึ้นมาใช้งานเองนะคะ แล้วเมื่อสร้างเสร็จแล้วนี่
จะนำไปใช้ในสิ่งใดสิ่งหนึ่งนะคะ
เป็นการเฉพาะ โดยใน
มาใช้โดยวิธีการใด
หรือเรียกใช้อย่างไรนะคะ แล้วก็จะพูดถึง Default Argument
จะต้องรู้ว่า
มันจะต้องเรียกฟังก์ชันที่เราใช้งานนี่จะถูกเรียก
กระบวนการที่เราจะต้องทำ
ก็คือเมื่อเราจะทำฟังกชันขึ้นมา
ด้วยว่ามันคืออะไรแล้วก็ Keyword Argument ด้วย
ว่ามันคืออะไรนะคะ ทีนี้ก็จะเริ่มเข้าสู่
ใน python
เราสามารถสร้างขึ้นเองได้นะคะ โดย
เราจะสร้างมันอย่างไรนะคะ
การสร้างฟังก์ชันใน Python นะคะ
ที่ที่บอกแล้วว่ามันสามารถ
ทำงานสิ่งใดสิ่งหนึ่งได้
วิธีการนี้นะคะ จะเป็น
ให้นึกถึงว่าเราจะเป็นคนเขียนโค้ด
ใช้ code นี้ซ้ำได้
ถ้าจะทำฟังก์ชันมาใช้งาน มันควรเป็น
แล้วเอาไปเรียกใช้ซ้ำได้อีกนะคะ จะเรียกว่า
"การนำโค้ดนี้กลับมาใช้" นี้ว่า "Code Reuse"
เราจะหาค่า vad นี่
คือ ถ้ามาเขียนโค้ด เราต้องมานั่งเขียนว่า Vat เกิดจากการ
ตัวที่เหมือน
สามารถเรียกใช้ได้บ่อย ๆ เช่น สมมตินะคะ
การที่เอาราคาสินค้ามาคูณกับ
ปริมาณที่ 7 เปอร์เซ็นต์เท่ากับเท่าไหร่ แล้วจะทำอย่างไร
ที่เอา
7 เปอร์เซ็นต์น่ะค่ะ Vat ก็คือ 7 เปอร์เซ็นต์ใช่ไหมคะ
นะคะ แล้วพอครั้งหน้าจะใช้ก็
เอาไปใช้ได้ หรืออย่างอื่น หรือคนอื่นจะเอาไปใช้ได้
เราจะให้รู้ว่าตัวนี้เป็นค่า Vat เราก็อาจจะ
สร้างฟังก์ชันสำหรับการคิด Vat ขึ้นมาอย่างนี้
ขั้นตอนในการสร้างนะคะ
ก็คือมันจะมีรูปแบบ เราจะต้องเขียนโค้ด
เมื่อรู้ว่าแต่ต้องรู้ด้วยนะว่า
มีฟังก์ชันนี้อยู่ อย่างนี้นะคะ ทีนี้
de
นั่นก็คือการประกาศตัวแปรนะคะ
น่ะค่ะ เขียนโค้ดให้ฟังก์ชันเราโดยตามรูปแบบ
ในที่เห็นนะคะ จะต้องมีคำว่า "def"
แล้วตามด้วย function_name
บอกให้รู้ว่านี่นะ ฉันจะประกาศ
จะประกาศค่า ประกาศฟังก์ชัน ไม่ใช่ประกาศตัวแปร พูดผิด
ให้เห็นว่าคำว่า def นะคะ
ตัวเล็กเท่านั้นนะคะ ไม่ใช่พิมพ์ด้วยตัวพิมพ์ใหญ่
เราต้องพิมพ์ d-e-f พิมพ์ด้วย
ตัวเล็กเสมอ ถึงได้ทำเป็นสีแดง
เราต้องพิมพ์คำว่า def
เป็นตัวแรกนะคะ แล้วตามด้วย function_name function_name
นึกออกนะนะคะ
ก็คือทุกครั้งที่พอจะมีการสร้างฟังก์ชัน
ให้นึกถึงฟังก์ชันเนม
ตั้งชื่อให้ตัวแปร แต่อันนี้เป็นการตั้งชื่อ
นั่นก็คือชื่อ ชื่อ
ของฟังก์ชันที่เราจะไว้เรียกใช้ในครั้งต่อไป เราจะเป็นคนตั้งเอง
ใส่ชื่อฟังก์ชันเราต้องต้องพิมพ์วงเล็บ
เสมอนะคะ แต่ถ้าเราพิมพ์ใน Colab ตัววงเล็บนี้จะ
ฟังก์ชันนี้คือฟังก์ชันอะไรนะคะ เสร็จ
แล้วก็จะมีวงเล็บ พอใส่คำว่า "def" แล้วก็
พารามิเตอร์
ถ้าเป็นเขียนโค้ดปกติ มันก็จะหมายถึงตัวแปร
ขึ้นมานะคะ แล้วส่วนข้างในนี่
นะคะ เขาบอกว่ามันเป็นการกำหนดค่า Paramiter
อะไรล่ะ เขาเรียก
นี่ เขาบอกว่าพารามิเตอร์ของฟังก์ชันนี่
นะคะ แต่ในฟังก์ชันนี่เราจะ
เรียกว่า "พารามิเตอร์" เพื่อไว้สำหรับ
พารามิเตอร์ตัวนั้นก็จะเป็นตัวเก็บให้เรา
สมมตินะคะ สมมติเราต้องการตำนวณหาค่า
มีจำนวนเท่าไรก็ได้ ก็คือในฟังก์ชันนี้
เราจะมีการเก็บค่าของอะไรบ้าง
ค่าของรัศมีวงกลม
หรือมีค่าของอะไรนะ
พื้นที่
วงกลมอย่างนี้นะคะ ค่าพารามิเตอร์ที่จะเก็บก็อาจจะมี
นี้นะคะ เสร็จแล้ว
เมื่อพิมพ์ function_name ใส่ค่าพารามิเตอร์
เส้นรอบวงอะไรอย่างนี้เข้ามานะคะ นั่นก็คือ
ค่าพารามิเตอร์ที่เราจะไว้เก็บข้อมูลในฟังก์ชัน
สังเกตนะคะ เมื่อใดที่
ตัวนั้นจะต้องปิดด้วยเสมอ แล้วขึ้นบรรทัด
อะไรเสร็จ เราจะปิดคำสั่ง
การประกาศฟังก์ชันด้วยโคลอนเสมอนะคะ
แล้วเด็ก ๆ สังเกต
ดูนะคะ ว่าในการประกาศฟังก์ชันตัวที่ 1
ใหม่มันจะเข้าสู่ย่อหน้าใหม่
ตัว statements ในที่นี้หมายถึงคำสั่งอื่น ๆ นะคะ
คือการคืนส่งค่าคืนกลับ
ซึ่งฟังก์ชันที่เราเขียน อาจจะ
นะคะ กับตัวที่ 2 ตัวที่ 2
จะมีคำว่า return value return ก็
รูปแบบนี้ให้เห็นทั้ง 2 แบบ
เป็นแบบที่ไม่มีการ return ค่า
เขียนแล้วมี return หรือ
ไม่มีก็ได้นะคะ แต่ที่เขียนให้ดูเป็นตัวอย่างนี่ ให้เห็น
เราต้องพิมพ์คำว่า return ด้วย
ตามด้วยค่าที่เราต้องการให้ส่งกลับ เช่น เดี๋ยวดู
แต่แบบที่ 2 นี่มี มีการส่งคืน
ค่ากลับ ก็เลยจะมีคำว่า "return value" ก็คือ
ค่าที่ส่งกลับนั้นจะเรียกว่า
นะคะ
ในตัวอย่างจะเห็นชัดนะคะ เดี๋ยวยกตัวอย่าง
แล้วจะมองภาพไม่ออก ซึ่งเขาบอกว่า
ตัวแปรแลลไม่มีการ return
ไม่มีคำสั่ง return เพื่อคืนค่านี่ ใน
ทีนี้เรามาดูตัวอย่างแรกก่อน
เพื่อจะให้เห็นว่าถ้าเราต้องการประกาศ
hello()
def ก็คือ definition
ตัวอย่างนี้เราจะประกาศตัวแปร
ชื่อ เห็นไหมคะ ตรง def แล้วตามด้วย
คือ def
แล้วก็ตามด้วย function_name ซึ่งในที่นี้ตั้งชื่อว่า
ก็คือคำสั่งเพื่อใช้
และติดประกาศตัวแปร ประกาศฟังก์ชัน ขอโทษทีนะคะ
นะคะ แล้วทีนี้
พอเวลาเรียกใช้ฟังก์ชันนี้นะคะ มันจะสั้น
hello นะคะ ฟังก์ชัน hello ก็คือ
ฟังก์ชันที่เราต้องใช้เพื่อแสดงคำทักทายออกมานั่นเอง
แล้วตามด้วย พารามิเตอร์หรือ
ที่เราไว้เก็บค่า ก็คือ name นะคะ เสร็จแล้ว ตาม
นึกออกนะ การเขียนโค้ดมันจะสั้น
กว่าที่เราเคยทำ
นะคะ แสดงคำทักทาย
ชื่อที่เรารับค่าเข้าไปนี่ หรือพารามิเตอร์ที่เรา
ด้วย statement ตามด้วยข้อความหรือคำสั่ง
หรือโค้ดอะไรก็แล้วแต่นะคะ ซึ่งในทีนี้เราต้องการให้แสดง
ไปที่ web browser
แล้วเปิดเหมือนเดิมนะคะ พิมพ์คำว่า "Colab" น่ะ
ส่งเข้าไป ก่อนอื่น เด็ก ๆ
เปิด Colab หรือยังคะ เปิด Colab ด้วย
แล้วกด Enter เลย
เพราะสังเกตว่าเว็บไหนที่เราเปิดมันจะ
c-o ต้องบอกว่า co สิ
Colab l-a-b นะคะ พิมพ์ l-a-b
ที่เราใช้งานนะ แล้วก็คลิก
อัตโนมัติเด็ก ๆ กด Enter ได้เลนย
มันก็จะเข้ามาหน้า
run มันไม่ได้นะคะ เด็ก ๆ อย่าลืม
ลงชื่อเข้าสู่ระบบด้วย Login เข้าไปด้วย
Code นะคะ ลืมไป
อย่าลืมทำอะไรก่อน เข้าสู่ระบบนะ ไม่อย่างนั้นเราจะ
ของเราให้เรียบร้อยด้วย
นะคะ
ไปที่เขียน code เหมือนเดิมนะคะ เด็ก ๆ
กดที่คำว่า "code" นะคะ ในบรรทัด
โอเคนะคะ เสร็จแล้วเราก็เริ่ม
de แล้วกฌ f
ใช่ไหมคะ พิมพ์ด้วยตัวพิมพ์เล็กเสมอนะคะ
แรกของเรานะคะ เราก็เริ่ม
ประกาศฟังก์ชัน โดยพิมพ์คำว่าอะไรคะ
ตัวใหญ่นี่ถือว่าไม่ถูกต้องนะคะ
def นะคะ แล้วก็กด
ไม่ใช่พิมพ์ใหญ่แบบนี้นะ ไม่ใช่พิมพ์ D-e-f
Def แบบนี้ ตัวใหญ่นี่ถือว่าไม่ถูกต้องนะคะ
แล้วตามด้วชื่อของฟังก์ชัน
ชื่อของฟังก์ชัน ในตัวอย่างเรา ชื่อว่า Hello
Space bar เพื่อวรรค 1 ครั้งนะคะ
บอกแล้วว่าวิธีการประกาศฟังก์ชัน ก็คือพิมพ์คำว่า "def"
นะคะ ไม่ใช่ตัวพิมพ์ใหญ่นะคะ
ดูดี ๆ นะคะ เพราะฉะนั้น
ทีนี้มาดูชื่อ ชื่อของฟังก์ชันนี่
ก็ต้องใช้ตัวพิมพ์เล็กเหมือนกัน
e-
l-l-o แล้วก็ใส่วงเล็บเข้าไป
พิมพ์ตัว h
ด้วยตัวพิมพ์เล็กนะคะ h-
name นะคะ ตัวพิมพ์เล็ก
เพราะมันเป็นตัวแปรชื่อว่า name เมื่อ
แล้วก็ตามด้วย
พารามิเตอร์ ในวงเล็บพารามิเตอร์ของเรา ก็คือคำว่า "
แล้วกด Enter 1 ครั้ง
ใช้วิธีกด Enter นะ ไม่ใช่เลื่อนเมาส์
เสร็จฟังก์ชันใช่ไหม
เสร็จคำสั่งฟังก์ชันต้องปิดด้วยเครื่องหมายโคลอนเสมอ
Stagement
หรือคำสั่งต่อไปที่เราจะใช้ ก็คือคำสั่งแสดง
ลงไป สังเกตบอกแล้วพอกด Enter นี่
ตำแหน่งของเคอร์เซอร์มันจะ Tab เข้าไปนะ
n-t
print แล้วก็ตามด้วยวงเล็บเหมือนเดิม print อะไร
ผลนะคะ ก็คือคำสั่ง print
p-r-i
เดี๋ยว
อ๋อ ขอโทษ ไม่ได้สลับหน้า
สิ่งที่อยู่ในวงเล็บอย่าลืมนะคะ เมื่อใดที่
บอกให้พิมพ์วงเล็บนี่ สังเกตมันจะมี () ขึ้นมานะ
เราก็ว่าอยู่แต่เด็ก
พิมพ์ตามใน PowerPoint แต่อยากให้เห็นใน Colab
มันไม่สลับหน้า
ตลอดเลย
นั่นน่ะสิ
เดี๋ยวเลื่อนไอ้นี่เอาก็ได้นะ
เพราะว่าเมาส์หาย
เมาส์จ๋า เมาส์จ๋า
ไอ้ตัวข้อความด้วย
เดี๋ยวสิ้นสุดการนำเสนอก่อน
โอเคนะคะ นะ
ในนี้จะพิมพ์คำว่า "print" นะคะ เดี๋ยวจะโชว์
โอเคไหม
เดี๋ยวนะ กำลัง
เดี๋ยวให้เห็น 2 หน้า
ด้วยกัน ไม่สิ ไม่สิ
โอเคน่า
จะได้เห็น 2 อย่างนะ เห็นไหมคะ จะมาที่คำสั่ง print ของเรานะ
หามุม มุมให้เธออยู่
แป๊บหนึ่ง
ขยับ
แล้วในวงเล็บของ print
ลืมทำให้มันขึ้น 2 หน้าคู่กัน เดี๋ยวนะคะ
ขอ 2 ทำไมได้ 4 นี่
เดี๋ยวนะ เดี๋ยวจะ
ได้ไหม
ไม่เห็นหน้านี้อีก
แล้วก็
กระเถิบ
โอเคไหม
อีกหน่อยหนึ่ง นะคะ
ไม่เห็นในสไลด์อีกสิ
ส่วนแบ่งทางการตลาดเยอะ
แล้วตามด้วย
เห็นไหม ตรงก่อน... ตรงก่อน Hello มี
วงเล็บในวงเล็บของคำว่า "print"
เราจะ print คำว่า "hello" นะคะ
แล้วค่อยพิมพ์ Hello ด้วยตัวใหญ่
แล้วก็ตามด้วย
เครื่องหมายคำพูดนะดูดี ๆ อาจจะเห็นไม่ชัด
ใส่เครื่องหมายคำพูดนะคะ Single Quote หรือ
แล้วหลังเครื่องหมายคำพูด
เด็ก ๆ ต้องเลื่อนไอ้ตัวนี้ไปหลังเครื่องหมายคำพูดนะ
เครื่องหมาย % %s
นั่นคือ ข้อความนี้เป็น String นะคะ
name ตัวเล็กนะ ดูดี ๆ นะ เราเรียกใช้ เราสร้าง
พิมพ์ % name
แล้วก็พิมพ์เปอร์เซ็นต์ แล้วตามด้วย
นี่คือเสร็จฟังก์ชันนี้แล้ว
ลองเรียกใช้งาน ลองกด Play ก่อน
พารามิเตอร์ด้วย name ตัวเล็กเวลาเรียกใช้ก็ต้องใช้ตัวเล็ก
นะคะ
ที่เรา code
ที่เราเขียนไปนี่มันถูกไหม ถ้าผิดมันจะขึ้น Error ใช่ไหมคะ
ขอโทษ เราจะได้รู้นะคะ
การกดตัวนี้นะ เพื่อจะได้เช็กว่า
มันก็จะยังหมุนติ้ว ๆ อยู่นะคะ เราก็ต้องรอนะคะ
ครั้งแรกเวลาโค้ดมันก็จะช้านิดหนึ่ง
แสดงว่าไม่มีอะไรผิดนะคะ
ไม่ทำอะไรนะ เพราะฟังก์ชันสร้างขึ้นมา สร้างแล้ว
นะคะ ตอนนี้คือสร้าง
เพื่อให้คอมพิวเตอร์มันจำ จำไว้ว่าตอนนี้เราสร้าง
แล้วอย่าลืมว่ามันจะต้องมีการเรียกใช้ นึกออกนะ
ต้องสร้าง สร้างเพื่อให้มันไปโดนเรียกก่อน มันถึงจะทำงาน
เพื่อจะให้ตรวจสอบว่า
โค้ดที่เราเขียนไปมันถูกหรือเปล่า ถ้าผิดมันจะแสดง Error
ฟังก์ชันชื่อว่า hello แล้วนะคะ
ที่ให้กด Run นี่
ของใครขึ้น Error ยกมือ
สิ่งที่ต้องเช็ก ก็คือ 1. คำสั่ง
นะ ถ้าเขียนไม่ผิดมันก็ไม่แสดงใช่ไหมคะ
นี่ลอง Run แล้วนะคะ Error ไม่ขึ้นนะคะ
ก็คือชื่อฟังก์ชัน
ใช้ตัวเล็ก และตัวที่ 3 พารามิเตอร์ พามิเตอร์จะ
d-e-f นะคะ definition
การประกาศฟังก์ชัน ตัวที่ 2
การประกาศฟังก์ชันด้วย
โคลอนเสมอนะคะ
มีค่าอยู่ในวงเล็บเสมอ
นะคะ เสร็จแล้วต้องปิด
ประกาศฟังก์ชันที่ 1 ไปแล้ว
มาดูแบบที่ 2 นะคะ ฟังก์ชัน
ทีนี้เมื่อกี้
สลับไปสลับมา
กันอยู่นี่ล่ะเรา อันนี้ อันนี้แบบไม่มี
ที่มีการ return หรือส่งกลับค่า
เดี๋ยวขยายหน้าไอ้นี่ให้ก่อน
เราใช้เราสร้างฟังก์ชันนี้
ขึ้นมาเพื้อต้องการให้มันแสดงข้อความ เอา
return ค่านะ
ในตัวอย่างนี่เราสร้างฟังก์ชันชื่อ hello นะคะ
ตัวนี้
ทำไมหนก่อนไม่เห็นมี หรือเพราะเป็น
อีกแล้วอะไรอีกหว่า
สลับจอไม่ได้เลย น่าจะเป็นกับไอ้
เป็นปัญหาในการใช้งาน
จะได้ใช้ Windows อื่นเสียล่ะมั้ง
ไอ้นี่บ่ะ Windows 11 นี่บ่ มันถึงขึ้น
ไอ้สลับไอ้จอไอ้นี่ทุกทีเลย แล้วก็
เราจะประกาศฟังก์ชัน
มีการใช้ return value หรือการคืนค่ากลับ
สลับไอ้จอไอ้นี่
นะคะ มาดูตัวอย่างที่ 2 นะคะ
โดยมีพารามิเตอร์ 2 ตัว
width แล้วก็ความ... width แล้วก็
ในตัวอย่างที่ 2 เป็นการประกาศ
ฟังก์ชันที่ชื่อว่า area()
กว้างคูณยาว
เพราะฉะนั้น ค่าพารามิเตอร์ที่ไว้ใช้สำหรับเก็บค้า
height ซึ่ง area ในที่นี้ึ
พื้นที่ สูตรการหาพื้นที่สี่เหลี่ยม ก็คือ
ว่า width
นั่นเองนะคะ เสร็จแล้วปิดด้วยโคลอน
ก็คือค่าความยาวกับความกว้าง
นั่นเองนะคะ ก็เลยตั้งชื่อตัวพารามิเตอร์ 2 ตัวนี้
สำหรับคำนวณ
ความกว้างคูณความยาว ก็คือคำนวณ
Statement ต่อมาสร้างตัวแปร
ชื่อว่า C ตัวแปร C
นะคะ ก็คือให้ส่งกลับค่าของ c
ก็คือเมื่อเอาพารามิเตอร์มาคำนวณแล้วนี่ c จะได้เท่าไหร่
หาพื้นที่ของสี่เหลี่ยมนั่นเองนะคะ
แล้วทำการ return ค่า c
แบบมีการ return ค่า
เพราะฉะนั้น บางคน
ส่งกลับค่าให้ c นะคะ
นี่คือการประกาศฟังก์ชัน
แล้วมันก็จะไม่ขึ้นไอ้หน้านี้
คีย์ใน Colab ไปเรียบร้อยแล้วนะคะ
เรามาเริ่มคีย์ของเราด้วยนะคะ
มันไม่สลับ Extend หรือ
อีกแล้ว มันเป็น
อะไรกับ...
โอเค ต้องสลับ
มันไม่ขึ้นหน้าจออีกแล้วน่ะ
อย่างนั้นก็ต้องมาจัดไอ้นี่ใหม่อีกแล้วนี่
2 รอบเชียวหรือนะคะ
เอาไว้ก่อน
ไม่เห็นตัวหลังอีก เอา
ไม่เห็นอีก มัน
เห็นไหม
แป๊บนึงนะสลับหน้าก่อน
โอเคไหม
น่านักเชียว
ไปไหนแล้ว
Colab
ที่ 2 ต่อด้วยฟังก์ชันแรกได้เลยนะคะ
เมื่อหลังฟังก์ชันแรกเรากด Enter กดลงไป
นะคะ
เราประกาศฟังก์ชัน
ตำแหน่งตรงกับชิดขอบ
แล้วก็เริ่มพิมพ์คำสั่ง definition
2 อันเลยก็ได้เด็ก ๆ สังเกตตำแหน่งมันจะ
Tab เข้าไปนะ เรากดย้อนคืน 1 ครั้ง
วรรคตามด้วย area
ตัวเล็กนะคะ
d-e-f เพื่อประกาศใช้คำสั่งฟังก์ชัน
ที่ชื่อว่า... ชื่อฟัง์ชันของเราชื่อว่า area() นะคะ
จะต้องมีพารามิเตอร์อยู่ในวงเล็บ
ก็คือพารามิเตอร์ตัวที่ 1 ชื่อว่า width w-
แล้วก็
ตามด้วยเครื่องหมายวงเล็บ เพราะบอกแล้วมีชื่อฟังก์ชัน เสร็จแล้ว
ขั้นพารามิเตอร์
ตัวต่อไป ด้วยเครื่องหมาย
i-d-
t-h นะคะ คั่น
นะคะ แล้วก็ตามด้วย
ชื่อพารามิเตอร์ตัวที่ 2 นะคะ ก็คือ h
Comma
นะ คอมมาหรือไอ้ลูกน้ำเรา
นั้นเองนะคะ มีพารามิเตอร์
สำหรับเก็บความยาวกับความกว้างนะคะ ก็คือ width กับ height
-i-
h-e-i-g-h-t height หรือสูง
เสมอ
เมื่อเราประกาศฟังก์ชันเสร็จแล้วนะคะ เรา
ปิดการ
ประกาศฟังก์ชันของเราด้วยเครื่องหมายโคลอน
อัตโนมัตินะคะ
เสร็จแล้วเราประกาศตัวแปร ชื่อว่า c เพื่อ
กด Enter เพื่อไปพิมพ์
Statements ใหม่นะคะ เคอร์เซอร์มันจะ Tab เข้าไป
เพราะสูตรการหาพื้นที่สี่เหลี่ยม
กว้างคูณยาวนะ เพราะฉะนั้น เราอยากรู้พื้นที่สี่เหลี่ยม
ทำการคำนวณค่าพารามิเตอร์ 2 ตัวของเรา
ก็คือเอา width
เมื่อเราพิมพ์นี่ ให้เรา
width w-i-d-t-h เพราะอย่างนี้ทำให้เรา
เอากว้างไปคูณกับยาว เพราะฉะนั้น ก็ต้องเอาพารามิเตอร์ width
ตัวนี้เด็ก ๆ ดูนะ
เครื่องหมาย คูณในที่นี้ก็คือเครื่องหมายดอ
ตัวแปรทางคณิตศาสตร์ของโปรแกรม
พิมพ์พารามิเตอร์หรือตัวแปรที่เราสร้างไว้
ไม่ผิดนะคะ แล้วใส่เครื่องหมายคูณ
พารามิเตอร์ตัวที่ 2
h รอสักพัก แล้วหาคำว่า "height" นะคะ
คอมพิวเตอร์เครื่องหมายคูณ ก็คือเครื่องหมายดอกจันนะคะ
แล้วตามด้วย
เห็นไหมคะ เจอตัวนี้ปุ๊บ
คลิกเลย เพราะบางคนจะมีปัญหา เมื่อ
h-e-i-g-h-t
อาจจะพิมพ์ h-e ก็ได้ น่าจะขึ้น
Error
เพราะฉะนั้น ตัว Colab นะคะ
ชื่อตัวแปรหรือพารามิเตอร์เริ่มยาวหรือยาก
จะพิมพ์ผิด แล้วพอพิมพ์ผิด พอไป Run โค้ดมันจะเกิด
เห็นนะคะ พอเราเห้นเราคลิกเลือกมันได้เลย
นะคะ เมื่อได้
ที่ดีเลย คือ เมื่อเราพิมพ์
ตัวแรกขึ้นมา ตัวแปรตัวนั้นมันก็จะขึ้นมาให้
คำสั่งหรือ code ของ
นะคะ แล้วในบรรทัดต่อไป เราจะใช้
Statement เพื่อการคำนวณแล้ว
ต่อไปเราจบ
พิมพ์ด้วยตัวเล็กนะคะ
ค่าที่เราต้องการให้แสดง หรือ...
คำสั่งในการคืนค่าหรือ return value
โดยการพิมพ์คำว่า "return"
ค่าของการที่เราคำนวณพื้นที่
c นั่นเองนะคะ เพราะฉะนั้น return c ตามด้วย c
หรืออะไรก็แล้วแต่ ซึ่ง
ค่าที่เราต้องการให้มันแสดงหรือเห็นนี่ ก็คือ
เหมือนเดิมนะคะ
เพื่อเป็นการเช็กโค้ดของเรา ก็คือกดตัว
ไม่มั่นใจก็คลิก c
ที่มันขึ้นมาอย่างนี้นะคะ
ว่า code ที่เราเขียนนี่
ถูกต้องแล้วนะคะ มีใคร
Play ที่เป็นรูปเหมือนเป็น
Play Video Play Music อะไรพวกนี้ ให้มันเช็ก
แล้วนี่คือ
การประกาศใช้ฟังก์ชัน หรือการสร้างฟังก์ชัน ทีนี้
ขึ้น Error ไหมคะ
ไม่มีนะคะ แสดงว่าเริ่มมีความชำนาญในการโค้ดแล้ว
เราต้องไปเรียกใช้งาน
มันถึงจะแสดงไอ้ผลพวกนี้ออกมาได้
บอกแล้วว่าเมื่อสร้างเสร็จแล้วนี่
ไม่เห็นผลอะไรเลยใช่ไหม พอเรากด Play นี่
ไม่สลับโหมดแล้วนะ
เดี๋ยวสลับไปสลับมา เราก็ เราก็แก้
เพราะฉะนั้น เราจะมาดูเนื้อหา
ต่อไปนะคะ ก็คือ...
ขอย่อให้มันพอดีหน่อย
โอเค
ไม่ได้อีก เดี๋ยวเสียเวลาในการแก้โหมด
หน้าจอนะคะ
โหมดเป็นยังไงนี่
ขึ้นไหม ขึ้นอยู่ โอเค สลับได้
ก็จะเล็กไปอีกใช่ไหมถ้าย่อ แล้วสลับ
เมื่อสร้างเสร็จแล้ว
มันต้องเรียกใช้เสียก่อนนะคะ เราถึงจะรู้ว่าฟังก์ชันที่เราสร้าง
นะคะ เมื่อกี้บอกแล้วว่าถ้าเรา
ทำใน Colab เป็นการสร้างแล้วนะ ต่อมา
ก็คือในนี้
พอเราสร้างฟังก์ชันแล้วนะคะ เราต้องเรียกใช้งานมัน วิธีการเรียก
มันใช้งานได้จริงไหมนะคะ
การเรียกใช้งานฟังก์ชันนะคะ
และส่ง อาร์กิวเมนต์
อะไร เมื่อกี้มีพารามิเตอร์ มามี Argument อีก
ใช้ ก็คือเราจะใช้ชื่อของ
ฟังก์ชัน เห็นไหมคะ
ก็เป็นคำ ไม่ใช่คำ
เป็นค่าที่เราส่งเข้าไปในฟังก์ชันนะคะ
Argument กับ Parame
เดี๋ยวมีคำอธิบายนะคะ ว่า Argument
ในฟังก์ชันเพื่อรับค่า
เมื่อกี้พารามิเตอร์ที่เรามีตัวที่ 1 ชื่อว่า
ตอนที่เราใช้งานนะคะ
ส่วนพารามิเตอร์น่ะ คือ ตัวแปรที่เรากำหนด
มันรับค่านั่นเองนะคะ
มาดูตัวอย่างวิธีการเรียกใช้ฟังก์ชันนะคะ
name นั่นคือตัวแปรที่เราใช้รับค่า
เพราะฉะนั้น Argument ก็คือชื่อที่เราจะพิมพ์เพื่อให้ตัวแปร
อะไรพิศดาลเลยเพียงแต่เราพิมพ
ชื่อฟังก์ชันนั้น แล้วตามด้วย
มาดูตัวอย่างกันก่อน
การจะเรียกใช้ฟังก์ชันที่เราสร้างขึ้น ไม่ได้มี
ชื่อเพราะในวงเล็บนี่
ิสิ่งที่เป็นตัวแปรชื่อว่า name นะคะ พารามิเตอร์
เห็นไหมคะ ตามด้วย Argument
ในที่นี้ ก็คือ
ที่เราจะให้
มันเก็บเลยนะ นะคะ ลองดูนะคะ
น่ะชื่อว่า name แล้วพอเราเรียกใช้นี่
ก็คือเราพิมพ์ชื่อฟังก์ชันนั้น แล้วตามด้วยค่า
หรือมันช้า พอ... พอสลับมา Colab มันจะช้า
ลองเลย ลองเลย เพื่อให้เห็นภาพ
นิดหนึ่งหรือ ไม่สลับ
อีกแล้วนะ อะไรนะ
นี่คือฟังก์ชันเวลาเรียกใช้
ไม่ได้มีอะไรพิสดารเลยนะคะ ใส่ Hashtag ก่อน
โอเค เรา
ก็จะต้องสลับกันอย่างนี้นะคะ นี่นะ เราไปประกาศไปแล้วนี่
ใส่เครื่องหมา chap หรือ hahtag
อันนี้คือคอมเมนต์นั่นเองนะคะ เพื่อจะบอกให้รู้ว่า
เพื่อจะให้รู้ว่าตรงนี้เป็นส่วนของ
เราเรียกการใช้ฟังก์ชันนี้ ก็เลย
แล้วก็ตามด้วยฟังก์ชัน f-u-n เด็ก ๆ ไม่ต้องพิมพ์ ไอ้นี
ตรงนี้เราจะเรียกใช้ฟังก์ชันที่เราสร้างแล้วนะ calling
calling นะคะ calling ก็
ก็ได้นะคะ
ฟังก์ชันแรกที่
ฟังก์ชันแรกของเรา
ชื่อว่า hello ใช่ไหมคะ แล้วตามด้วยเครื่องหมายวงเล็บ
เราจะเรียกใช้ชื่อ ก็คือเวลาจะเรียกใช้มัน
พิมพ์ชื่อฟังก์ชันนั้นนะคะ พิมพ์ hello เลยนะคะ
ทีนี้เราไม่อยากใส้ Danny เราใส่ชื่อเราเองไปก็ได้
นะคะ เห็นไหมคะ มันจะขึ้นมาบอกเลย name
name คืออะไร name ในที่นี้ ในตัวอย่าง ก็คือ Danny นะคะ
เครื่องหมายคำพูด
หรือ Double Quote นะคะ name
ชื่อนึกออกนะ เช่น
เนื่องจาก name เป็น string อย่าลืมใส่เ
ใส่ชื่อเราแทน Danny ก็ได้นะคะเด็ก ๆ
สมมติ
เรียกฟังก์ชัน hello ไปแล้ว ฟังก์ชันต่อมา
จะใส่ชื่อเล่นหรือชื่อจริง
ก็ได้ แล้วแต่นะคะ
เราอยากให้มันแสดงค่าพื้นที่
นะคะ ก็เลยใช้คำสั่ง
ที่เราจะเรียกใช้นะคะ
ก็คือ area() แต่ area() ที่เรา
ทำให้ดูก่อน
p-r-i-n-t
print ก่อน แล้วไปเรียกฟังก์ชัน
นั้นไว้ใน print นะคะ ให้ print แสดงนะคะ ดูตัวอย่าง
ตำแหน่งของฟังก์ชันชิดนะคะ
ไม่วรรคนะคะ นี่ ไม่ต้อง Tab เข้าไปนะ
ลืมแก้ภาษาขอโทษที
ตัวที่ 2 นะคะ
ด้วยแสดงคำว่า
เป็นข้อความนะคะ เพราะฉะนั้น
เราจะใช้คำสั่ง print
ฟังก์ชันนะคะ เพื่อให้แสดงแล้วก็เรียกใช้ฟังก์ชัน
สี่เหลี่ยม
เมื่อเป็นข้อความ พิมพ์เป็นภาษาไทยก็ได้
ไม่ต้องใช้คำว่า "area" ในภาษาอังกฤษ ก็คือพื้นที่
ใส่เครื่องหมายเท่ากับนะคะ เปลี่ยนภาษา
=
เปอร์เซ็นต์แล้วก็ d
แล้วหลังเครื่องหมายคำพูด
ก่อน =
%d นะคะ %d เท่ากับ แล้วก็
แล้วก็
พิมพ์ฟังก์ชัน area a-
ตามด้วย % แล้วเรียกใช้
ฟังก์ชัน area นะคะ ตามด้วยเครื่องหมายเปอร์เซ็นต์
e-a นะคะ
แล้วก็วงเล็บ
r ปุ๊บ ขึ้นหรือยัง
A-r-
เอามากกว่านั้นก็ได้นะ
ในตัวอย่างบอกว่าความกว้าง คือ 8 ความสูง คือ 4
ทีนี้ใส่ Argument
ให้ 2 ตัว ก็คือ 8 นะคะ กว้าง 8
ความสูง 4 นี่ความสูงนี้
เท่าไหร่ ตอนนี้เราพิมพ์คำสั่งหรือโค้ด
ถ้าพื้นที่ที่มี
ความกว้าง พื้นที่สี่เหลี่ยมที่มีความกว้าง 8
จะแสดงผลอย่างไร
Error เด้งขึ้นมา ณบัด Now
เสร็จหมดแล้วนะคะ
เด็ก ๆ ลองกด Play ดูได้เลยนะคะ ถ้าใครพิมพ์เสร็จแล้ว
เกิดอะไรขึ้น
print
บรรทัดที่ 9
ตัวแปร ตัวแปรผิด เดี๋ยวนะ ค่อย ๆ ไล่นะคะ
สังเกตนะคะ เมื่อขึ้น Error
เด็ก ๆ ดู เห็นไหม มันจะชี้ไปที่บรรทัดผิด
พอขยายแล้วของตัวเองก็เล็ก
แบบนี้นะ เดี๋ยว
เสร็จแล้ว
มันบอกว่าในบรรทัดที่
พิมพ์ตัวแปรผิดหรือ ฟังก์ชันชื่อฟังก์ชัน
ถูกแล้วนะ hello ถูกต้องนะคะ
ไม่อยู่ใน Index
S ตัวใหญ่หรือ s เล็กใช่ไหม ขอโทษที
2 % name
value error ค่า error ตรง...
แก้ได้ ๆ
เห็นไหมคะ
พิมพ์ s ผิดใช่ไหมนี่
%s
แม่ไม่ได้ดู s มันเป็นตัวมหญ่ตาม
คือ ไอ้พวก % d % อะไรนี่
เมื่อกี้ตรงลืมพล็อต
ให้ดูก่อน เมื่อกี้ตอนแม่พิมพ์ %s
ตัวพิมพ์เล็เกแค่นั้นเอง
พิมพ์เล็กมันไม่ใช่ตัวพิมพ์ใหญ่ แม่ไปพิมพ์ใหญ่
ถ้าเด็ก ๆ ผิดตำแหน่งนี้ แก้แค่ตัว S จากตัวพิมพ์ใหญ่ เป็น
พอมาไล่ฟังก์ชัน
การขึ้น Error นะ เดี๋ยวแก้ให้ดูนะคะ
%s' name
มันจะขึ้นลูกศรชี้ไปที่บรรทัดไหน นั่นหมายความว่า
มันหมายความผิดพลาดที่
ย้อนกลับไปดู อ๋อ s ฉันพิมพ์ผ
ฉันต้องพิมพ์เป็นตัวเล็กนะคะ พอแม่แก้
ตรง value error เห็นไหม ค่าที่มัน error ค่ามัน
อยู่ที่คำว่า s อ๋อ
มันก็จะแสดงขึ้นมา เห็นไหม มันก็จะพิมพ์คำว่า...
มันก็จะไปเรียกใช้ ไอ้ตัวนี้
จากตัวใหญ่เป็นตัวเล็ก
เรากด Play น่ะ Error มันก็หาย แล้วผลลัพธ์
ที่จะให้มันแสดงแต่
ตอนที่ทำงานน่ะ มันมาทำงานที่ตัวนี้เห็นไหมคะ
ออกมาเลย ทั้ง ๆ ที่ ตอนเรียกนี่ เราพิมพ์แค่
ฟังก์ชัน แล้วก็ตามด้วยค่า Argument
คำว่า "print" ไว้
พอเวลามาเรียกใช้เธอ เราก็เลยมาพิมพ์คำว่า...
ตัวคำว่า "print" แต่ตรง area นี่
นะคะ ตรงฟังก์ชัน area
สามเหลี่ยม 8 x 4 = 32 ถูกต้องนะคะ
มันก็จะส่งค่า c ที่มาคำ
มีแถมตัว r มาจากไหนนี่
สามเหลี่ยม = %d'
พื้นที่ สี่เหลี่ยม
ของเรานี่นะคะ มีค่า =
มาแสดงตรงนี้เห็นไหมคะ
เป็น 32 นะคะ มันก็เลย print คำว่า "
แสดงทศนิยมออกมานะคะ
ลองดูอีกสักตัวอย่างหนึ่งไหมคะ
%d นั่นหมายถึง
ให้แสดงเป็นเลขจำนวณเต็มนี่
เด็ก ๆ ลองนะคะ ทีนี้ให้
ใส่ชื่อเล่นตัวเองลงไป
ลอง ลองเรียกใช้
ฟังก์ชัน hello อีกนะคะ
เอาแต่ hello อย่างเดียวให้เห็น
เห็นไหมคะ มันจะขึ้นมาเป็น
ใส่ชื่อเล่นเรานะ
ไม่แน่ใจว่ามันจะไปเรียกใช้ได้อีกไหม
มันจะไปเรียกใช้ได้อีกไหม
ตัวต่อไปอันนี้ไม่มันก็จะ
ทำซ้ำไง เพราะเรายังอยู่ในตัวเดิมนะ
ไม่ได้ไปเรียกต่อจากเมื่อกี้
ลองพิมพ์ฟังก์ชัน hello ที่เราสร้างไว้
มีตัวใหม่ใช่ไหม แล้วลองเรียกใหม่
จากโค้ดที่เราเพิ่มเข้ามา ลองเรียกนะคะ
ก่อนหน้า ลืมแก้ภาษาอีกแล้ว
พิมพ์เรียกใช้ฟังก์ชัน
ลองดูสิ มันจะขึ้นอย่างไร ลองดูนะคะ
ทีนี้ลองใส่ชื่อเล่น
หลาย ๆ คน ใส่ชื่อเพื่อนลงไปด้วยสัก 3 คน
เพราะบอกแล้วว่า Argument นะคะ
มีกี่คนก็ได้ ลองสิขึ้นไหม
ตัวเดียว แต่เราไปใส่หลายตัวนะคะ มันจะใส่ได้
ตามจำนวนพารามิเตอร์ด้วยนะคะ เพราะฉะนั้น ในกรณีนี้
Syntax error เพราะอะไรคะ
เพราะไอ้ตัวนี้มันมีพารามิเตอร์ใ
ให้มันมีหลายคนนะคะ เราต้องไปแก้ที่ฟังก์ชันเรา
ถ้าเราจะเพิ่มให้มันมีหลายคน
ถ้าเราจะเพิ่ม
แล้วลอง ลองมาใส่ที่ตัวนี้ใหม่
เข้าใจแล้ว
แสดงว่าไม่เรียก อ๋อ
มัน มันข้ามไปสร้างตัวใหม่
Type Error ชนิดไม่ถูกต้องนะคะ เพราะ
ฟังก์ชัน Hello เราน่ะ
นี่ไง ๆ มันขึ้นเตือนว่ามาว่า
เราไปใส่ 3 ก็คือถ้าเราต้องการให้มีหลายตค
ไปเพิ่มตัวนี้นะคะ เพิ่มขึ้น
Position ให้แค่ 1 ตำแหน่ง
นะคะ ใน Argument แต่
ไปวิธีแก้ไม่ได้ยากเลยนะคะ
ถ้าจะ... เรามาเปลี่ยนที่ตัวฟังก์ชันหลัก
เพราะฉะนั้น
นี่คือเมื่อ... จำไว้เลยว่าเมื่อ
ตอนจะเรียกใช้แค่พิมพ์ชื่อ
เพราะตอนเรีกยใช้ไอ้ตัวนี้มันเรียกแค่
ใช่หรือเปล่าอย่างนี้เป็นต้นนะคะ
Argument ลงไปแค่นั
มันชื่อนี้เวลาเราเรียกใช้มันนี่ เราเอามา
แล้วในวงเล็บนี่ เราพิมพ์
ค่าของ... เขาเรียกว่า "
มัน... พอมันโดนเรียกใช้นี่มันจะกลายเป็น
Argument แต่ตอนที่มันเป็นฟังก์ชันนี่
ทั้งชื่อฟังก์ชันกับวงเล็บ แต่สิ่งที่อยู่ใน
วงเล็บนี่ ก็คือเราใส่เข้าไปได้เลย
เราเอาฟังก์ชันนั้นมาใช้งาน สิ่งที่อยู่ใน
วงเล็บจะกลายเป็น
ตรงในวงเล็บนี่คือ
หรือตัวแปรที่จะไว้รับค่านะคะ แต่พอ
นี่ นี่คือส่วนของการสร้าง
ฟังก์ชันและการเรียกใช้ฟังก์ชันนะคะ มาดูหัวข้อ
รับเข้าไปนั่นเอง
นะคะ
เหลืออีก 2 หัวข้อ
เดี๋ยวนะ เดี๋ยวนะ
ต่อมาของเราก่อนดีกว่านะคะ เดี๋ยวเด็ก ๆ จะได้
ไปเดินงานวันวิทยาศาสตร์ต่อ
โอเค
สลับหน้าจอก่อนไม่สลับไม่ได้
คืออะไร มันเป็นการกำหนด
Default Argument นี่
ดูส่วนต่อมานะคะ ส่วนที่เรียกว่า
"Default Argument Value"
ค่าที่เราจะส่งเข้ามาในฟังก์ชันตอนแรกนะ
ทำให้สามารถเรียกใช้งานฟังก์ชัน
กำหนดค่าเริ่มต้นนะคะ เป็นการกำหนดค่าเริ่มต้นให้
กับไอ้ค่า
เห็นไหม
นี่นะคะ ในตัวอย่างนี่ สร้างฟังก์ชัน
โดยส่ง Argument ที่น้อยกว่าจำนวนที่กำหนดไว้ก็ได้นะคะ
ดูตัวอย่างจะเห็นภาพชัด
เห็นไหม ใส่ Argument เข้าไปด้วยเลย มี พ
Salary มี Argument =
ชื่อว่า show_info
ไม่ได้ใส่เป็นพารามิเตอร์
แล้วกำหนด Argument ให้มันด้วยเลยนะคะ แล้วก็
สร้างพารามิเตอร์ตัวที่ 2 ชื่อว่า lang
84360 เห็นไหมคะ
นี่คือการ Defal
แล้วก็สั่งให้ print
หรือ Language นะคะ มาจากคำว่า "Language"
แล้วใส่ Argument ที่ชื่อว่า Python
ก็คือ Argument ที่ชื่อ...
ไม่ใช่ print Argument print parameter
print ที่ 1 บอกให้ print เฉพาะแค่ชื่อ
print ที่ 2
ตอนเราเรียกใช้ ให้เด็ก ๆ ดูตอน Calling Function
ใน name นี่เราไม่ได้กำหนด Argument ให้เหมือน salary
นะคะ ที่ชื่อ Salary เห็นไหม print Name print Salary
แล้วก็ print
พอ พอเราเรียกนะคะ เรียกใช้มันปุ๊บนี่
อันนี้ผิดนะนี่ พิมพ์ผิดขอโทษ มันต้องเป็น
กับ Lang Language
เห็นไหมคะ
ไหง มือบอกไปพิมพ์ Java สะงั้น
สะอย่างนั้น เพราะ Argument ที่เราใส่เข้าไป
Python ขึ้นมา ไม่ใช่ JAVA
เดี๋ยว ๆ ขอแก้ก่อน
ชื่อ Python นะคะ
เมื่อกี้กลับมาแก้
ดูนะคะ เดี๋ยว
ไม่สลับอีกแล้ว ไม่เป็นไร
นะ เพราะฉะนั้น เปิด Colab ของเรา
ขึ้นมาไว้นะคะ
เราจะลองทำฟังก์ชันแบบกำหนด Argument ด้วย
นะคะ
โอเค สลับได้ เดี๋ยวสลับไป เดี๋ยวสลับไม่ได้ เดี๋ยวจะตีมือ
นะคะ โอเค
แล้วเราก็ต้องสลับ
โอเคสลับได้
ทีนี้ สร้างโค้ดใหม่เลยนะ
เด็ก ๆ กด + เพิ่มโค้ดใหม่ไปเลย
มาดูแบบที่ 2 ที่เราสร้างฟังก์ชันที่มีการ...
จะได้ไม่ไปงงกับอันแรกนะคะ อันแรกเป็นการสร้างฟังก์ชันแบบปกติ
ที่ไม่ได้กำหนดค่า Argument ให่
นะคะ ฟังก์ชันแบบที่ 2
มันทะลุจอไป
จอไป
ให้ Argument ในฟังก์ชันเลยนะคะ ก่อนอื่น เราก็ต้องพิมพ์
คำสั่ง def
ชื่อว่า Default Argument Value
นี่นะคะ แบบที่มีการกำหนดค่า
ชื่อฟังก์ชัน ซึ้งในตัวอย่างใช้คำว่า "show_info"
นะคะ ไม่อยาก
d-e-f เพื่อประกาศตัวแปร... เพื่อประกาศ
ฟังก์ชัน แล้วก็ตามด้วย
ถ้าชื่อมันเป็น 2 ประโยคนี่ เขาจะใช้ Under sco
แยกประโยคที่ 1 กับประโยคที่ 2 เห็นไหมคะ s-
ตั้งชื่อยาวกว่านี้ก็...
สังเกตนะคะ เวลาตั้งชื่อ ฟังก์
ประโยคที่ 2 คือ คำว่า "info"
ก็คือโชว์ข้อมูลนั่นเองนะคะ info ย่อมาจาก
h-o-w show คือ ประโยคที่ 1
show คือแสดงนะคะ แล้วตามด้วย
สร้างฟังก์ชันที่ชื่อว่า show_info นะคะ โดย
ในนั้นนี่ กำหนดพารามิเตอร์
information นั่นเองนะคะ
ตอนนี้เราสร้างฟังก์ชันที่ชื่อ
แล้วมีพารามิเตอร์ที่ 2 คั่นด้วย
โคลอน ไม่ใช่โคลอน คอมมา
ตัวที่ 1 ชื่อว่า name n-a-m-e
name นะคะ
แล้วก็ตามด้วยชื่อพารามิเตอร์ตัวที่ 2 ซึ่งพารามิเตอร์ตัวที่ 2 นี่
เราจะกำหนดค่า
เรียกผิด เรียกถูกตลอดเลย
นะคะ
ซึ่งแปลว่าเงินเดือนนั่นเองนะคะ salary
Argument ให้เขาไปเลยนะคะ เพราะฉะนั้น พารามิเตอร์
ตัวที่ 2 ชื่อว่า
อันนี้กำหนดเองได้เลยนะคะ เด็ก ๆ อยากได้เม่าไหร่ เด็ก ๆ กำหนดเอง
ใส่เข้าไปเองเลย
ซึ่งแปลว่าเงินเดือน อยากได้เงินเดือนเท่าไหร่เด็ก ๆ
ตรงเครื่องหมายเท่ากับใส่เข้าไปนะลูก
อันนี้
สิบ ร้อย พัน หมื่น นะคะ 20,000
ปุ๊บนะคะ เสร็จแล้ว
เขาบอกว่าค่าเริ่มต้นที่ให้ สมมติ 20,000
หน่วย หน่วย
ืn-g lang นะคะ
แล้วตามด้วยเครื่องหมาย =
เพิ่มพารามิเตอร์ตัวที่ 3 ชื่อว่า
lang ซื้อมาจากคำว่า
ในที่นี้ภาษาเริ่มต้นเข้าบอกว่า Python
แล้วก็ตามด้วยชื่อ...
คำว่า Python lang
เมื่อจบ เมื่อจบ
การประกาศฟังก์ชัน ปิดด้วยเครื่องหมาย :
เมื่อเสร็จ
ชื่อว่า show_info นะคะ ดูไปด้วย
อธิบายไปด้วย มีพารามิเตอร์ทั้งหมด 3 ตัว
เสมอนะคะเด็ก ๆ
ตอนนี้เรามีฟังก์ชันที่
แล้วก็มี lang โดยกำหนด Argument
ของ
คือ name salary นะคะ โดยที่ salary นี่
กำหนด Argument เริ่มต้นด้วยที่ 20,000
หลังจากนี้ ก็คือ 1. นะคะ print ค่ะ ให้ใช้คำสั่ง
print
Language นี่นะคะ ว่า Python
เมื่อประกาศฟังก์ชันเสร็จ
ก็จะอยู่ในเครื่องหมายคำพูด แล้วตามด้วย
ข้อความ ซึ่งในที่นี้
print อะไรบ้าง print แรก ก็คือต้องการ
ให้ print ชื่อ
ก็คือชื่อนะคะ
แล้วก็ตามด้วยเครื่องหมาย :
เราจะไม่พิมพ์เป็นภาษาไทยแล้วนะ เพื่อให้รู้ว่าตรงนี้คือสิ่งที่เราต้องการให้
ใส่ %s
อย่าลืมว่าเมื่อเราใช้เปอร์เซ็นต์ ตัวอักษร
: ชื่อ
เปลี่ยนเป็นภาษาไทย
แล้วไปที่หลังเครื่องหมาย
คำพูดนะคะ อยู่หลัง
จะเป็นตัวเล็กเสมอ ไม่ใช่ตัวใหญ่ เพราะเราผิดไปแล้ว 1 ครั้งนะคะ
เราต้องจำให้ได้
name มาใช้นะคะ แล้วก็พิมพ์คำว่า "name"
เครื่องหมายคำพูดนะ เด็ก ๆ ดูดี ๆ เลื่อนตำแหน่งมานะ แล้วก็
ใส่เปอร์เซ็นต์แล้วก็เรียกพารามิเตอร์
statemat ที่ 1 statemet ที่ 2
print ชื่อค่ะ พิมพ์ค่ะ
เสร็จ
Salary คือ เงินเดือน ขอโทษ ในเครื่องหมายคำพูด
ใส่คำว่า "เงินเดือน" ค่ะ แปลเป็นไทยเลย
print พิมพ์ print เหมือนเดิม
แล้วบอกไม่ใช่ชื่อสิ
นะคะ เมื่อเราต้องการ
เด็ก ๆ น่าจะพิมพ์ง่ายขึ้น
พิมพ์ % แล้วก็ตามด้วย d ตัวเล็กนะคะ
เลขที่เป็นจำนวนเต็มนะคะ ไม่มีทศนิยมนี่ เรา
ก็ใช้ %d
ก็คือให้แสดง... ให้ print ข้อความเพื่อแสดง
เงินเดือนนะ และตัวที่ 4 ค่ะ
โอเคไหมคะ
เราก็จะได้ Statenert
ก็คือ print ภาษามันเองนะคะ
Language มาจากภาษานั่นเองนะคะ
เอ้ย ตัวที่ 2 ตัวที่ 3 ค่ะ
พูดผิดตัวที่ 3
เพราะฉะนั้น ในเครื่องหมายคำพูด พิมพ์คำว่า "ภาษา"
statements ที่ 3
เราต้องการให้แสดงภาษา
แล้วก็ตามด้วยเครื่องหมาย Colon
ว่าภาษา... เดี๋ยวจะงงนะ
ภาษา Python
เพื่อให้แสดงข้อความนะคะ
ลืม
ถ้าเป็นข้อความหรือ string นะคะ
สิ่งที่จะกำหนด
ค่าพารามิเตอร์ เช่น อันที่ 1 % name
ก็เป็นเปอร์เซ็นต์ salary เปอร์เซ็นต์ที ่
เห็นไหม รูปแบบมันจะเหมือนกัน พอหลังเครื่องหมายคำพูด
เราต้องใส่อะไรคะ % แล้วตาส
ใส่เครื่องหมาย % แล้วตามด้วย
ชื่อพารามิเตอร์ตัวที่ 3 คือ lang
ชื่อว่า salary จำได้นะ อันที่ 3 ก็ทำ
เหมือนกันใส่เครื่องหมาย %
ตัวอย่าง เช็กจากโค้ดที่เขียนนี่ เห็นไหม ทุกตัว
จะระบุว่าเมื่อมีข้อความ
หรือ Language ของเรานั่นเอง l-a-n-g นะคะ
เช็กนะคะ เช็ก
แล้วก็พารามิเตอร์ที่ชื่อว่า lang นะคะ
แล้วในตัวอย่างมันมีบอก
แสดงแล้ว แล้วสิ่งที่จะให้แสดง ก็คือพารามิเตอร์ที่ชื่อว่า name
พารามิเตอร์ที่ขื่อว่า na
p-r-i-n-t print แล้วก็ตามด้วยเครื่องหมายวงเล็บ
print ช่องว่างอีก 1 อัน
ดูสิมันจะขึ้นชื่อว่าอะไร
เมื่อเราทำการประกาศฟังก์ชันแล้วนะคะ บอกแล้วว่า
ประกาศเสร็จจะต้องมีการทำอะไรคะ เรียกใช้
เคอร์เซอร์เราขยับเข้ามาอยู่ตำแหน่ง print ไม่ได้
นะคะ กด Enter ลงไป 2 ครั้ง เสร็จแล้ว
ใช่ไหม callingfunction
แต่ทีนี้ตำแหน่งในการเรียก
เห็นไหม ให้เคอร์เซอร์มันมาอยู่ตรง
ชิดขอบน่ะนะ แล้วก็
กดเครื่องหมาย Backspace หรือ
ลูกศิษย์ย้อนหลัง
ขึ้นมาเลย
show_
เรียกฟังก์ชัน show_info
นะคะ เราจะเรียกฟังก์ชัน show
แล้วก็ใส่พารามิเตอร์ชื่อลงไปให้
show แล้วก็ _ แล้วก็ตามด้วย info
ดูในตัวอย่างที่ 1 นะคะ show_info
วงเล็บเสมอ เห็นไหมคะ อยากให้
show พารามิเตอร์ชื่อว่า name o
เดี๋ยวเผื่อไม่เห็น ขยายให้ดูก่อน อย่าลืม
นะคะพอเรียกใช้ฟังก์ชันมันจะต้องมี
ชื่อเรา ชื่อเล่นก็ได้นะคะ ใส่ชื่อเล่นลงไป
นะคะ ในเครื่องหมายคำพูด
ตอนเรียก show... เรียกฟังก์ชัน show_ info
แสดงเฉพาะพารามิเตอร์ชื่อนะคะ
อันนี้พารามิเตอร์แรกนี่
แสดงชื่อ แล้วก็เงินเดือนนะคะ
ดูนะคะ
ในตัวอย่าง
เรียกฟังก์ชัน show_info
ก็คือคำว่า "show" ลืมแก้ภาษษอังกฤษอีกแล้ว
s-h-o-w
ทำเหมือนเดิม
พมิ์ชื่อฟังก์ชันที่เราจะเรียก
ที่ต้องการให้มันแสดง ก็คือชื่อ
ขี้เกียจสลับแล้วนะ
show_info นะคะ
แล้วตามด้วยค่าพารามิเตอร์
หรือ Comma นะคะ
แล้วก็ตามด้วย
แล้วต้องการให้มีพารามิเตอร์ตัว
ที่ 2 ก็คือขั้นด้วยลูกน้ำ
ในฟังก์ชันนี่ เรากำหนดที่ 20,000 แต่ใน
ตอนที่เรามาเรียกนี่ สมมติว่าเงินเดือนเราเพิ่มขึ้น
ค่าพารามิเตอร์ในตัวที่ 2 เช่น เงินเดือน เงินเดือนนี่
ในในฟังก์ชันนี่
ลงไปนะคะ ถ้า
เราต้องการให้มีฟังก์ชัน เอ้ย แสดง
หรือเงินเดือนของคนคนนี้มีมากกว่า 20,000 มี 23,000
เป็น 23,000
= Python นี่ เราจะเอา
ภาษาอื่น เช่น ภาษา C นะคะ
พารามิเตอร์ตัวที่ 3 เราก็พิมพ์
ค่าพารามิเตอร์ตัวที่ 3 แต่เราไม่ได้เอา
ก็คือในกรณีที่เรียงฟังก์ชันที่ 1 นี่ โชว์เฉพาะ
พารามิเตอร์เดียว เราก็พิมพ์แค่
ก็ใส่คำว่า c ลงไป
พร้อมจะดูผลลัพธ์หรือยังคะ
เรียกฟังก์ชันในอันที่ 2 นี่ แม่อยากให้
มันแสดงทุกพารามิเตอร์เลย แม่ก็เลยใส่เข้าไปครบ
ชื่อฟังก์ชันแล้วก็ตามด้วยพารามิเตอร์ที่เราต้องการให้แสดงพอ
แต่ใรกรณีที่
นี่ เห็นไหมคะ ชื่อ เงินเดือน
เห็นไหม แบบที่ 1
3 อัน เห็นไหมคะ เดี๋ยวเล่นให้ดูนะคะ ว่าผลลัพธ์
ออกมาจะเป็นยังไง
ที่มีอยู่แล้วขึ้นมาด้วย เห็นไหมคะ เพราะ
เมื่อเรียกฟังก์ชันนี้ปุ๊บ สิ่งที่มันจะแสดงมีอะไรบ้าง ชื่อ
แบบที่ 1 ตอนเรียกนี่
ให้แสดงแต่ชื่อ แต่มันก็จะแสดง
มันจะเว้นให้ 1 บรรทัด เด็ก ๆ ดู
พออันที่ 2 มามันเว้นก่อนบรรทัดหนึ่ง
มีเงินเดือน แล้วก็มีภาษา เห็นไหม
พอใส่ print แล้ววงเล็บ
พื้นที่สี่เหลี่ยมมันก็ติดกัน เห็นไหมคะ แต่พอ
ตัวอย่างนี้ นี่
เด็ก ๆ ไปดูความแตกต่างกับอันแรก ที่ไม่มีเว้นบรรทัด
พอเราสั่ง print Hello
ิสิ่งที่มันแสดงมีชื่อเหมือนกัน มีเงินเดือนเหมือนกัน ภาษา
แสดง 3 อย่างเห็นไหมคะ นั่นก็คือฟังก์ชัน
มันมี print ในวงเล็บ
เห็นไหมขั้นมาก 1 อัน
นะคะ แต่มันจะแสดงตาม
อะไรเช่น เหมือนตัวแรก แสดงเฉพาะชื่อแรก
ีที่ชื่อว่า show_info นี่ มันจะแสดงข้อมูลของชื่อ
ของเงินเดือนแล้วก็ของภาษาขึ้นมาทุกครั้ว
เห็นไหมคะ แต่พออันที่ 2 show_info อันที่ 2
แม่ไปเปลี่ยนไป แม่ไปเปลี่ยนว่า
เพราะฉะนั้น เงินเดือนกับภาษานี่มันจะไปแสดงตามค่าที่เรา
ตั้งไว้ในครั้งแรก
ก็เลยเปลี่ยนเป็น 23,000 ภาษาของเขา ก็เปลี่ยนเป็นภาษา C เห็นไหม
แต่มันจะรู้ว่าพารามิเตอร์ตัวที่ 2 นี่
คนนี้คนใหม่ไม่ใช่คนเดิม นิวคนละนิว
เพราะฉะนั้นเงินเดือนคนนี้
มันก็ไปแสดงที่คำว่า "ภาษา" เห็นไหมคะ นี่ก็เป็น
ใช้งานฟังก์ชันที่มีการ
คือ เงินเดือน มันก็จะไปแสดงที่ตำแหน่งเงินเดือน เห็นไหม
พารามิเตอร์ตัวที่ 3
ดูเอาแล้วกัน ว่า
แบบไหนใช้งานง่ายกว่าให้ศึกษา
กำหนดค่า ค่า Argument ไว้แล้ว
นะคะ ค่าเริ่มต้นไว้แล้วนะคะ
นะคะ เห็นไหมคะ เรา
กำหนดค่า Argument
ให้มองเห็นความแตกต่างนะคะ
แล้วก็มาสู่หัวข้อสึดท้ายของเรา
Keyword Argument ยังเกี่ยวกับ Argument อีก มันคืออะไรกัน
keyword ชื่อก็บอกอยู่แล้ว
ไปได้แล้วนะคะ ต่อมา เรื่องต่อมา
ของเราเรื่องสุดท้าย
เขาบอกว่าใช้ชื่อของ
พารามิเตอร์ในการส่ง Argument
คือ คำสำคัญนะคะ มันจะเป็นฟังก์ชัน
ที่มีรูปแบบ
เราจะต้องไปกำหนดค่าให้พารามิเตอร์ของเราก่อน ตัวแรกนะคะ
ดูตัวอย่างตัวนี้ เห็นไหมคะ
โดยพารามิเตอร์นั้นต้องมีการกำหนด
Default Argument ก่อน
มันจะคล้ายกับอะไร คล้ายกับเมื่อกี้นี้ แต่มีข้อแตกต่าง
คือตรงไหน Keyword
สังเกต สังเกตที่อะไรเด็ก ๆ นี่ เห็นไหม
Color น่ะค่ะ
ที่เป็นรหัส เขาเรียกว่าเป็นรหัสหรือเป็นคีย์น่ะค่ะ
เช่น fff นี่ น่าจะเป็นสีขาว
ค่าสี คือ ไปเรียก
ใช้ค่าสี
มันจะไม่ใช่ค่าตัว ที่เป็นแบบข้อความ หรือ
เป็นตัวเลข
หรือไม่ได้เติมสีนี่ล่ะ ถ้าจำไม่ผิดนะ ให้นึกถึงนะ
นี่คือ
Argument ที่เป็นลักษณะ Keyword นะคะ
ไม่เป็นไร ถ้าอยากรู้มันคืออะไร
เหมือนปกตินะ ไอ้ตัวนี้ คือ สิ่งที่เรียกว่า "Keyword"
นึกออกนะ Keyword Argument
ดูนะคะ ค่าสีใน... ในคอมพิวเตอร์
ดูนะคะ ค่าสี ค่าสี
เดี๋ยวจะลองให้ดูนะคะเด็ก ๆ
นี่ เห็นไหม
ไม่สลับอีกแล้ว
ในคอมพิวเตอร์นี่มันมีหลายแบบ
นี่คือคีย์เวิร์ดของค่าสีในคอมพิวเตอร์ โดยปกตินี่
เวลาถ้าเราเขียนโค้ดนี่
ไม่ต้องการอะไรแบบนี้
เด็ก ๆ ดูนคะ
แล้วก็... ค่า
สี 3 ฐาน 16 มันจะไม่รับ มันจะรับค่าสี
โปรแกรมมันจะรับค่าสีที่เป็นค่าสี
ฐาน 16 นะคะ RGB
ก็คือมันต้องมาอ่านค่าของตัวนี้ก่อน แล้วมา
แสดงให้เห็นสีที่เราต้องการจะรู้ เดี๋ยว
ตัว 0000 ff นี่ เหมือนตัวอย่างนี่ ตัวนี้
คือเป็น Keyword Argument
อยากรู้ว่าเป็นสีอะไร เดี๋ยวเปิด paint ให้ดูนะคะ โปรแกรม paint
จะเห็นชัดกว่า
ทำให้ดูนะคะ ตัวอย่างนี้ เดี๋ยวนะ
ไอ้ 00 สีอะไร
โปรแกรม Paint นะ
ไม่ใช่ paint สิ อะไรนะ Microsoft Word ก็เห็นแล้ว
เดี๋ยวนะคะ
เดี๋ยวไอ้นี่ไม่เห็นสิ
เปิดให้ดูว่าเราจะรู้ได้อย่างไรว่าค่าสีนี้สีอะไร
เปิดใน Word ให้ดูนะคะ
ตรงนี้จะเป็นค่าสี มันจะมีแบบ
มาตรฐานกับกำหนดเองนี่
ดูสีนะ เด็ก ๆ ดูที่สีนะคะ
นี่เห็นไหม
ไม่ใช่สิ อย่างนั้นเปิดให้ดู
ตารางค่าสีเลยแล้วกันนะคะ
ไอ้ตัวนี้ก็ไม่ขึ้นแบบนี้
ดูนะคะ ตารางค่าสีจะเป็นอย่างนี้
ชักงงเอง ตารางค่าสี
อันไหนที่จะเห็นชัด
ลักษณะนี้นะ อันนี้จะเห็นชัดนะคะ ว่าถ้า
สีชมพูเข้มขนาดนี้
อย่างนี้นะคะ สมมติสีชมพู
นี่เห็นไหมตัวเลขสีมันก็จะเปลี่ยนไป
มันก็ขึ้นอยู่ข้างในนี่
ตัวเลขที่แสดงค่าสีมันน่ะ
ค่าสีจะเป็นตัวนี้ อย่างนี้นะคะ
ตัวนี้ขึ้นไหม
ไม่โชว์แล้วน่ะ เดี๋ยวเทสต์ให้ดูเลยนะคะ
ถ้าอยากรู้ว่าสีไหนเป็นสีอะไร อย่างเล็ก
ไม่เอาน่ะ
เอาแค่นี้พอ
ปุ๊บ print color ขอก๊อปก่อน
ขอเพิ่มโค้ดให้ จะทำโค้ด
แค่สร้างสีตัวเดียวเลย
เราไหมนี่
ขี้เกียจน่ะ ขี้เกียจพิมพ์
copy ให้
ไม่วางให้นะคะ ไม่เป็นอะไร
อันนี้เป็นตัวอย่างให้เห็นว่า Key
Argument def ฟังก์ชันนี้
สมมติ สมมตินะคะ สร้างฟังก์ชัน
เดี๋ยวสร้างให้ดูเด็ก ๆ ไม่ต้อวง
c-r-e-a-t-e create color
จะใช้ในการสร้างสีนั่นเองนะคะ
ใส่พารามิเตอร์ ชื่อ color นะคะ โดย
มีค่าเท่ากับ
โดย
กำหนด Default Argument ที่
1, 2, 3, 4,
5, 6 6 นะ
ตัวที่บอกว่า f นี่ มันเป็นคีย์เวิร์ดของ
ค่าสีที่บอก เพราะฉะนั้น พอเรา
เครื่องหมาย # F1 F2 F3 F4
f5
ขอโทษที มือไวจริง ๆ เลย
สร้างฟังก์ชันนี้ มันจะแสดงอะไรออกมา
ดูนะคะ ทำไมเผลอไปลบ
เราจะ
ให้มัน print สีนั้นออกมาให้ดูนะคะ
4
ดูนะคะ เห็นไหม นี่
print color
=
print อะไร ต้องการให้ print
่
ขอเพิ่มพารามิเตอร์อีกตัวหนึ่ง
ใส่สีนี้อะไรจะเกิดขึ้น อันนี้ประกาศตัวแปรจะเสร็จแล้ว จะเรียกใช้
มันนะคะ เรียกใช้
คือ id นะคะ id คือ ลำดับที่นั่นเอง
เพื่อให้เห็นว่าอันที่ 1
เราก็คลิกเลือก แล้วตามด้วย id ลำดับ
ที่ 1 นะคะ
Create color พิมพ์ชื่อฟังก์ชัน
a-t-e
ขอลอง print ก่อน
เหมือนเดิมนะคะ
แล้วก็ % เหมือนเดิม
ลำดับที่แล้วก็ตามด้วย :
ใช้ colon แทน
%d นะคะ ตัวเลข เป็นตัวเลข
แล้วก็ตามด้วย
% ลำดับที่เป็น % อะไรนะ
พิมพ์อะไรผิดนี่ p-r-
i
% แล้วก็ค่าพารามิเตอร์ ก็คือ id
p-r-i-n-t print
syntax error ผิดตรงไหนนี่
อ๋อ
เดี๋ยว Run ให้ดูเลยนะคะ
แม่พิมพ์อะไรผิด
p-r-i-n-t
ตำแหน่ง เดี๋ยวนะ Enter เข้าไป เอาใหม่สิ
+
ลบแล้ว print ใหม่ p-
i-n-t
print เอาใหม่
ลบก็ได้
print
Syntax Error Invalid
เดี๋ยวนะ 1
ผิดได้อย่างไรล่ะ
เขาก็ไม่ได้พิมพ์ผิดนี่
ทำไมมันขึ้น Error ล่ะ
เดี๋ยวนะ ขอ
ขยายก่อนนะ
1, 2, 3, 4,
1 2 3 4 5 6
ก็ตรง
อะไรนะ
ผิดตรงไหนนี่
ทำไม Syntax นี้ Error ล่ะ
ลืมอะไร ไม่ได้ลืมนี่
เอาอีกแล้ว
Syntax Error Print
print บรรทัดที่ 3 ไม่ได้ colors หรือ
มันบอกว่า print ไม่ได้น่ะ
ถ้าลบ
จะขึ้น Error อีกไหม
มันจะ Error ได้ยังไงน่ะ
ไม่รู้จัก
รันผ่าน รันไม่ผ่าน
อ๋อ รู้แล้ว
ผิดตรงไหน
อะไร
ผิดตรงไหนหรือเปล่านี่
print คำสัง Prit
ตรงนิดเดียว มองไม่เห็น
ลืมใส่เครื่องหมายคำพูดตรงคาบ
โอเคนะคะ
รู้แล้ว
นะคะ เดี๋ยวจะขอลองดู
ของ color นะคะ
มันก็เลยคำสั่ง print สี
อันนี้ถูกแล้วนะคะ
คิคือ fff ขึ้นมาอย่างนี้นะคะ
ก็คือจะแสดงเป็น
ผลลัพธ์ก็จะออกอย่างนี้ คือ พิมพ์ลำดับที่ 1 เสร็จ
มันก็จะ print สี่ที่มีค่า
นี่
อยากโกรธโปรแกรมดีหรือไม่ก็ไม่รู้
Argument ที่เป็น Keyword นั่นเองนะคะ
สาเหตุ ก็คือนี่มันมี
เครื่องหมายคำพูดนี่ แต่ไม่ได้ใส่ให้มันนี่นะคะ
พอเปลี่ยนฟอนต์น่ะ มันก็มาจัด
ตัวนี้ตัวเล็กตัวใหญ่ดูยากมาก
เหมือนกันนั้นล่ะค่ะ default
ดี ๆ แค่นั้นเอง ว่าจะให้มันเป็น
นะคะ
ก็คือการกำหนดค่า Argument
ก็ต้องมาใช้รูปแบบนี้นะคะ
เขาบอก
Default ที่เป็นลักษณะ... Argument ที่ให้มันแสดง
มันเป็นลักษณะไหนถ้าเป็น
ข้างหน้าตัวนี้
พอ Run แล้วถึงจะผ่าน
เขาเป็น Keyword
นี่มันต้องใส่เครื่องหมายที่เป็นคำพูด
ก็คือแสดงลักษณะที่เป็นคีย์เวิร์ดแบบนี้ออกมา
สงสัย
ถึงจะขึ้นนะคะ
ขึ้นค่าให้
ไอ้ค่าที่เราจะใส่เข้าไปนี่ล่ะค่ะ เพราะตัวนี้ ลักษณะ
คือมันเป็นค่าของเขาเรียกว่าอะไรนะ
ตรงไหนหรือเปล่าคะเด็ก ๆ ความแตกต่าง แทบไม่แตกต่าง
ว่าไม่แตกต่างกัน มันต่างกันตรงค่า
รหัสสี ซึ่งความจริง ก็คือถ้าเราใส่สีแดง
สีชมพูอะไรอย่างนี้ แต่อย่าลืมว่าสีในคอมพิวเตอร์น่ะ
เขาเรียกว่า "
เป็น code สีนะ
มันก็จะเป็น #ec407a
เปลี่ยนไปตามความเข้มความอะไรอย่างนี้ด้วยนะคะ
มันแยกเฉดอีก เหมือน
อย่างนี้ ชมพูเข้ม
นั่นก็คือเป็นคีย์เวิร์ดหรือคำสำคัญ
คือคอมพิวเตอร์น่ะจะรู้นะ คอมพิวเตอร์
เหมือนสีฟ้านี่ ค่าเขาก็จะเปลี่ยนไปตาม
ที่เห็นนนะคะ
ในฟังก์ชันนะคะ คือ ที่เราจะทำจริง ๆ นะ
มันก็จะมีแบบที่ 1 น่ะ
เขาจะรู้จัก ว่าอย่างนั้นเถอะนะคะ
ถ้าไม่มีใครสงสัย
ฟังก์ชัน มีพารามิเตอร์ แล้วในพารามิเตอร์
กำหนด Argument ลงไปเลยอย่างนี้ก็ได้
กำหนดฟังก์ชันขึ้นมานะคะ อย่างนี้ แล้วก็ตามด้วยพารามิเตอร์
กับแบบที่ 2 ที่มีการกำหนด
สำหรับสัปดาห์นี้นะคะ เราก็จะจบ
บทเรียนหลักการเขียนโปรแกรม
ได้ทั้ง 2 แบบ แล้วแต่จะเลือกใช้งาน แล้วแต่วัตถุประสงค์
การที่จะสร้างฟังก์ชัน
เดี๋ยวสอบแล้วจะนัดแนะอีกทีหนึ่งนะคะเด็ก ๆ
มีใครสงสัยไหม ถามได้
ของเราในเทอมนี้เพียงเท่านี้นะคะ
สัปดาห์หน้าจะให้เบรก
เพราะอย่าลืมว่าแล็บไม่ได้แต่เราใช้คนเดียวนะ
เมื่อเลิกใช้เราต้องออกจากระบบของเราทุกครั้งนะคะ
ถ้าไม่มีจะปล่อยแล้วนะคะ
อย่าลืมออกจากระบบทุกครั้งด้วย
ขอบคุณพี่ล่ามค่ะ สำหรับการเรียนในวันนี้ขอบคุณค่ะ
มันชอบมาเปลี่ยนฟอนต์ให้
เครื่องที่มี
-
(ล่าม) ฮัลโหลครับ
(อาจารย์สุธิรา) สวัสดีค่ะ พี่ล่ามไม่ได้ยินเรานะ
นะคะ
สำหรับวันนี้นะคะ ในสัปดาห์นี้จะเป็น
ฝั่งล่ามไหมครับผม
(อาจารย์สุธิรา) ได้ยินค่ะ (ล่าม) โอเคครับ
ใน Python
เราจะต้องมาเรียนเบื้องต้นนี่ ก็คือต้องมารู้จัก
(ล่าม) ได้ยินครับ ได้ยินครับ
(อาจารย์สุธิรา) ได้ยินไหม ได้ยินนะคะ โอเค นึกว่าไม่ได้ยิน
นะคะ หัวข้อที่
เราจะเรียนในสัปาดาห์นี้นะคะ จะเป็น
เรื่องเกี่ยวกับ
ฟังก์ชันนะ
วันนี้เราจะพูดถึงการ
นะคะ การเรียกใช้งาน
สิ่งที่เรียกว่า Function ก่อนนะคะ
นะคะ อ้าวทำไมหน้าจอไม่ขึ้น
หัวข้อสุดท้ายของปีนี้
เทอมนี้นะคะ ภาคเรียนนี้ ก็คือฟังก์ชัน
โอเคนะคะ ก่อนอื่น
แล้วก็พูดถึง
Default Argument Values แล้วก็ Keyword Argument
คือ ถ้าพูดถึงโดยทั่วไปนะคะ
อีกแล้ว...
สั่งพิเศษ
ีที่ให้ทำงานเฉพาะสิ่งใดสิ่งหนึ่งนะคะ
ก่อนจะรู้วิธีการสร้าง
การเลือกใช้งานนี่ เราก็ต้องรู้ก่อนว่าฟังก์ชันมันคืออะไรนะคะ
ในส่วนของภาษา python
ฟังก์ชันจะเป็นโค้ด หรือโปรแกรมที่เรา
ก็คือถ้าเราเป็นโปรแกรมเมอร์หรือ
ในวิธีการเขียนโปรแกรมคอมพิวเตอร์นี่ ฟังก์ชันมันจะเป็น
เหมือนตั้งขึ้นมาว่าฟังก์ชันนี้จะตั
นะคะ เช่น
ซึ่งแต่เดิมนี่ฟังก์ชันมันจะเป็น
ที่เขาพัฒนาไว้แล้วก็มี แต่ใน Python นะคะ
แล้วไปเรียกฟังก์ชันนี้มาเพื่อให้มัน
ทำกาารคำนวณค่านี้ให้อย่างนี้นะคะ นั่นคือจุดประสงค์
สร้างขึ้นได้เองนะคะ
เพื่อเอาไปใช้กับ...
บอกแล้วว่าในสัปดาห์นี้เราจะสร้าง
ขึ้นมาใช้งานเองนะคะ แล้วเมื่อสร้างเสร็จแล้วนี่
เหมือนบางครั้งนี่ การคำนวณบางอย่าง
ไม่จำเป็นต้องไปเขียนโค้ดใหม่ทุกครั้ง เราก็เลยสร้างฟังก์ชันไว้เลย
มาใช้โดยวิธีการใด
หรือเรียกใช้อย่างไรนะคะ แล้วก็จะพูดถึง Default Argument
จะนำไปใช้ในสิ่งใดสิ่งหนึ่งนะคะ
เป็นการเฉพาะ โดยใน
กระบวนการที่เราจะต้องทำ
ก็คือเมื่อเราจะทำฟังกชันขึ้นมา
จะต้องรู้ว่า
มันจะต้องเรียกฟังก์ชันที่เราใช้งานนี่จะถูกเรียก
ใน python
เราสามารถสร้างขึ้นเองได้นะคะ โดย
ด้วยว่ามันคืออะไรแล้วก็ Keyword Argument ด้วย
ว่ามันคืออะไรนะคะ ทีนี้ก็จะเริ่มเข้าสู่
ที่ที่บอกแล้วว่ามันสามารถ
ทำงานสิ่งใดสิ่งหนึ่งได้
เราจะสร้างมันอย่างไรนะคะ
การสร้างฟังก์ชันใน Python นะคะ
ใช้ code นี้ซ้ำได้
ถ้าจะทำฟังก์ชันมาใช้งาน มันควรเป็น
วิธีการนี้นะคะ จะเป็น
ให้นึกถึงว่าเราจะเป็นคนเขียนโค้ด
เราจะหาค่า vad นี่
คือ ถ้ามาเขียนโค้ด เราต้องมานั่งเขียนว่า Vat เกิดจากการ
แล้วเอาไปเรียกใช้ซ้ำได้อีกนะคะ จะเรียกว่า
"การนำโค้ดนี้กลับมาใช้" นี้ว่า "Code Reuse"
การที่เอาราคาสินค้ามาคูณกับ
ปริมาณที่ 7 เปอร์เซ็นต์เท่ากับเท่าไหร่ แล้วจะทำอย่างไร
ตัวที่เหมือน
สามารถเรียกใช้ได้บ่อย ๆ เช่น สมมตินะคะ
นะคะ แล้วพอครั้งหน้าจะใช้ก็
เอาไปใช้ได้ หรืออย่างอื่น หรือคนอื่นจะเอาไปใช้ได้
ที่เอา
7 เปอร์เซ็นต์น่ะค่ะ Vat ก็คือ 7 เปอร์เซ็นต์ใช่ไหมคะ
ขั้นตอนในการสร้างนะคะ
ก็คือมันจะมีรูปแบบ เราจะต้องเขียนโค้ด
เราจะให้รู้ว่าตัวนี้เป็นค่า Vat เราก็อาจจะ
สร้างฟังก์ชันสำหรับการคิด Vat ขึ้นมาอย่างนี้
de
นั่นก็คือการประกาศตัวแปรนะคะ
เมื่อรู้ว่าแต่ต้องรู้ด้วยนะว่า
มีฟังก์ชันนี้อยู่ อย่างนี้นะคะ ทีนี้
แล้วตามด้วย function_name
น่ะค่ะ เขียนโค้ดให้ฟังก์ชันเราโดยตามรูปแบบ
ในที่เห็นนะคะ จะต้องมีคำว่า "def"
ให้เห็นว่าคำว่า def นะคะ
ตัวเล็กเท่านั้นนะคะ ไม่ใช่พิมพ์ด้วยตัวพิมพ์ใหญ่
บอกให้รู้ว่านี่นะ ฉันจะประกาศ
จะประกาศค่า ประกาศฟังก์ชัน ไม่ใช่ประกาศตัวแปร พูดผิด
เราต้องพิมพ์คำว่า def
เป็นตัวแรกนะคะ แล้วตามด้วย function_name function_name
เราต้องพิมพ์ d-e-f พิมพ์ด้วย
ตัวเล็กเสมอ ถึงได้ทำเป็นสีแดง
ให้นึกถึงฟังก์ชันเนม
ตั้งชื่อให้ตัวแปร แต่อันนี้เป็นการตั้งชื่อ
นึกออกนะนะคะ
ก็คือทุกครั้งที่พอจะมีการสร้างฟังก์ชัน
ใส่ชื่อฟังก์ชันเราต้องต้องพิมพ์วงเล็บ
เสมอนะคะ แต่ถ้าเราพิมพ์ใน Colab ตัววงเล็บนี้จะ
นั่นก็คือชื่อ ชื่อ
ของฟังก์ชันที่เราจะไว้เรียกใช้ในครั้งต่อไป เราจะเป็นคนตั้งเอง
พารามิเตอร์
ถ้าเป็นเขียนโค้ดปกติ มันก็จะหมายถึงตัวแปร
ฟังก์ชันนี้คือฟังก์ชันอะไรนะคะ เสร็จ
แล้วก็จะมีวงเล็บ พอใส่คำว่า "def" แล้วก็
อะไรล่ะ เขาเรียก
นี่ เขาบอกว่าพารามิเตอร์ของฟังก์ชันนี่
ขึ้นมานะคะ แล้วส่วนข้างในนี่
นะคะ เขาบอกว่ามันเป็นการกำหนดค่า Paramiter
พารามิเตอร์ตัวนั้นก็จะเป็นตัวเก็บให้เรา
สมมตินะคะ สมมติเราต้องการตำนวณหาค่า
นะคะ แต่ในฟังก์ชันนี่เราจะ
เรียกว่า "พารามิเตอร์" เพื่อไว้สำหรับ
ค่าของรัศมีวงกลม
หรือมีค่าของอะไรนะ
มีจำนวนเท่าไรก็ได้ ก็คือในฟังก์ชันนี้
เราจะมีการเก็บค่าของอะไรบ้าง
นี้นะคะ เสร็จแล้ว
เมื่อพิมพ์ function_name ใส่ค่าพารามิเตอร์
พื้นที่
วงกลมอย่างนี้นะคะ ค่าพารามิเตอร์ที่จะเก็บก็อาจจะมี
สังเกตนะคะ เมื่อใดที่
ตัวนั้นจะต้องปิดด้วยเสมอ แล้วขึ้นบรรทัด
เส้นรอบวงอะไรอย่างนี้เข้ามานะคะ นั่นก็คือ
ค่าพารามิเตอร์ที่เราจะไว้เก็บข้อมูลในฟังก์ชัน
แล้วเด็ก ๆ สังเกต
ดูนะคะ ว่าในการประกาศฟังก์ชันตัวที่ 1
อะไรเสร็จ เราจะปิดคำสั่ง
การประกาศฟังก์ชันด้วยโคลอนเสมอนะคะ
คือการคืนส่งค่าคืนกลับ
ซึ่งฟังก์ชันที่เราเขียน อาจจะ
ใหม่มันจะเข้าสู่ย่อหน้าใหม่
ตัว statements ในที่นี้หมายถึงคำสั่งอื่น ๆ นะคะ
รูปแบบนี้ให้เห็นทั้ง 2 แบบ
เป็นแบบที่ไม่มีการ return ค่า
นะคะ กับตัวที่ 2 ตัวที่ 2
จะมีคำว่า return value return ก็
เราต้องพิมพ์คำว่า return ด้วย
ตามด้วยค่าที่เราต้องการให้ส่งกลับ เช่น เดี๋ยวดู
เขียนแล้วมี return หรือ
ไม่มีก็ได้นะคะ แต่ที่เขียนให้ดูเป็นตัวอย่างนี่ ให้เห็น
ค่าที่ส่งกลับนั้นจะเรียกว่า
นะคะ
แต่แบบที่ 2 นี่มี มีการส่งคืน
ค่ากลับ ก็เลยจะมีคำว่า "return value" ก็คือ
ตัวแปรแลลไม่มีการ return
ไม่มีคำสั่ง return เพื่อคืนค่านี่ ใน
ในตัวอย่างจะเห็นชัดนะคะ เดี๋ยวยกตัวอย่าง
แล้วจะมองภาพไม่ออก ซึ่งเขาบอกว่า
hello()
def ก็คือ definition
ทีนี้เรามาดูตัวอย่างแรกก่อน
เพื่อจะให้เห็นว่าถ้าเราต้องการประกาศ
คือ def
แล้วก็ตามด้วย function_name ซึ่งในที่นี้ตั้งชื่อว่า
ตัวอย่างนี้เราจะประกาศตัวแปร
ชื่อ เห็นไหมคะ ตรง def แล้วตามด้วย
นะคะ แล้วทีนี้
พอเวลาเรียกใช้ฟังก์ชันนี้นะคะ มันจะสั้น
ก็คือคำสั่งเพื่อใช้
และติดประกาศตัวแปร ประกาศฟังก์ชัน ขอโทษทีนะคะ
แล้วตามด้วย พารามิเตอร์หรือ
ที่เราไว้เก็บค่า ก็คือ name นะคะ เสร็จแล้ว ตาม
hello นะคะ ฟังก์ชัน hello ก็คือ
ฟังก์ชันที่เราต้องใช้เพื่อแสดงคำทักทายออกมานั่นเอง
นะคะ แสดงคำทักทาย
ชื่อที่เรารับค่าเข้าไปนี่ หรือพารามิเตอร์ที่เรา
นึกออกนะ การเขียนโค้ดมันจะสั้น
กว่าที่เราเคยทำ
ไปที่ web browser
แล้วเปิดเหมือนเดิมนะคะ พิมพ์คำว่า "Colab" น่ะ
ด้วย statement ตามด้วยข้อความหรือคำสั่ง
หรือโค้ดอะไรก็แล้วแต่นะคะ ซึ่งในทีนี้เราต้องการให้แสดง
แล้วกด Enter เลย
เพราะสังเกตว่าเว็บไหนที่เราเปิดมันจะ
ส่งเข้าไป ก่อนอื่น เด็ก ๆ
เปิด Colab หรือยังคะ เปิด Colab ด้วย
ที่เราใช้งานนะ แล้วก็คลิก
c-o ต้องบอกว่า co สิ
Colab l-a-b นะคะ พิมพ์ l-a-b
run มันไม่ได้นะคะ เด็ก ๆ อย่าลืม
ลงชื่อเข้าสู่ระบบด้วย Login เข้าไปด้วย
อัตโนมัติเด็ก ๆ กด Enter ได้เลนย
มันก็จะเข้ามาหน้า
ของเราให้เรียบร้อยด้วย
Code นะคะ ลืมไป
อย่าลืมทำอะไรก่อน เข้าสู่ระบบนะ ไม่อย่างนั้นเราจะ
ไปที่เขียน code เหมือนเดิมนะคะ เด็ก ๆ
กดที่คำว่า "code" นะคะ ในบรรทัด
นะคะ
de แล้วกฌ f
ใช่ไหมคะ พิมพ์ด้วยตัวพิมพ์เล็กเสมอนะคะ
โอเคนะคะ เสร็จแล้วเราก็เริ่ม
ตัวใหญ่นี่ถือว่าไม่ถูกต้องนะคะ
def นะคะ แล้วก็กด
แรกของเรานะคะ เราก็เริ่ม
ประกาศฟังก์ชัน โดยพิมพ์คำว่าอะไรคะ
แล้วตามด้วชื่อของฟังก์ชัน
ชื่อของฟังก์ชัน ในตัวอย่างเรา ชื่อว่า Hello
ไม่ใช่พิมพ์ใหญ่แบบนี้นะ ไม่ใช่พิมพ์ D-e-f
Def แบบนี้ ตัวใหญ่นี่ถือว่าไม่ถูกต้องนะคะ
นะคะ ไม่ใช่ตัวพิมพ์ใหญ่นะคะ
ดูดี ๆ นะคะ เพราะฉะนั้น
Space bar เพื่อวรรค 1 ครั้งนะคะ
บอกแล้วว่าวิธีการประกาศฟังก์ชัน ก็คือพิมพ์คำว่า "def"
e-
l-l-o แล้วก็ใส่วงเล็บเข้าไป
ทีนี้มาดูชื่อ ชื่อของฟังก์ชันนี่
ก็ต้องใช้ตัวพิมพ์เล็กเหมือนกัน
name นะคะ ตัวพิมพ์เล็ก
เพราะมันเป็นตัวแปรชื่อว่า name เมื่อ
พิมพ์ตัว h
ด้วยตัวพิมพ์เล็กนะคะ h-
แล้วกด Enter 1 ครั้ง
ใช้วิธีกด Enter นะ ไม่ใช่เลื่อนเมาส์
แล้วก็ตามด้วย
พารามิเตอร์ ในวงเล็บพารามิเตอร์ของเรา ก็คือคำว่า "
Stagement
หรือคำสั่งต่อไปที่เราจะใช้ ก็คือคำสั่งแสดง
เสร็จฟังก์ชันใช่ไหม
เสร็จคำสั่งฟังก์ชันต้องปิดด้วยเครื่องหมายโคลอนเสมอ
n-t
print แล้วก็ตามด้วยวงเล็บเหมือนเดิม print อะไร
ลงไป สังเกตบอกแล้วพอกด Enter นี่
ตำแหน่งของเคอร์เซอร์มันจะ Tab เข้าไปนะ
เดี๋ยว
อ๋อ ขอโทษ ไม่ได้สลับหน้า
ผลนะคะ ก็คือคำสั่ง print
p-r-i
เราก็ว่าอยู่แต่เด็ก
พิมพ์ตามใน PowerPoint แต่อยากให้เห็นใน Colab
สิ่งที่อยู่ในวงเล็บอย่าลืมนะคะ เมื่อใดที่
บอกให้พิมพ์วงเล็บนี่ สังเกตมันจะมี () ขึ้นมานะ
นั่นน่ะสิ
เดี๋ยวเลื่อนไอ้นี่เอาก็ได้นะ
มันไม่สลับหน้า
ตลอดเลย
ไอ้ตัวข้อความด้วย
เดี๋ยวสิ้นสุดการนำเสนอก่อน
เพราะว่าเมาส์หาย
เมาส์จ๋า เมาส์จ๋า
โอเคไหม
เดี๋ยวนะ กำลัง
โอเคนะคะ นะ
ในนี้จะพิมพ์คำว่า "print" นะคะ เดี๋ยวจะโชว์
โอเคน่า
จะได้เห็น 2 อย่างนะ เห็นไหมคะ จะมาที่คำสั่ง print ของเรานะ
เดี๋ยวให้เห็น 2 หน้า
ด้วยกัน ไม่สิ ไม่สิ
แป๊บหนึ่ง
ขยับ
หามุม มุมให้เธออยู่
ขอ 2 ทำไมได้ 4 นี่
เดี๋ยวนะ เดี๋ยวจะ
แล้วในวงเล็บของ print
ลืมทำให้มันขึ้น 2 หน้าคู่กัน เดี๋ยวนะคะ
แล้วก็
ได้ไหม
ไม่เห็นหน้านี้อีก
โอเคไหม
อีกหน่อยหนึ่ง นะคะ
กระเถิบ
แล้วตามด้วย
เห็นไหม ตรงก่อน... ตรงก่อน Hello มี
ไม่เห็นในสไลด์อีกสิ
ส่วนแบ่งทางการตลาดเยอะ
แล้วค่อยพิมพ์ Hello ด้วยตัวใหญ่
แล้วก็ตามด้วย
วงเล็บในวงเล็บของคำว่า "print"
เราจะ print คำว่า "hello" นะคะ
แล้วหลังเครื่องหมายคำพูด
เด็ก ๆ ต้องเลื่อนไอ้ตัวนี้ไปหลังเครื่องหมายคำพูดนะ
เครื่องหมายคำพูดนะดูดี ๆ อาจจะเห็นไม่ชัด
ใส่เครื่องหมายคำพูดนะคะ Single Quote หรือ
name ตัวเล็กนะ ดูดี ๆ นะ เราเรียกใช้ เราสร้าง
เครื่องหมาย % %s
นั่นคือ ข้อความนี้เป็น String นะคะ
นี่คือเสร็จฟังก์ชันนี้แล้ว
ลองเรียกใช้งาน ลองกด Play ก่อน
พิมพ์ % name
แล้วก็พิมพ์เปอร์เซ็นต์ แล้วตามด้วย
ที่เรา code
ที่เราเขียนไปนี่มันถูกไหม ถ้าผิดมันจะขึ้น Error ใช่ไหมคะ
พารามิเตอร์ด้วย name ตัวเล็กเวลาเรียกใช้ก็ต้องใช้ตัวเล็ก
นะคะ
มันก็จะยังหมุนติ้ว ๆ อยู่นะคะ เราก็ต้องรอนะคะ
ขอโทษ เราจะได้รู้นะคะ
การกดตัวนี้นะ เพื่อจะได้เช็กว่า
แสดงว่าไม่มีอะไรผิดนะคะ
ไม่ทำอะไรนะ เพราะฟังก์ชันสร้างขึ้นมา สร้างแล้ว
ครั้งแรกเวลาโค้ดมันก็จะช้านิดหนึ่ง
นะคะ ตอนนี้คือสร้าง
เพื่อให้คอมพิวเตอร์มันจำ จำไว้ว่าตอนนี้เราสร้าง
เพื่อจะให้ตรวจสอบว่า
โค้ดที่เราเขียนไปมันถูกหรือเปล่า ถ้าผิดมันจะแสดง Error
แล้วอย่าลืมว่ามันจะต้องมีการเรียกใช้ นึกออกนะ
ต้องสร้าง สร้างเพื่อให้มันไปโดนเรียกก่อน มันถึงจะทำงาน
ของใครขึ้น Error ยกมือ
สิ่งที่ต้องเช็ก ก็คือ 1. คำสั่ง
ฟังก์ชันชื่อว่า hello แล้วนะคะ
ที่ให้กด Run นี่
ก็คือชื่อฟังก์ชัน
ใช้ตัวเล็ก และตัวที่ 3 พารามิเตอร์ พามิเตอร์จะ
นะ ถ้าเขียนไม่ผิดมันก็ไม่แสดงใช่ไหมคะ
นี่ลอง Run แล้วนะคะ Error ไม่ขึ้นนะคะ
การประกาศฟังก์ชันด้วย
โคลอนเสมอนะคะ
d-e-f นะคะ definition
การประกาศฟังก์ชัน ตัวที่ 2
ประกาศฟังก์ชันที่ 1 ไปแล้ว
มาดูแบบที่ 2 นะคะ ฟังก์ชัน
มีค่าอยู่ในวงเล็บเสมอ
นะคะ เสร็จแล้วต้องปิด
สลับไปสลับมา
กันอยู่นี่ล่ะเรา อันนี้ อันนี้แบบไม่มี
ทีนี้เมื่อกี้
เราใช้เราสร้างฟังก์ชันนี้
ขึ้นมาเพื้อต้องการให้มันแสดงข้อความ เอา
ที่มีการ return หรือส่งกลับค่า
เดี๋ยวขยายหน้าไอ้นี่ให้ก่อน
ตัวนี้
ทำไมหนก่อนไม่เห็นมี หรือเพราะเป็น
return ค่านะ
ในตัวอย่างนี่เราสร้างฟังก์ชันชื่อ hello นะคะ
เป็นปัญหาในการใช้งาน
จะได้ใช้ Windows อื่นเสียล่ะมั้ง
อีกแล้วอะไรอีกหว่า
สลับจอไม่ได้เลย น่าจะเป็นกับไอ้
เราจะประกาศฟังก์ชัน
มีการใช้ return value หรือการคืนค่ากลับ
ไอ้นี่บ่ะ Windows 11 นี่บ่ มันถึงขึ้น
ไอ้สลับไอ้จอไอ้นี่ทุกทีเลย แล้วก็
โดยมีพารามิเตอร์ 2 ตัว
width แล้วก็ความ... width แล้วก็
สลับไอ้จอไอ้นี่
นะคะ มาดูตัวอย่างที่ 2 นะคะ
กว้างคูณยาว
เพราะฉะนั้น ค่าพารามิเตอร์ที่ไว้ใช้สำหรับเก็บค้า
ในตัวอย่างที่ 2 เป็นการประกาศ
ฟังก์ชันที่ชื่อว่า area()
ว่า width
นั่นเองนะคะ เสร็จแล้วปิดด้วยโคลอน
height ซึ่ง area ในที่นี้ึ
พื้นที่ สูตรการหาพื้นที่สี่เหลี่ยม ก็คือ
สำหรับคำนวณ
ความกว้างคูณความยาว ก็คือคำนวณ
ก็คือค่าความยาวกับความกว้าง
นั่นเองนะคะ ก็เลยตั้งชื่อตัวพารามิเตอร์ 2 ตัวนี้
นะคะ ก็คือให้ส่งกลับค่าของ c
ก็คือเมื่อเอาพารามิเตอร์มาคำนวณแล้วนี่ c จะได้เท่าไหร่
Statement ต่อมาสร้างตัวแปร
ชื่อว่า C ตัวแปร C
แบบมีการ return ค่า
เพราะฉะนั้น บางคน
หาพื้นที่ของสี่เหลี่ยมนั่นเองนะคะ
แล้วทำการ return ค่า c
แล้วมันก็จะไม่ขึ้นไอ้หน้านี้
ส่งกลับค่าให้ c นะคะ
นี่คือการประกาศฟังก์ชัน
มันไม่สลับ Extend หรือ
คีย์ใน Colab ไปเรียบร้อยแล้วนะคะ
เรามาเริ่มคีย์ของเราด้วยนะคะ
โอเค ต้องสลับ
อีกแล้ว มันเป็น
อะไรกับ...
อย่างนั้นก็ต้องมาจัดไอ้นี่ใหม่อีกแล้วนี่
มันไม่ขึ้นหน้าจออีกแล้วน่ะ
ไม่เห็นตัวหลังอีก เอา
2 รอบเชียวหรือนะคะ
เอาไว้ก่อน
ไม่เห็นอีก มัน
แป๊บนึงนะสลับหน้าก่อน
โอเคไหม
เห็นไหม
ไปไหนแล้ว
น่านักเชียว
ที่ 2 ต่อด้วยฟังก์ชันแรกได้เลยนะคะ
เมื่อหลังฟังก์ชันแรกเรากด Enter กดลงไป
Colab
ตำแหน่งตรงกับชิดขอบ
แล้วก็เริ่มพิมพ์คำสั่ง definition
นะคะ
เราประกาศฟังก์ชัน
วรรคตามด้วย area
ตัวเล็กนะคะ
2 อันเลยก็ได้เด็ก ๆ สังเกตตำแหน่งมันจะ
Tab เข้าไปนะ เรากดย้อนคืน 1 ครั้ง
จะต้องมีพารามิเตอร์อยู่ในวงเล็บ
ก็คือพารามิเตอร์ตัวที่ 1 ชื่อว่า width w-
d-e-f เพื่อประกาศใช้คำสั่งฟังก์ชัน
ที่ชื่อว่า... ชื่อฟัง์ชันของเราชื่อว่า area() นะคะ
ขั้นพารามิเตอร์
ตัวต่อไป ด้วยเครื่องหมาย
แล้วก็
ตามด้วยเครื่องหมายวงเล็บ เพราะบอกแล้วมีชื่อฟังก์ชัน เสร็จแล้ว
นะคะ แล้วก็ตามด้วย
ชื่อพารามิเตอร์ตัวที่ 2 นะคะ ก็คือ h
i-d-
t-h นะคะ คั่น
นั้นเองนะคะ มีพารามิเตอร์
สำหรับเก็บความยาวกับความกว้างนะคะ ก็คือ width กับ height
Comma
นะ คอมมาหรือไอ้ลูกน้ำเรา
เสมอ
เมื่อเราประกาศฟังก์ชันเสร็จแล้วนะคะ เรา
-i-
h-e-i-g-h-t height หรือสูง
อัตโนมัตินะคะ
เสร็จแล้วเราประกาศตัวแปร ชื่อว่า c เพื่อ
ปิดการ
ประกาศฟังก์ชันของเราด้วยเครื่องหมายโคลอน
เพราะสูตรการหาพื้นที่สี่เหลี่ยม
กว้างคูณยาวนะ เพราะฉะนั้น เราอยากรู้พื้นที่สี่เหลี่ยม
กด Enter เพื่อไปพิมพ์
Statements ใหม่นะคะ เคอร์เซอร์มันจะ Tab เข้าไป
เมื่อเราพิมพ์นี่ ให้เรา
width w-i-d-t-h เพราะอย่างนี้ทำให้เรา
ทำการคำนวณค่าพารามิเตอร์ 2 ตัวของเรา
ก็คือเอา width
เครื่องหมาย คูณในที่นี้ก็คือเครื่องหมายดอ
ตัวแปรทางคณิตศาสตร์ของโปรแกรม
เอากว้างไปคูณกับยาว เพราะฉะนั้น ก็ต้องเอาพารามิเตอร์ width
ตัวนี้เด็ก ๆ ดูนะ
พารามิเตอร์ตัวที่ 2
h รอสักพัก แล้วหาคำว่า "height" นะคะ
พิมพ์พารามิเตอร์หรือตัวแปรที่เราสร้างไว้
ไม่ผิดนะคะ แล้วใส่เครื่องหมายคูณ
เห็นไหมคะ เจอตัวนี้ปุ๊บ
คลิกเลย เพราะบางคนจะมีปัญหา เมื่อ
คอมพิวเตอร์เครื่องหมายคูณ ก็คือเครื่องหมายดอกจันนะคะ
แล้วตามด้วย
Error
เพราะฉะนั้น ตัว Colab นะคะ
h-e-i-g-h-t
อาจจะพิมพ์ h-e ก็ได้ น่าจะขึ้น
เห็นนะคะ พอเราเห้นเราคลิกเลือกมันได้เลย
นะคะ เมื่อได้
ชื่อตัวแปรหรือพารามิเตอร์เริ่มยาวหรือยาก
จะพิมพ์ผิด แล้วพอพิมพ์ผิด พอไป Run โค้ดมันจะเกิด
คำสั่งหรือ code ของ
นะคะ แล้วในบรรทัดต่อไป เราจะใช้
ที่ดีเลย คือ เมื่อเราพิมพ์
ตัวแรกขึ้นมา ตัวแปรตัวนั้นมันก็จะขึ้นมาให้
พิมพ์ด้วยตัวเล็กนะคะ
ค่าที่เราต้องการให้แสดง หรือ...
Statement เพื่อการคำนวณแล้ว
ต่อไปเราจบ
ค่าของการที่เราคำนวณพื้นที่
c นั่นเองนะคะ เพราะฉะนั้น return c ตามด้วย c
คำสั่งในการคืนค่าหรือ return value
โดยการพิมพ์คำว่า "return"
เหมือนเดิมนะคะ
เพื่อเป็นการเช็กโค้ดของเรา ก็คือกดตัว
หรืออะไรก็แล้วแต่ ซึ่ง
ค่าที่เราต้องการให้มันแสดงหรือเห็นนี่ ก็คือ
ว่า code ที่เราเขียนนี่
ถูกต้องแล้วนะคะ มีใคร
ไม่มั่นใจก็คลิก c
ที่มันขึ้นมาอย่างนี้นะคะ
แล้วนี่คือ
การประกาศใช้ฟังก์ชัน หรือการสร้างฟังก์ชัน ทีนี้
Play ที่เป็นรูปเหมือนเป็น
Play Video Play Music อะไรพวกนี้ ให้มันเช็ก
เราต้องไปเรียกใช้งาน
มันถึงจะแสดงไอ้ผลพวกนี้ออกมาได้
ขึ้น Error ไหมคะ
ไม่มีนะคะ แสดงว่าเริ่มมีความชำนาญในการโค้ดแล้ว
ไม่สลับโหมดแล้วนะ
เดี๋ยวสลับไปสลับมา เราก็ เราก็แก้
บอกแล้วว่าเมื่อสร้างเสร็จแล้วนี่
ไม่เห็นผลอะไรเลยใช่ไหม พอเรากด Play นี่
ขอย่อให้มันพอดีหน่อย
โอเค
เพราะฉะนั้น เราจะมาดูเนื้อหา
ต่อไปนะคะ ก็คือ...
โหมดเป็นยังไงนี่
ขึ้นไหม ขึ้นอยู่ โอเค สลับได้
ไม่ได้อีก เดี๋ยวเสียเวลาในการแก้โหมด
หน้าจอนะคะ
เมื่อสร้างเสร็จแล้ว
มันต้องเรียกใช้เสียก่อนนะคะ เราถึงจะรู้ว่าฟังก์ชันที่เราสร้าง
ก็จะเล็กไปอีกใช่ไหมถ้าย่อ แล้วสลับ
ก็คือในนี้
พอเราสร้างฟังก์ชันแล้วนะคะ เราต้องเรียกใช้งานมัน วิธีการเรียก
นะคะ เมื่อกี้บอกแล้วว่าถ้าเรา
ทำใน Colab เป็นการสร้างแล้วนะ ต่อมา
และส่ง อาร์กิวเมนต์
อะไร เมื่อกี้มีพารามิเตอร์ มามี Argument อีก
มันใช้งานได้จริงไหมนะคะ
การเรียกใช้งานฟังก์ชันนะคะ
ก็เป็นคำ ไม่ใช่คำ
เป็นค่าที่เราส่งเข้าไปในฟังก์ชันนะคะ
ใช้ ก็คือเราจะใช้ชื่อของ
ฟังก์ชัน เห็นไหมคะ
ในฟังก์ชันเพื่อรับค่า
เมื่อกี้พารามิเตอร์ที่เรามีตัวที่ 1 ชื่อว่า
Argument กับ Parame
เดี๋ยวมีคำอธิบายนะคะ ว่า Argument
มันรับค่านั่นเองนะคะ
มาดูตัวอย่างวิธีการเรียกใช้ฟังก์ชันนะคะ
ตอนที่เราใช้งานนะคะ
ส่วนพารามิเตอร์น่ะ คือ ตัวแปรที่เรากำหนด
อะไรพิศดาลเลยเพียงแต่เราพิมพ
ชื่อฟังก์ชันนั้น แล้วตามด้วย
name นั่นคือตัวแปรที่เราใช้รับค่า
เพราะฉะนั้น Argument ก็คือชื่อที่เราจะพิมพ์เพื่อให้ตัวแปร
ชื่อเพราะในวงเล็บนี่
ิสิ่งที่เป็นตัวแปรชื่อว่า name นะคะ พารามิเตอร์
มาดูตัวอย่างกันก่อน
การจะเรียกใช้ฟังก์ชันที่เราสร้างขึ้น ไม่ได้มี
ที่เราจะให้
มันเก็บเลยนะ นะคะ ลองดูนะคะ
เห็นไหมคะ ตามด้วย Argument
ในที่นี้ ก็คือ
หรือมันช้า พอ... พอสลับมา Colab มันจะช้า
น่ะชื่อว่า name แล้วพอเราเรียกใช้นี่
ก็คือเราพิมพ์ชื่อฟังก์ชันนั้น แล้วตามด้วยค่า
ลองเลย ลองเลย เพื่อให้เห็นภาพ
นี่คือฟังก์ชันเวลาเรียกใช้
ไม่ได้มีอะไรพิสดารเลยนะคะ ใส่ Hashtag ก่อน
นิดหนึ่งหรือ ไม่สลับ
อีกแล้วนะ อะไรนะ
ใส่เครื่องหมา chap หรือ hahtag
อันนี้คือคอมเมนต์นั่นเองนะคะ เพื่อจะบอกให้รู้ว่า
โอเค เรา
ก็จะต้องสลับกันอย่างนี้นะคะ นี่นะ เราไปประกาศไปแล้วนี่
แล้วก็ตามด้วยฟังก์ชัน f-u-n เด็ก ๆ ไม่ต้องพิมพ์ ไอ้นี
เพื่อจะให้รู้ว่าตรงนี้เป็นส่วนของ
เราเรียกการใช้ฟังก์ชันนี้ ก็เลย
ตรงนี้เราจะเรียกใช้ฟังก์ชันที่เราสร้างแล้วนะ calling
calling นะคะ calling ก็
ฟังก์ชันแรกที่
ก็ได้นะคะ
ฟังก์ชันแรกของเรา
ชื่อว่า hello ใช่ไหมคะ แล้วตามด้วยเครื่องหมายวงเล็บ
ทีนี้เราไม่อยากใส้ Danny เราใส่ชื่อเราเองไปก็ได้
เราจะเรียกใช้ชื่อ ก็คือเวลาจะเรียกใช้มัน
พิมพ์ชื่อฟังก์ชันนั้นนะคะ พิมพ์ hello เลยนะคะ
เครื่องหมายคำพูด
หรือ Double Quote นะคะ name
นะคะ เห็นไหมคะ มันจะขึ้นมาบอกเลย name
name คืออะไร name ในที่นี้ ในตัวอย่าง ก็คือ Danny นะคะ
ชื่อนึกออกนะ เช่น
เนื่องจาก name เป็น string อย่าลืมใส่เ
สมมติ
เรียกฟังก์ชัน hello ไปแล้ว ฟังก์ชันต่อมา
ใส่ชื่อเราแทน Danny ก็ได้นะคะเด็ก ๆ
เราอยากให้มันแสดงค่าพื้นที่
นะคะ ก็เลยใช้คำสั่ง
จะใส่ชื่อเล่นหรือชื่อจริง
ก็ได้ แล้วแต่นะคะ
ทำให้ดูก่อน
p-r-i-n-t
ที่เราจะเรียกใช้นะคะ
ก็คือ area() แต่ area() ที่เรา
ตำแหน่งของฟังก์ชันชิดนะคะ
ไม่วรรคนะคะ นี่ ไม่ต้อง Tab เข้าไปนะ
print ก่อน แล้วไปเรียกฟังก์ชัน
นั้นไว้ใน print นะคะ ให้ print แสดงนะคะ ดูตัวอย่าง
ลืมแก้ภาษาขอโทษที
ด้วยแสดงคำว่า
เป็นข้อความนะคะ เพราะฉะนั้น
ตัวที่ 2 นะคะ
สี่เหลี่ยม
เราจะใช้คำสั่ง print
ฟังก์ชันนะคะ เพื่อให้แสดงแล้วก็เรียกใช้ฟังก์ชัน
ใส่เครื่องหมายเท่ากับนะคะ เปลี่ยนภาษา
เมื่อเป็นข้อความ พิมพ์เป็นภาษาไทยก็ได้
ไม่ต้องใช้คำว่า "area" ในภาษาอังกฤษ ก็คือพื้นที่
เปอร์เซ็นต์แล้วก็ d
แล้วหลังเครื่องหมายคำพูด
=
แล้วก็
พิมพ์ฟังก์ชัน area a-
ก่อน =
%d นะคะ %d เท่ากับ แล้วก็
e-a นะคะ
แล้วก็วงเล็บ
ตามด้วย % แล้วเรียกใช้
ฟังก์ชัน area นะคะ ตามด้วยเครื่องหมายเปอร์เซ็นต์
เอามากกว่านั้นก็ได้นะ
ในตัวอย่างบอกว่าความกว้าง คือ 8 ความสูง คือ 4
r ปุ๊บ ขึ้นหรือยัง
A-r-
ความสูง 4 นี่ความสูงนี้
เท่าไหร่ ตอนนี้เราพิมพ์คำสั่งหรือโค้ด
ทีนี้ใส่ Argument
ให้ 2 ตัว ก็คือ 8 นะคะ กว้าง 8
จะแสดงผลอย่างไร
Error เด้งขึ้นมา ณบัด Now
ถ้าพื้นที่ที่มี
ความกว้าง พื้นที่สี่เหลี่ยมที่มีความกว้าง 8
เกิดอะไรขึ้น
print
เสร็จหมดแล้วนะคะ
เด็ก ๆ ลองกด Play ดูได้เลยนะคะ ถ้าใครพิมพ์เสร็จแล้ว
ตัวแปร ตัวแปรผิด เดี๋ยวนะ ค่อย ๆ ไล่นะคะ
บรรทัดที่ 9
สังเกตนะคะ เมื่อขึ้น Error
เด็ก ๆ ดู เห็นไหม มันจะชี้ไปที่บรรทัดผิด
เสร็จแล้ว
มันบอกว่าในบรรทัดที่
พอขยายแล้วของตัวเองก็เล็ก
แบบนี้นะ เดี๋ยว
ไม่อยู่ใน Index
S ตัวใหญ่หรือ s เล็กใช่ไหม ขอโทษที
พิมพ์ตัวแปรผิดหรือ ฟังก์ชันชื่อฟังก์ชัน
ถูกแล้วนะ hello ถูกต้องนะคะ
แก้ได้ ๆ
เห็นไหมคะ
2 % name
value error ค่า error ตรง...
แม่ไม่ได้ดู s มันเป็นตัวมหญ่ตาม
คือ ไอ้พวก % d % อะไรนี่
พิมพ์ s ผิดใช่ไหมนี่
%s
ตัวพิมพ์เล็เกแค่นั้นเอง
เมื่อกี้ตรงลืมพล็อต
ให้ดูก่อน เมื่อกี้ตอนแม่พิมพ์ %s
พอมาไล่ฟังก์ชัน
พิมพ์เล็กมันไม่ใช่ตัวพิมพ์ใหญ่ แม่ไปพิมพ์ใหญ่
ถ้าเด็ก ๆ ผิดตำแหน่งนี้ แก้แค่ตัว S จากตัวพิมพ์ใหญ่ เป็น
%s' name
การขึ้น Error นะ เดี๋ยวแก้ให้ดูนะคะ
ย้อนกลับไปดู อ๋อ s ฉันพิมพ์ผ
ฉันต้องพิมพ์เป็นตัวเล็กนะคะ พอแม่แก้
มันจะขึ้นลูกศรชี้ไปที่บรรทัดไหน นั่นหมายความว่า
มันหมายความผิดพลาดที่
มันก็จะแสดงขึ้นมา เห็นไหม มันก็จะพิมพ์คำว่า...
มันก็จะไปเรียกใช้ ไอ้ตัวนี้
ตรง value error เห็นไหม ค่าที่มัน error ค่ามัน
อยู่ที่คำว่า s อ๋อ
ที่จะให้มันแสดงแต่
ตอนที่ทำงานน่ะ มันมาทำงานที่ตัวนี้เห็นไหมคะ
จากตัวใหญ่เป็นตัวเล็ก
เรากด Play น่ะ Error มันก็หาย แล้วผลลัพธ์
คำว่า "print" ไว้
พอเวลามาเรียกใช้เธอ เราก็เลยมาพิมพ์คำว่า...
ออกมาเลย ทั้ง ๆ ที่ ตอนเรียกนี่ เราพิมพ์แค่
ฟังก์ชัน แล้วก็ตามด้วยค่า Argument
สามเหลี่ยม 8 x 4 = 32 ถูกต้องนะคะ
มันก็จะส่งค่า c ที่มาคำ
ตัวคำว่า "print" แต่ตรง area นี่
นะคะ ตรงฟังก์ชัน area
พื้นที่ สี่เหลี่ยม
ของเรานี่นะคะ มีค่า =
มีแถมตัว r มาจากไหนนี่
สามเหลี่ยม = %d'
แสดงทศนิยมออกมานะคะ
ลองดูอีกสักตัวอย่างหนึ่งไหมคะ
มาแสดงตรงนี้เห็นไหมคะ
เป็น 32 นะคะ มันก็เลย print คำว่า "
เด็ก ๆ ลองนะคะ ทีนี้ให้
ใส่ชื่อเล่นตัวเองลงไป
%d นั่นหมายถึง
ให้แสดงเป็นเลขจำนวณเต็มนี่
ลอง ลองเรียกใช้
ฟังก์ชัน hello อีกนะคะ
เห็นไหมคะ มันจะขึ้นมาเป็น
เอาแต่ hello อย่างเดียวให้เห็น
ไม่แน่ใจว่ามันจะไปเรียกใช้ได้อีกไหม
มันจะไปเรียกใช้ได้อีกไหม
ใส่ชื่อเล่นเรานะ
ไม่ได้ไปเรียกต่อจากเมื่อกี้
ลองพิมพ์ฟังก์ชัน hello ที่เราสร้างไว้
ตัวต่อไปอันนี้ไม่มันก็จะ
ทำซ้ำไง เพราะเรายังอยู่ในตัวเดิมนะ
มีตัวใหม่ใช่ไหม แล้วลองเรียกใหม่
จากโค้ดที่เราเพิ่มเข้ามา ลองเรียกนะคะ
ลองดูสิ มันจะขึ้นอย่างไร ลองดูนะคะ
ก่อนหน้า ลืมแก้ภาษาอีกแล้ว
พิมพ์เรียกใช้ฟังก์ชัน
ทีนี้ลองใส่ชื่อเล่น
หลาย ๆ คน ใส่ชื่อเพื่อนลงไปด้วยสัก 3 คน
เพราะบอกแล้วว่า Argument นะคะ
มีกี่คนก็ได้ ลองสิขึ้นไหม
ตัวเดียว แต่เราไปใส่หลายตัวนะคะ มันจะใส่ได้
ตามจำนวนพารามิเตอร์ด้วยนะคะ เพราะฉะนั้น ในกรณีนี้
ให้มันมีหลายคนนะคะ เราต้องไปแก้ที่ฟังก์ชันเรา
Syntax error เพราะอะไรคะ
เพราะไอ้ตัวนี้มันมีพารามิเตอร์ใ
แล้วลอง ลองมาใส่ที่ตัวนี้ใหม่
ถ้าเราจะเพิ่มให้มันมีหลายคน
ถ้าเราจะเพิ่ม
เข้าใจแล้ว
แสดงว่าไม่เรียก อ๋อ
มัน มันข้ามไปสร้างตัวใหม่
Type Error ชนิดไม่ถูกต้องนะคะ เพราะ
ฟังก์ชัน Hello เราน่ะ
เราไปใส่ 3 ก็คือถ้าเราต้องการให้มีหลายตค
ไปเพิ่มตัวนี้นะคะ เพิ่มขึ้น
นี่ไง ๆ มันขึ้นเตือนว่ามาว่า
ไปวิธีแก้ไม่ได้ยากเลยนะคะ
ถ้าจะ... เรามาเปลี่ยนที่ตัวฟังก์ชันหลัก
Position ให้แค่ 1 ตำแหน่ง
นะคะ ใน Argument แต่
นี่คือเมื่อ... จำไว้เลยว่าเมื่อ
ตอนจะเรียกใช้แค่พิมพ์ชื่อ
เพราะฉะนั้น
Argument ลงไปแค่นั
มันชื่อนี้เวลาเราเรียกใช้มันนี่ เราเอามา
เพราะตอนเรีกยใช้ไอ้ตัวนี้มันเรียกแค่
ใช่หรือเปล่าอย่างนี้เป็นต้นนะคะ
มัน... พอมันโดนเรียกใช้นี่มันจะกลายเป็น
Argument แต่ตอนที่มันเป็นฟังก์ชันนี่
แล้วในวงเล็บนี่ เราพิมพ์
ค่าของ... เขาเรียกว่า "
เราเอาฟังก์ชันนั้นมาใช้งาน สิ่งที่อยู่ใน
วงเล็บจะกลายเป็น
ทั้งชื่อฟังก์ชันกับวงเล็บ แต่สิ่งที่อยู่ใน
วงเล็บนี่ ก็คือเราใส่เข้าไปได้เลย
นี่ นี่คือส่วนของการสร้าง
ฟังก์ชันและการเรียกใช้ฟังก์ชันนะคะ มาดูหัวข้อ
ตรงในวงเล็บนี่คือ
หรือตัวแปรที่จะไว้รับค่านะคะ แต่พอ
เหลืออีก 2 หัวข้อ
เดี๋ยวนะ เดี๋ยวนะ
รับเข้าไปนั่นเอง
นะคะ
โอเค
ต่อมาของเราก่อนดีกว่านะคะ เดี๋ยวเด็ก ๆ จะได้
ไปเดินงานวันวิทยาศาสตร์ต่อ
คืออะไร มันเป็นการกำหนด
Default Argument นี่
สลับหน้าจอก่อนไม่สลับไม่ได้
ค่าที่เราจะส่งเข้ามาในฟังก์ชันตอนแรกนะ
ทำให้สามารถเรียกใช้งานฟังก์ชัน
ดูส่วนต่อมานะคะ ส่วนที่เรียกว่า
"Default Argument Value"
เห็นไหม
นี่นะคะ ในตัวอย่างนี่ สร้างฟังก์ชัน
กำหนดค่าเริ่มต้นนะคะ เป็นการกำหนดค่าเริ่มต้นให้
กับไอ้ค่า
เห็นไหม ใส่ Argument เข้าไปด้วยเลย มี พ
Salary มี Argument =
โดยส่ง Argument ที่น้อยกว่าจำนวนที่กำหนดไว้ก็ได้นะคะ
ดูตัวอย่างจะเห็นภาพชัด
แล้วกำหนด Argument ให้มันด้วยเลยนะคะ แล้วก็
สร้างพารามิเตอร์ตัวที่ 2 ชื่อว่า lang
ชื่อว่า show_info
ไม่ได้ใส่เป็นพารามิเตอร์
แล้วก็สั่งให้ print
84360 เห็นไหมคะ
นี่คือการ Defal
ก็คือ Argument ที่ชื่อ...
ไม่ใช่ print Argument print parameter
หรือ Language นะคะ มาจากคำว่า "Language"
แล้วใส่ Argument ที่ชื่อว่า Python
ตอนเราเรียกใช้ ให้เด็ก ๆ ดูตอน Calling Function
ใน name นี่เราไม่ได้กำหนด Argument ให้เหมือน salary
print ที่ 1 บอกให้ print เฉพาะแค่ชื่อ
print ที่ 2
พอ พอเราเรียกนะคะ เรียกใช้มันปุ๊บนี่
อันนี้ผิดนะนี่ พิมพ์ผิดขอโทษ มันต้องเป็น
นะคะ ที่ชื่อ Salary เห็นไหม print Name print Salary
แล้วก็ print
ไหง มือบอกไปพิมพ์ Java สะงั้น
สะอย่างนั้น เพราะ Argument ที่เราใส่เข้าไป
กับ Lang Language
เห็นไหมคะ
Python ขึ้นมา ไม่ใช่ JAVA
เดี๋ยว ๆ ขอแก้ก่อน
เมื่อกี้กลับมาแก้
ดูนะคะ เดี๋ยว
ชื่อ Python นะคะ
นะ เพราะฉะนั้น เปิด Colab ของเรา
ขึ้นมาไว้นะคะ
ไม่สลับอีกแล้ว ไม่เป็นไร
โอเค สลับได้ เดี๋ยวสลับไป เดี๋ยวสลับไม่ได้ เดี๋ยวจะตีมือ
นะคะ โอเค
เราจะลองทำฟังก์ชันแบบกำหนด Argument ด้วย
นะคะ
ทีนี้ สร้างโค้ดใหม่เลยนะ
เด็ก ๆ กด + เพิ่มโค้ดใหม่ไปเลย
แล้วเราก็ต้องสลับ
โอเคสลับได้
มาดูแบบที่ 2 ที่เราสร้างฟังก์ชันที่มีการ...
นะคะ ฟังก์ชันแบบที่ 2
จะได้ไม่ไปงงกับอันแรกนะคะ อันแรกเป็นการสร้างฟังก์ชันแบบปกติ
ที่ไม่ได้กำหนดค่า Argument ให่
ให้ Argument ในฟังก์ชันเลยนะคะ ก่อนอื่น เราก็ต้องพิมพ์
คำสั่ง def
มันทะลุจอไป
จอไป
ชื่อฟังก์ชัน ซึ้งในตัวอย่างใช้คำว่า "show_info"
นะคะ ไม่อยาก
ชื่อว่า Default Argument Value
นี่นะคะ แบบที่มีการกำหนดค่า
ถ้าชื่อมันเป็น 2 ประโยคนี่ เขาจะใช้ Under sco
แยกประโยคที่ 1 กับประโยคที่ 2 เห็นไหมคะ s-
d-e-f เพื่อประกาศตัวแปร... เพื่อประกาศ
ฟังก์ชัน แล้วก็ตามด้วย
ประโยคที่ 2 คือ คำว่า "info"
ก็คือโชว์ข้อมูลนั่นเองนะคะ info ย่อมาจาก
ตั้งชื่อยาวกว่านี้ก็...
สังเกตนะคะ เวลาตั้งชื่อ ฟังก์
สร้างฟังก์ชันที่ชื่อว่า show_info นะคะ โดย
ในนั้นนี่ กำหนดพารามิเตอร์
h-o-w show คือ ประโยคที่ 1
show คือแสดงนะคะ แล้วตามด้วย
แล้วมีพารามิเตอร์ที่ 2 คั่นด้วย
โคลอน ไม่ใช่โคลอน คอมมา
information นั่นเองนะคะ
ตอนนี้เราสร้างฟังก์ชันที่ชื่อ
แล้วก็ตามด้วยชื่อพารามิเตอร์ตัวที่ 2 ซึ่งพารามิเตอร์ตัวที่ 2 นี่
เราจะกำหนดค่า
ตัวที่ 1 ชื่อว่า name n-a-m-e
name นะคะ
ซึ่งแปลว่าเงินเดือนนั่นเองนะคะ salary
เรียกผิด เรียกถูกตลอดเลย
นะคะ
อันนี้กำหนดเองได้เลยนะคะ เด็ก ๆ อยากได้เม่าไหร่ เด็ก ๆ กำหนดเอง
ใส่เข้าไปเองเลย
Argument ให้เขาไปเลยนะคะ เพราะฉะนั้น พารามิเตอร์
ตัวที่ 2 ชื่อว่า
อันนี้
ซึ่งแปลว่าเงินเดือน อยากได้เงินเดือนเท่าไหร่เด็ก ๆ
ตรงเครื่องหมายเท่ากับใส่เข้าไปนะลูก
สิบ ร้อย พัน หมื่น นะคะ 20,000
ปุ๊บนะคะ เสร็จแล้ว
ืn-g lang นะคะ
แล้วตามด้วยเครื่องหมาย =
เขาบอกว่าค่าเริ่มต้นที่ให้ สมมติ 20,000
หน่วย หน่วย
ในที่นี้ภาษาเริ่มต้นเข้าบอกว่า Python
เพิ่มพารามิเตอร์ตัวที่ 3 ชื่อว่า
lang ซื้อมาจากคำว่า
เมื่อจบ เมื่อจบ
การประกาศฟังก์ชัน ปิดด้วยเครื่องหมาย :
แล้วก็ตามด้วยชื่อ...
คำว่า Python lang
ชื่อว่า show_info นะคะ ดูไปด้วย
อธิบายไปด้วย มีพารามิเตอร์ทั้งหมด 3 ตัว
เมื่อเสร็จ
แล้วก็มี lang โดยกำหนด Argument
ของ
เสมอนะคะเด็ก ๆ
ตอนนี้เรามีฟังก์ชันที่
หลังจากนี้ ก็คือ 1. นะคะ print ค่ะ ให้ใช้คำสั่ง
print
คือ name salary นะคะ โดยที่ salary นี่
กำหนด Argument เริ่มต้นด้วยที่ 20,000
ก็จะอยู่ในเครื่องหมายคำพูด แล้วตามด้วย
ข้อความ ซึ่งในที่นี้
Language นี่นะคะ ว่า Python
เมื่อประกาศฟังก์ชันเสร็จ
ก็คือชื่อนะคะ
แล้วก็ตามด้วยเครื่องหมาย :
print อะไรบ้าง print แรก ก็คือต้องการ
ให้ print ชื่อ
ใส่ %s
อย่าลืมว่าเมื่อเราใช้เปอร์เซ็นต์ ตัวอักษร
เราจะไม่พิมพ์เป็นภาษาไทยแล้วนะ เพื่อให้รู้ว่าตรงนี้คือสิ่งที่เราต้องการให้
แล้วไปที่หลังเครื่องหมาย
คำพูดนะคะ อยู่หลัง
: ชื่อ
เปลี่ยนเป็นภาษาไทย
name มาใช้นะคะ แล้วก็พิมพ์คำว่า "name"
จะเป็นตัวเล็กเสมอ ไม่ใช่ตัวใหญ่ เพราะเราผิดไปแล้ว 1 ครั้งนะคะ
เราต้องจำให้ได้
statemat ที่ 1 statemet ที่ 2
print ชื่อค่ะ พิมพ์ค่ะ
เครื่องหมายคำพูดนะ เด็ก ๆ ดูดี ๆ เลื่อนตำแหน่งมานะ แล้วก็
ใส่เปอร์เซ็นต์แล้วก็เรียกพารามิเตอร์
Salary คือ เงินเดือน ขอโทษ ในเครื่องหมายคำพูด
ใส่คำว่า "เงินเดือน" ค่ะ แปลเป็นไทยเลย
เสร็จ
นะคะ เมื่อเราต้องการ
print พิมพ์ print เหมือนเดิม
แล้วบอกไม่ใช่ชื่อสิ
พิมพ์ % แล้วก็ตามด้วย d ตัวเล็กนะคะ
เด็ก ๆ น่าจะพิมพ์ง่ายขึ้น
ก็คือให้แสดง... ให้ print ข้อความเพื่อแสดง
เงินเดือนนะ และตัวที่ 4 ค่ะ
เลขที่เป็นจำนวนเต็มนะคะ ไม่มีทศนิยมนี่ เรา
ก็ใช้ %d
ก็คือ print ภาษามันเองนะคะ
Language มาจากภาษานั่นเองนะคะ
โอเคไหมคะ
เราก็จะได้ Statenert
เพราะฉะนั้น ในเครื่องหมายคำพูด พิมพ์คำว่า "ภาษา"
เอ้ย ตัวที่ 2 ตัวที่ 3 ค่ะ
พูดผิดตัวที่ 3
แล้วก็ตามด้วยเครื่องหมาย Colon
statements ที่ 3
เราต้องการให้แสดงภาษา
เพื่อให้แสดงข้อความนะคะ
ลืม
ว่าภาษา... เดี๋ยวจะงงนะ
ภาษา Python
ค่าพารามิเตอร์ เช่น อันที่ 1 % name
ก็เป็นเปอร์เซ็นต์ salary เปอร์เซ็นต์ที ่
ถ้าเป็นข้อความหรือ string นะคะ
สิ่งที่จะกำหนด
ใส่เครื่องหมาย % แล้วตามด้วย
ชื่อพารามิเตอร์ตัวที่ 3 คือ lang
เห็นไหม รูปแบบมันจะเหมือนกัน พอหลังเครื่องหมายคำพูด
เราต้องใส่อะไรคะ % แล้วตาส
ตัวอย่าง เช็กจากโค้ดที่เขียนนี่ เห็นไหม ทุกตัว
จะระบุว่าเมื่อมีข้อความ
ชื่อว่า salary จำได้นะ อันที่ 3 ก็ทำ
เหมือนกันใส่เครื่องหมาย %
แล้วก็พารามิเตอร์ที่ชื่อว่า lang นะคะ
แล้วในตัวอย่างมันมีบอก
หรือ Language ของเรานั่นเอง l-a-n-g นะคะ
เช็กนะคะ เช็ก
p-r-i-n-t print แล้วก็ตามด้วยเครื่องหมายวงเล็บ
แสดงแล้ว แล้วสิ่งที่จะให้แสดง ก็คือพารามิเตอร์ที่ชื่อว่า name
พารามิเตอร์ที่ขื่อว่า na
เมื่อเราทำการประกาศฟังก์ชันแล้วนะคะ บอกแล้วว่า
ประกาศเสร็จจะต้องมีการทำอะไรคะ เรียกใช้
print ช่องว่างอีก 1 อัน
ดูสิมันจะขึ้นชื่อว่าอะไร
เคอร์เซอร์เราขยับเข้ามาอยู่ตำแหน่ง print ไม่ได้
นะคะ กด Enter ลงไป 2 ครั้ง เสร็จแล้ว
เห็นไหม ให้เคอร์เซอร์มันมาอยู่ตรง
ชิดขอบน่ะนะ แล้วก็
ใช่ไหม callingfunction
แต่ทีนี้ตำแหน่งในการเรียก
ขึ้นมาเลย
show_
กดเครื่องหมาย Backspace หรือ
ลูกศิษย์ย้อนหลัง
แล้วก็ใส่พารามิเตอร์ชื่อลงไปให้
เรียกฟังก์ชัน show_info
นะคะ เราจะเรียกฟังก์ชัน show
วงเล็บเสมอ เห็นไหมคะ อยากให้
show พารามิเตอร์ชื่อว่า name o
show แล้วก็ _ แล้วก็ตามด้วย info
ดูในตัวอย่างที่ 1 นะคะ show_info
ชื่อเรา ชื่อเล่นก็ได้นะคะ ใส่ชื่อเล่นลงไป
เดี๋ยวเผื่อไม่เห็น ขยายให้ดูก่อน อย่าลืม
นะคะพอเรียกใช้ฟังก์ชันมันจะต้องมี
ตอนเรียก show... เรียกฟังก์ชัน show_ info
แสดงเฉพาะพารามิเตอร์ชื่อนะคะ
นะคะ ในเครื่องหมายคำพูด
แสดงชื่อ แล้วก็เงินเดือนนะคะ
ดูนะคะ
อันนี้พารามิเตอร์แรกนี่
ก็คือคำว่า "show" ลืมแก้ภาษษอังกฤษอีกแล้ว
s-h-o-w
ในตัวอย่าง
เรียกฟังก์ชัน show_info
ที่ต้องการให้มันแสดง ก็คือชื่อ
ขี้เกียจสลับแล้วนะ
ทำเหมือนเดิม
พมิ์ชื่อฟังก์ชันที่เราจะเรียก
หรือ Comma นะคะ
แล้วก็ตามด้วย
show_info นะคะ
แล้วตามด้วยค่าพารามิเตอร์
ในฟังก์ชันนี่ เรากำหนดที่ 20,000 แต่ใน
ตอนที่เรามาเรียกนี่ สมมติว่าเงินเดือนเราเพิ่มขึ้น
แล้วต้องการให้มีพารามิเตอร์ตัว
ที่ 2 ก็คือขั้นด้วยลูกน้ำ
ลงไปนะคะ ถ้า
เราต้องการให้มีฟังก์ชัน เอ้ย แสดง
ค่าพารามิเตอร์ในตัวที่ 2 เช่น เงินเดือน เงินเดือนนี่
ในในฟังก์ชันนี่
= Python นี่ เราจะเอา
ภาษาอื่น เช่น ภาษา C นะคะ
หรือเงินเดือนของคนคนนี้มีมากกว่า 20,000 มี 23,000
เป็น 23,000
ก็คือในกรณีที่เรียงฟังก์ชันที่ 1 นี่ โชว์เฉพาะ
พารามิเตอร์เดียว เราก็พิมพ์แค่
พารามิเตอร์ตัวที่ 3 เราก็พิมพ์
ค่าพารามิเตอร์ตัวที่ 3 แต่เราไม่ได้เอา
เรียกฟังก์ชันในอันที่ 2 นี่ แม่อยากให้
มันแสดงทุกพารามิเตอร์เลย แม่ก็เลยใส่เข้าไปครบ
ก็ใส่คำว่า c ลงไป
พร้อมจะดูผลลัพธ์หรือยังคะ
นี่ เห็นไหมคะ ชื่อ เงินเดือน
เห็นไหม แบบที่ 1
ชื่อฟังก์ชันแล้วก็ตามด้วยพารามิเตอร์ที่เราต้องการให้แสดงพอ
แต่ใรกรณีที่
ที่มีอยู่แล้วขึ้นมาด้วย เห็นไหมคะ เพราะ
เมื่อเรียกฟังก์ชันนี้ปุ๊บ สิ่งที่มันจะแสดงมีอะไรบ้าง ชื่อ
3 อัน เห็นไหมคะ เดี๋ยวเล่นให้ดูนะคะ ว่าผลลัพธ์
ออกมาจะเป็นยังไง
มันจะเว้นให้ 1 บรรทัด เด็ก ๆ ดู
พออันที่ 2 มามันเว้นก่อนบรรทัดหนึ่ง
แบบที่ 1 ตอนเรียกนี่
ให้แสดงแต่ชื่อ แต่มันก็จะแสดง
พื้นที่สี่เหลี่ยมมันก็ติดกัน เห็นไหมคะ แต่พอ
ตัวอย่างนี้ นี่
มีเงินเดือน แล้วก็มีภาษา เห็นไหม
พอใส่ print แล้ววงเล็บ
ิสิ่งที่มันแสดงมีชื่อเหมือนกัน มีเงินเดือนเหมือนกัน ภาษา
แสดง 3 อย่างเห็นไหมคะ นั่นก็คือฟังก์ชัน
เด็ก ๆ ไปดูความแตกต่างกับอันแรก ที่ไม่มีเว้นบรรทัด
พอเราสั่ง print Hello
นะคะ แต่มันจะแสดงตาม
อะไรเช่น เหมือนตัวแรก แสดงเฉพาะชื่อแรก
มันมี print ในวงเล็บ
เห็นไหมขั้นมาก 1 อัน
เห็นไหมคะ แต่พออันที่ 2 show_info อันที่ 2
แม่ไปเปลี่ยนไป แม่ไปเปลี่ยนว่า
ีที่ชื่อว่า show_info นี่ มันจะแสดงข้อมูลของชื่อ
ของเงินเดือนแล้วก็ของภาษาขึ้นมาทุกครั้ว
ก็เลยเปลี่ยนเป็น 23,000 ภาษาของเขา ก็เปลี่ยนเป็นภาษา C เห็นไหม
แต่มันจะรู้ว่าพารามิเตอร์ตัวที่ 2 นี่
เพราะฉะนั้น เงินเดือนกับภาษานี่มันจะไปแสดงตามค่าที่เรา
ตั้งไว้ในครั้งแรก
มันก็ไปแสดงที่คำว่า "ภาษา" เห็นไหมคะ นี่ก็เป็น
ใช้งานฟังก์ชันที่มีการ
คนนี้คนใหม่ไม่ใช่คนเดิม นิวคนละนิว
เพราะฉะนั้นเงินเดือนคนนี้
ดูเอาแล้วกัน ว่า
แบบไหนใช้งานง่ายกว่าให้ศึกษา
คือ เงินเดือน มันก็จะไปแสดงที่ตำแหน่งเงินเดือน เห็นไหม
พารามิเตอร์ตัวที่ 3
นะคะ เห็นไหมคะ เรา
กำหนดค่า Argument
กำหนดค่า ค่า Argument ไว้แล้ว
นะคะ ค่าเริ่มต้นไว้แล้วนะคะ
Keyword Argument ยังเกี่ยวกับ Argument อีก มันคืออะไรกัน
keyword ชื่อก็บอกอยู่แล้ว
ให้มองเห็นความแตกต่างนะคะ
แล้วก็มาสู่หัวข้อสึดท้ายของเรา
เขาบอกว่าใช้ชื่อของ
พารามิเตอร์ในการส่ง Argument
ไปได้แล้วนะคะ ต่อมา เรื่องต่อมา
ของเราเรื่องสุดท้าย
เราจะต้องไปกำหนดค่าให้พารามิเตอร์ของเราก่อน ตัวแรกนะคะ
ดูตัวอย่างตัวนี้ เห็นไหมคะ
คือ คำสำคัญนะคะ มันจะเป็นฟังก์ชัน
ที่มีรูปแบบ
มันจะคล้ายกับอะไร คล้ายกับเมื่อกี้นี้ แต่มีข้อแตกต่าง
คือตรงไหน Keyword
โดยพารามิเตอร์นั้นต้องมีการกำหนด
Default Argument ก่อน
สังเกต สังเกตที่อะไรเด็ก ๆ นี่ เห็นไหม
Color น่ะค่ะ
ที่เป็นรหัส เขาเรียกว่าเป็นรหัสหรือเป็นคีย์น่ะค่ะ
เช่น fff นี่ น่าจะเป็นสีขาว
มันจะไม่ใช่ค่าตัว ที่เป็นแบบข้อความ หรือ
เป็นตัวเลข
ค่าสี คือ ไปเรียก
ใช้ค่าสี
Argument ที่เป็นลักษณะ Keyword นะคะ
ไม่เป็นไร ถ้าอยากรู้มันคืออะไร
หรือไม่ได้เติมสีนี่ล่ะ ถ้าจำไม่ผิดนะ ให้นึกถึงนะ
นี่คือ
ดูนะคะ ค่าสีใน... ในคอมพิวเตอร์
ดูนะคะ ค่าสี ค่าสี
เหมือนปกตินะ ไอ้ตัวนี้ คือ สิ่งที่เรียกว่า "Keyword"
นึกออกนะ Keyword Argument
นี่ เห็นไหม
ไม่สลับอีกแล้ว
เดี๋ยวจะลองให้ดูนะคะเด็ก ๆ
นี่คือคีย์เวิร์ดของค่าสีในคอมพิวเตอร์ โดยปกตินี่
เวลาถ้าเราเขียนโค้ดนี่
ในคอมพิวเตอร์นี่มันมีหลายแบบ
แล้วก็... ค่า
สี 3 ฐาน 16 มันจะไม่รับ มันจะรับค่าสี
ไม่ต้องการอะไรแบบนี้
เด็ก ๆ ดูนคะ
ก็คือมันต้องมาอ่านค่าของตัวนี้ก่อน แล้วมา
แสดงให้เห็นสีที่เราต้องการจะรู้ เดี๋ยว
โปรแกรมมันจะรับค่าสีที่เป็นค่าสี
ฐาน 16 นะคะ RGB
อยากรู้ว่าเป็นสีอะไร เดี๋ยวเปิด paint ให้ดูนะคะ โปรแกรม paint
จะเห็นชัดกว่า
ตัว 0000 ff นี่ เหมือนตัวอย่างนี่ ตัวนี้
คือเป็น Keyword Argument
ทำให้ดูนะคะ ตัวอย่างนี้ เดี๋ยวนะ
ไอ้ 00 สีอะไร
ไม่ใช่ paint สิ อะไรนะ Microsoft Word ก็เห็นแล้ว
เดี๋ยวนะคะ
โปรแกรม Paint นะ
เดี๋ยวไอ้นี่ไม่เห็นสิ
ตรงนี้จะเป็นค่าสี มันจะมีแบบ
มาตรฐานกับกำหนดเองนี่
เปิดให้ดูว่าเราจะรู้ได้อย่างไรว่าค่าสีนี้สีอะไร
เปิดใน Word ให้ดูนะคะ
ไม่ใช่สิ อย่างนั้นเปิดให้ดู
ตารางค่าสีเลยแล้วกันนะคะ
ดูสีนะ เด็ก ๆ ดูที่สีนะคะ
นี่เห็นไหม
ดูนะคะ ตารางค่าสีจะเป็นอย่างนี้
ไอ้ตัวนี้ก็ไม่ขึ้นแบบนี้
ชักงงเอง ตารางค่าสี
ลักษณะนี้นะ อันนี้จะเห็นชัดนะคะ ว่าถ้า
สีชมพูเข้มขนาดนี้
อันไหนที่จะเห็นชัด
มันก็ขึ้นอยู่ข้างในนี่
ตัวเลขที่แสดงค่าสีมันน่ะ
อย่างนี้นะคะ สมมติสีชมพู
นี่เห็นไหมตัวเลขสีมันก็จะเปลี่ยนไป
ไม่โชว์แล้วน่ะ เดี๋ยวเทสต์ให้ดูเลยนะคะ
ค่าสีจะเป็นตัวนี้ อย่างนี้นะคะ
ตัวนี้ขึ้นไหม
เอาแค่นี้พอ
ปุ๊บ print color ขอก๊อปก่อน
ถ้าอยากรู้ว่าสีไหนเป็นสีอะไร อย่างเล็ก
ไม่เอาน่ะ
เราไหมนี่
ขอเพิ่มโค้ดให้ จะทำโค้ด
แค่สร้างสีตัวเดียวเลย
ไม่วางให้นะคะ ไม่เป็นอะไร
ขี้เกียจน่ะ ขี้เกียจพิมพ์
copy ให้
อันนี้เป็นตัวอย่างให้เห็นว่า Key
Argument def ฟังก์ชันนี้
c-r-e-a-t-e create color
สมมติ สมมตินะคะ สร้างฟังก์ชัน
เดี๋ยวสร้างให้ดูเด็ก ๆ ไม่ต้อวง
ใส่พารามิเตอร์ ชื่อ color นะคะ โดย
มีค่าเท่ากับ
จะใช้ในการสร้างสีนั่นเองนะคะ
โดย
กำหนด Default Argument ที่
ตัวที่บอกว่า f นี่ มันเป็นคีย์เวิร์ดของ
ค่าสีที่บอก เพราะฉะนั้น พอเรา
1, 2, 3, 4,
5, 6 6 นะ
ขอโทษที มือไวจริง ๆ เลย
เครื่องหมาย # F1 F2 F3 F4
f5
เราจะ
ให้มัน print สีนั้นออกมาให้ดูนะคะ
สร้างฟังก์ชันนี้ มันจะแสดงอะไรออกมา
ดูนะคะ ทำไมเผลอไปลบ
ดูนะคะ เห็นไหม นี่
4
=
print color
print อะไร ต้องการให้ print
ขอเพิ่มพารามิเตอร์อีกตัวหนึ่ง
่
ใส่สีนี้อะไรจะเกิดขึ้น อันนี้ประกาศตัวแปรจะเสร็จแล้ว จะเรียกใช้
มันนะคะ เรียกใช้
เราก็คลิกเลือก แล้วตามด้วย id ลำดับ
ที่ 1 นะคะ
คือ id นะคะ id คือ ลำดับที่นั่นเอง
เพื่อให้เห็นว่าอันที่ 1
ขอลอง print ก่อน
Create color พิมพ์ชื่อฟังก์ชัน
a-t-e
เหมือนเดิมนะคะ
แล้วก็ % เหมือนเดิม
%d นะคะ ตัวเลข เป็นตัวเลข
แล้วก็ตามด้วย
ลำดับที่แล้วก็ตามด้วย :
ใช้ colon แทน
พิมพ์อะไรผิดนี่ p-r-
i
% ลำดับที่เป็น % อะไรนะ
% แล้วก็ค่าพารามิเตอร์ ก็คือ id
p-r-i-n-t print
syntax error ผิดตรงไหนนี่
อ๋อ
แม่พิมพ์อะไรผิด
p-r-i-n-t
เดี๋ยว Run ให้ดูเลยนะคะ
ลบแล้ว print ใหม่ p-
i-n-t
ตำแหน่ง เดี๋ยวนะ Enter เข้าไป เอาใหม่สิ
+
print เอาใหม่
ลบก็ได้
print
Syntax Error Invalid
เดี๋ยวนะ 1
เขาก็ไม่ได้พิมพ์ผิดนี่
ทำไมมันขึ้น Error ล่ะ
ผิดได้อย่างไรล่ะ
เดี๋ยวนะ ขอ
ขยายก่อนนะ
1 2 3 4 5 6
1, 2, 3, 4,
ก็ตรง
อะไรนะ
ผิดตรงไหนนี่
ลืมอะไร ไม่ได้ลืมนี่
ทำไม Syntax นี้ Error ล่ะ
เอาอีกแล้ว
Syntax Error Print
มันบอกว่า print ไม่ได้น่ะ
print บรรทัดที่ 3 ไม่ได้ colors หรือ
ถ้าลบ
จะขึ้น Error อีกไหม
ไม่รู้จัก
มันจะ Error ได้ยังไงน่ะ
รันผ่าน รันไม่ผ่าน
อ๋อ รู้แล้ว
ผิดตรงไหน
อะไร
ตรงนิดเดียว มองไม่เห็น
ลืมใส่เครื่องหมายคำพูดตรงคาบ
ผิดตรงไหนหรือเปล่านี่
print คำสัง Prit
นะคะ เดี๋ยวจะขอลองดู
โอเคนะคะ
รู้แล้ว
ของ color นะคะ
มันก็เลยคำสั่ง print สี
อันนี้ถูกแล้วนะคะ
คิคือ fff ขึ้นมาอย่างนี้นะคะ
ก็คือจะแสดงเป็น
นี่
อยากโกรธโปรแกรมดีหรือไม่ก็ไม่รู้
ผลลัพธ์ก็จะออกอย่างนี้ คือ พิมพ์ลำดับที่ 1 เสร็จ
มันก็จะ print สี่ที่มีค่า
สาเหตุ ก็คือนี่มันมี
เครื่องหมายคำพูดนี่ แต่ไม่ได้ใส่ให้มันนี่นะคะ
Argument ที่เป็น Keyword นั่นเองนะคะ
เหมือนกันนั้นล่ะค่ะ default
ดี ๆ แค่นั้นเอง ว่าจะให้มันเป็น
พอเปลี่ยนฟอนต์น่ะ มันก็มาจัด
ตัวนี้ตัวเล็กตัวใหญ่ดูยากมาก
ก็ต้องมาใช้รูปแบบนี้นะคะ
เขาบอก
นะคะ
ก็คือการกำหนดค่า Argument
ข้างหน้าตัวนี้
พอ Run แล้วถึงจะผ่าน
Default ที่เป็นลักษณะ... Argument ที่ให้มันแสดง
มันเป็นลักษณะไหนถ้าเป็น
ก็คือแสดงลักษณะที่เป็นคีย์เวิร์ดแบบนี้ออกมา
สงสัย
เขาเป็น Keyword
นี่มันต้องใส่เครื่องหมายที่เป็นคำพูด
ไอ้ค่าที่เราจะใส่เข้าไปนี่ล่ะค่ะ เพราะตัวนี้ ลักษณะ
คือมันเป็นค่าของเขาเรียกว่าอะไรนะ
ถึงจะขึ้นนะคะ
ขึ้นค่าให้
รหัสสี ซึ่งความจริง ก็คือถ้าเราใส่สีแดง
สีชมพูอะไรอย่างนี้ แต่อย่าลืมว่าสีในคอมพิวเตอร์น่ะ
ตรงไหนหรือเปล่าคะเด็ก ๆ ความแตกต่าง แทบไม่แตกต่าง
ว่าไม่แตกต่างกัน มันต่างกันตรงค่า
มันก็จะเป็น #ec407a
เปลี่ยนไปตามความเข้มความอะไรอย่างนี้ด้วยนะคะ
เขาเรียกว่า "
เป็น code สีนะ
นั่นก็คือเป็นคีย์เวิร์ดหรือคำสำคัญ
คือคอมพิวเตอร์น่ะจะรู้นะ คอมพิวเตอร์
มันแยกเฉดอีก เหมือน
อย่างนี้ ชมพูเข้ม
ในฟังก์ชันนะคะ คือ ที่เราจะทำจริง ๆ นะ
มันก็จะมีแบบที่ 1 น่ะ
เหมือนสีฟ้านี่ ค่าเขาก็จะเปลี่ยนไปตาม
ที่เห็นนนะคะ
ฟังก์ชัน มีพารามิเตอร์ แล้วในพารามิเตอร์
กำหนด Argument ลงไปเลยอย่างนี้ก็ได้
เขาจะรู้จัก ว่าอย่างนั้นเถอะนะคะ
ถ้าไม่มีใครสงสัย
สำหรับสัปดาห์นี้นะคะ เราก็จะจบ
บทเรียนหลักการเขียนโปรแกรม
กำหนดฟังก์ชันขึ้นมานะคะ อย่างนี้ แล้วก็ตามด้วยพารามิเตอร์
กับแบบที่ 2 ที่มีการกำหนด
เดี๋ยวสอบแล้วจะนัดแนะอีกทีหนึ่งนะคะเด็ก ๆ
มีใครสงสัยไหม ถามได้
ได้ทั้ง 2 แบบ แล้วแต่จะเลือกใช้งาน แล้วแต่วัตถุประสงค์
การที่จะสร้างฟังก์ชัน
เพราะอย่าลืมว่าแล็บไม่ได้แต่เราใช้คนเดียวนะ
เมื่อเลิกใช้เราต้องออกจากระบบของเราทุกครั้งนะคะ
ของเราในเทอมนี้เพียงเท่านี้นะคะ
สัปดาห์หน้าจะให้เบรก
ถ้าไม่มีจะปล่อยแล้วนะคะ
อย่าลืมออกจากระบบทุกครั้งด้วย
มันชอบมาเปลี่ยนฟอนต์ให้
เครื่องที่มี
ขอบคุณพี่ล่ามค่ะ สำหรับการเรียนในวันนี้ขอบคุณค่ะ
-
(ล่าม) ฮัลโหลครับ
(อาจารย์สุธิรา) สวัสดีค่ะ พี่ล่ามไม่ได้ยินเรานะ
นะคะ
สำหรับวันนี้นะคะ ในสัปดาห์นี้จะเป็น
ใน Python
เราจะต้องมาเรียนเบื้องต้นนี่ ก็คือต้องมารู้จัก
ฝั่งล่ามไหมครับผม
(อาจารย์สุธิรา) ได้ยินค่ะ (ล่าม) โอเคครับ
นะคะ หัวข้อที่
เราจะเรียนในสัปาดาห์นี้นะคะ จะเป็น
(ล่าม) ได้ยินครับ ได้ยินครับ
(อาจารย์สุธิรา) ได้ยินไหม ได้ยินนะคะ โอเค นึกว่าไม่ได้ยิน
วันนี้เราจะพูดถึงการ
นะคะ การเรียกใช้งาน
เรื่องเกี่ยวกับ
ฟังก์ชันนะ
นะคะ อ้าวทำไมหน้าจอไม่ขึ้น
สิ่งที่เรียกว่า Function ก่อนนะคะ
โอเคนะคะ ก่อนอื่น
หัวข้อสุดท้ายของปีนี้
เทอมนี้นะคะ ภาคเรียนนี้ ก็คือฟังก์ชัน
คือ ถ้าพูดถึงโดยทั่วไปนะคะ
แล้วก็พูดถึง
Default Argument Values แล้วก็ Keyword Argument
สั่งพิเศษ
ีที่ให้ทำงานเฉพาะสิ่งใดสิ่งหนึ่งนะคะ
อีกแล้ว...
ในส่วนของภาษา python
ฟังก์ชันจะเป็นโค้ด หรือโปรแกรมที่เรา
ก่อนจะรู้วิธีการสร้าง
การเลือกใช้งานนี่ เราก็ต้องรู้ก่อนว่าฟังก์ชันมันคืออะไรนะคะ
เหมือนตั้งขึ้นมาว่าฟังก์ชันนี้จะตั
นะคะ เช่น
ก็คือถ้าเราเป็นโปรแกรมเมอร์หรือ
ในวิธีการเขียนโปรแกรมคอมพิวเตอร์นี่ ฟังก์ชันมันจะเป็น
แล้วไปเรียกฟังก์ชันนี้มาเพื่อให้มัน
ทำกาารคำนวณค่านี้ให้อย่างนี้นะคะ นั่นคือจุดประสงค์
ซึ่งแต่เดิมนี่ฟังก์ชันมันจะเป็น
ที่เขาพัฒนาไว้แล้วก็มี แต่ใน Python นะคะ
บอกแล้วว่าในสัปดาห์นี้เราจะสร้าง
ขึ้นมาใช้งานเองนะคะ แล้วเมื่อสร้างเสร็จแล้วนี่
สร้างขึ้นได้เองนะคะ
เพื่อเอาไปใช้กับ...
มาใช้โดยวิธีการใด
หรือเรียกใช้อย่างไรนะคะ แล้วก็จะพูดถึง Default Argument
เหมือนบางครั้งนี่ การคำนวณบางอย่าง
ไม่จำเป็นต้องไปเขียนโค้ดใหม่ทุกครั้ง เราก็เลยสร้างฟังก์ชันไว้เลย
กระบวนการที่เราจะต้องทำ
ก็คือเมื่อเราจะทำฟังกชันขึ้นมา
จะนำไปใช้ในสิ่งใดสิ่งหนึ่งนะคะ
เป็นการเฉพาะ โดยใน
ใน python
เราสามารถสร้างขึ้นเองได้นะคะ โดย
จะต้องรู้ว่า
มันจะต้องเรียกฟังก์ชันที่เราใช้งานนี่จะถูกเรียก
ที่ที่บอกแล้วว่ามันสามารถ
ทำงานสิ่งใดสิ่งหนึ่งได้
ด้วยว่ามันคืออะไรแล้วก็ Keyword Argument ด้วย
ว่ามันคืออะไรนะคะ ทีนี้ก็จะเริ่มเข้าสู่
ใช้ code นี้ซ้ำได้
ถ้าจะทำฟังก์ชันมาใช้งาน มันควรเป็น
เราจะสร้างมันอย่างไรนะคะ
การสร้างฟังก์ชันใน Python นะคะ
เราจะหาค่า vad นี่
คือ ถ้ามาเขียนโค้ด เราต้องมานั่งเขียนว่า Vat เกิดจากการ
วิธีการนี้นะคะ จะเป็น
ให้นึกถึงว่าเราจะเป็นคนเขียนโค้ด
การที่เอาราคาสินค้ามาคูณกับ
ปริมาณที่ 7 เปอร์เซ็นต์เท่ากับเท่าไหร่ แล้วจะทำอย่างไร
แล้วเอาไปเรียกใช้ซ้ำได้อีกนะคะ จะเรียกว่า
"การนำโค้ดนี้กลับมาใช้" นี้ว่า "Code Reuse"
นะคะ แล้วพอครั้งหน้าจะใช้ก็
เอาไปใช้ได้ หรืออย่างอื่น หรือคนอื่นจะเอาไปใช้ได้
ตัวที่เหมือน
สามารถเรียกใช้ได้บ่อย ๆ เช่น สมมตินะคะ
ขั้นตอนในการสร้างนะคะ
ก็คือมันจะมีรูปแบบ เราจะต้องเขียนโค้ด
ที่เอา
7 เปอร์เซ็นต์น่ะค่ะ Vat ก็คือ 7 เปอร์เซ็นต์ใช่ไหมคะ
de
นั่นก็คือการประกาศตัวแปรนะคะ
เราจะให้รู้ว่าตัวนี้เป็นค่า Vat เราก็อาจจะ
สร้างฟังก์ชันสำหรับการคิด Vat ขึ้นมาอย่างนี้
แล้วตามด้วย function_name
เมื่อรู้ว่าแต่ต้องรู้ด้วยนะว่า
มีฟังก์ชันนี้อยู่ อย่างนี้นะคะ ทีนี้
ให้เห็นว่าคำว่า def นะคะ
ตัวเล็กเท่านั้นนะคะ ไม่ใช่พิมพ์ด้วยตัวพิมพ์ใหญ่
น่ะค่ะ เขียนโค้ดให้ฟังก์ชันเราโดยตามรูปแบบ
ในที่เห็นนะคะ จะต้องมีคำว่า "def"
เราต้องพิมพ์คำว่า def
เป็นตัวแรกนะคะ แล้วตามด้วย function_name function_name
บอกให้รู้ว่านี่นะ ฉันจะประกาศ
จะประกาศค่า ประกาศฟังก์ชัน ไม่ใช่ประกาศตัวแปร พูดผิด
ให้นึกถึงฟังก์ชันเนม
ตั้งชื่อให้ตัวแปร แต่อันนี้เป็นการตั้งชื่อ
เราต้องพิมพ์ d-e-f พิมพ์ด้วย
ตัวเล็กเสมอ ถึงได้ทำเป็นสีแดง
ใส่ชื่อฟังก์ชันเราต้องต้องพิมพ์วงเล็บ
เสมอนะคะ แต่ถ้าเราพิมพ์ใน Colab ตัววงเล็บนี้จะ
นึกออกนะนะคะ
ก็คือทุกครั้งที่พอจะมีการสร้างฟังก์ชัน
พารามิเตอร์
ถ้าเป็นเขียนโค้ดปกติ มันก็จะหมายถึงตัวแปร
นั่นก็คือชื่อ ชื่อ
ของฟังก์ชันที่เราจะไว้เรียกใช้ในครั้งต่อไป เราจะเป็นคนตั้งเอง
อะไรล่ะ เขาเรียก
นี่ เขาบอกว่าพารามิเตอร์ของฟังก์ชันนี่
ฟังก์ชันนี้คือฟังก์ชันอะไรนะคะ เสร็จ
แล้วก็จะมีวงเล็บ พอใส่คำว่า "def" แล้วก็
พารามิเตอร์ตัวนั้นก็จะเป็นตัวเก็บให้เรา
สมมตินะคะ สมมติเราต้องการตำนวณหาค่า
ขึ้นมานะคะ แล้วส่วนข้างในนี่
นะคะ เขาบอกว่ามันเป็นการกำหนดค่า Paramiter
ค่าของรัศมีวงกลม
หรือมีค่าของอะไรนะ
นะคะ แต่ในฟังก์ชันนี่เราจะ
เรียกว่า "พารามิเตอร์" เพื่อไว้สำหรับ
นี้นะคะ เสร็จแล้ว
เมื่อพิมพ์ function_name ใส่ค่าพารามิเตอร์
มีจำนวนเท่าไรก็ได้ ก็คือในฟังก์ชันนี้
เราจะมีการเก็บค่าของอะไรบ้าง
สังเกตนะคะ เมื่อใดที่
ตัวนั้นจะต้องปิดด้วยเสมอ แล้วขึ้นบรรทัด
พื้นที่
วงกลมอย่างนี้นะคะ ค่าพารามิเตอร์ที่จะเก็บก็อาจจะมี
แล้วเด็ก ๆ สังเกต
ดูนะคะ ว่าในการประกาศฟังก์ชันตัวที่ 1
เส้นรอบวงอะไรอย่างนี้เข้ามานะคะ นั่นก็คือ
ค่าพารามิเตอร์ที่เราจะไว้เก็บข้อมูลในฟังก์ชัน
คือการคืนส่งค่าคืนกลับ
ซึ่งฟังก์ชันที่เราเขียน อาจจะ
อะไรเสร็จ เราจะปิดคำสั่ง
การประกาศฟังก์ชันด้วยโคลอนเสมอนะคะ
รูปแบบนี้ให้เห็นทั้ง 2 แบบ
เป็นแบบที่ไม่มีการ return ค่า
ใหม่มันจะเข้าสู่ย่อหน้าใหม่
ตัว statements ในที่นี้หมายถึงคำสั่งอื่น ๆ นะคะ
เราต้องพิมพ์คำว่า return ด้วย
ตามด้วยค่าที่เราต้องการให้ส่งกลับ เช่น เดี๋ยวดู
นะคะ กับตัวที่ 2 ตัวที่ 2
จะมีคำว่า return value return ก็
ค่าที่ส่งกลับนั้นจะเรียกว่า
นะคะ
เขียนแล้วมี return หรือ
ไม่มีก็ได้นะคะ แต่ที่เขียนให้ดูเป็นตัวอย่างนี่ ให้เห็น
ตัวแปรแลลไม่มีการ return
ไม่มีคำสั่ง return เพื่อคืนค่านี่ ใน
แต่แบบที่ 2 นี่มี มีการส่งคืน
ค่ากลับ ก็เลยจะมีคำว่า "return value" ก็คือ
hello()
def ก็คือ definition
ในตัวอย่างจะเห็นชัดนะคะ เดี๋ยวยกตัวอย่าง
แล้วจะมองภาพไม่ออก ซึ่งเขาบอกว่า
คือ def
แล้วก็ตามด้วย function_name ซึ่งในที่นี้ตั้งชื่อว่า
ทีนี้เรามาดูตัวอย่างแรกก่อน
เพื่อจะให้เห็นว่าถ้าเราต้องการประกาศ
นะคะ แล้วทีนี้
พอเวลาเรียกใช้ฟังก์ชันนี้นะคะ มันจะสั้น
ตัวอย่างนี้เราจะประกาศตัวแปร
ชื่อ เห็นไหมคะ ตรง def แล้วตามด้วย
แล้วตามด้วย พารามิเตอร์หรือ
ที่เราไว้เก็บค่า ก็คือ name นะคะ เสร็จแล้ว ตาม
ก็คือคำสั่งเพื่อใช้
และติดประกาศตัวแปร ประกาศฟังก์ชัน ขอโทษทีนะคะ
นะคะ แสดงคำทักทาย
ชื่อที่เรารับค่าเข้าไปนี่ หรือพารามิเตอร์ที่เรา
hello นะคะ ฟังก์ชัน hello ก็คือ
ฟังก์ชันที่เราต้องใช้เพื่อแสดงคำทักทายออกมานั่นเอง
ไปที่ web browser
แล้วเปิดเหมือนเดิมนะคะ พิมพ์คำว่า "Colab" น่ะ
นึกออกนะ การเขียนโค้ดมันจะสั้น
กว่าที่เราเคยทำ
แล้วกด Enter เลย
เพราะสังเกตว่าเว็บไหนที่เราเปิดมันจะ
ด้วย statement ตามด้วยข้อความหรือคำสั่ง
หรือโค้ดอะไรก็แล้วแต่นะคะ ซึ่งในทีนี้เราต้องการให้แสดง
ที่เราใช้งานนะ แล้วก็คลิก
ส่งเข้าไป ก่อนอื่น เด็ก ๆ
เปิด Colab หรือยังคะ เปิด Colab ด้วย
run มันไม่ได้นะคะ เด็ก ๆ อย่าลืม
ลงชื่อเข้าสู่ระบบด้วย Login เข้าไปด้วย
c-o ต้องบอกว่า co สิ
Colab l-a-b นะคะ พิมพ์ l-a-b
ของเราให้เรียบร้อยด้วย
อัตโนมัติเด็ก ๆ กด Enter ได้เลนย
มันก็จะเข้ามาหน้า
ไปที่เขียน code เหมือนเดิมนะคะ เด็ก ๆ
กดที่คำว่า "code" นะคะ ในบรรทัด
Code นะคะ ลืมไป
อย่าลืมทำอะไรก่อน เข้าสู่ระบบนะ ไม่อย่างนั้นเราจะ
de แล้วกฌ f
ใช่ไหมคะ พิมพ์ด้วยตัวพิมพ์เล็กเสมอนะคะ
นะคะ
ตัวใหญ่นี่ถือว่าไม่ถูกต้องนะคะ
def นะคะ แล้วก็กด
โอเคนะคะ เสร็จแล้วเราก็เริ่ม
แล้วตามด้วชื่อของฟังก์ชัน
ชื่อของฟังก์ชัน ในตัวอย่างเรา ชื่อว่า Hello
แรกของเรานะคะ เราก็เริ่ม
ประกาศฟังก์ชัน โดยพิมพ์คำว่าอะไรคะ
นะคะ ไม่ใช่ตัวพิมพ์ใหญ่นะคะ
ดูดี ๆ นะคะ เพราะฉะนั้น
ไม่ใช่พิมพ์ใหญ่แบบนี้นะ ไม่ใช่พิมพ์ D-e-f
Def แบบนี้ ตัวใหญ่นี่ถือว่าไม่ถูกต้องนะคะ
e-
l-l-o แล้วก็ใส่วงเล็บเข้าไป
Space bar เพื่อวรรค 1 ครั้งนะคะ
บอกแล้วว่าวิธีการประกาศฟังก์ชัน ก็คือพิมพ์คำว่า "def"
name นะคะ ตัวพิมพ์เล็ก
เพราะมันเป็นตัวแปรชื่อว่า name เมื่อ
ทีนี้มาดูชื่อ ชื่อของฟังก์ชันนี่
ก็ต้องใช้ตัวพิมพ์เล็กเหมือนกัน
แล้วกด Enter 1 ครั้ง
ใช้วิธีกด Enter นะ ไม่ใช่เลื่อนเมาส์
พิมพ์ตัว h
ด้วยตัวพิมพ์เล็กนะคะ h-
Stagement
หรือคำสั่งต่อไปที่เราจะใช้ ก็คือคำสั่งแสดง
แล้วก็ตามด้วย
พารามิเตอร์ ในวงเล็บพารามิเตอร์ของเรา ก็คือคำว่า "
n-t
print แล้วก็ตามด้วยวงเล็บเหมือนเดิม print อะไร
เสร็จฟังก์ชันใช่ไหม
เสร็จคำสั่งฟังก์ชันต้องปิดด้วยเครื่องหมายโคลอนเสมอ
เดี๋ยว
อ๋อ ขอโทษ ไม่ได้สลับหน้า
ลงไป สังเกตบอกแล้วพอกด Enter นี่
ตำแหน่งของเคอร์เซอร์มันจะ Tab เข้าไปนะ
เราก็ว่าอยู่แต่เด็ก
พิมพ์ตามใน PowerPoint แต่อยากให้เห็นใน Colab
ผลนะคะ ก็คือคำสั่ง print
p-r-i
นั่นน่ะสิ
เดี๋ยวเลื่อนไอ้นี่เอาก็ได้นะ
สิ่งที่อยู่ในวงเล็บอย่าลืมนะคะ เมื่อใดที่
บอกให้พิมพ์วงเล็บนี่ สังเกตมันจะมี () ขึ้นมานะ
ไอ้ตัวข้อความด้วย
เดี๋ยวสิ้นสุดการนำเสนอก่อน
มันไม่สลับหน้า
ตลอดเลย
โอเคไหม
เดี๋ยวนะ กำลัง
เพราะว่าเมาส์หาย
เมาส์จ๋า เมาส์จ๋า
โอเคน่า
จะได้เห็น 2 อย่างนะ เห็นไหมคะ จะมาที่คำสั่ง print ของเรานะ
โอเคนะคะ นะ
ในนี้จะพิมพ์คำว่า "print" นะคะ เดี๋ยวจะโชว์
แป๊บหนึ่ง
ขยับ
เดี๋ยวให้เห็น 2 หน้า
ด้วยกัน ไม่สิ ไม่สิ
ขอ 2 ทำไมได้ 4 นี่
เดี๋ยวนะ เดี๋ยวจะ
หามุม มุมให้เธออยู่
แล้วก็
แล้วในวงเล็บของ print
ลืมทำให้มันขึ้น 2 หน้าคู่กัน เดี๋ยวนะคะ
โอเคไหม
อีกหน่อยหนึ่ง นะคะ
ได้ไหม
ไม่เห็นหน้านี้อีก
แล้วตามด้วย
เห็นไหม ตรงก่อน... ตรงก่อน Hello มี
กระเถิบ
แล้วค่อยพิมพ์ Hello ด้วยตัวใหญ่
แล้วก็ตามด้วย
ไม่เห็นในสไลด์อีกสิ
ส่วนแบ่งทางการตลาดเยอะ
แล้วหลังเครื่องหมายคำพูด
เด็ก ๆ ต้องเลื่อนไอ้ตัวนี้ไปหลังเครื่องหมายคำพูดนะ
วงเล็บในวงเล็บของคำว่า "print"
เราจะ print คำว่า "hello" นะคะ
name ตัวเล็กนะ ดูดี ๆ นะ เราเรียกใช้ เราสร้าง
เครื่องหมายคำพูดนะดูดี ๆ อาจจะเห็นไม่ชัด
ใส่เครื่องหมายคำพูดนะคะ Single Quote หรือ
นี่คือเสร็จฟังก์ชันนี้แล้ว
ลองเรียกใช้งาน ลองกด Play ก่อน
เครื่องหมาย % %s
นั่นคือ ข้อความนี้เป็น String นะคะ
ที่เรา code
ที่เราเขียนไปนี่มันถูกไหม ถ้าผิดมันจะขึ้น Error ใช่ไหมคะ
พิมพ์ % name
แล้วก็พิมพ์เปอร์เซ็นต์ แล้วตามด้วย
มันก็จะยังหมุนติ้ว ๆ อยู่นะคะ เราก็ต้องรอนะคะ
พารามิเตอร์ด้วย name ตัวเล็กเวลาเรียกใช้ก็ต้องใช้ตัวเล็ก
นะคะ
แสดงว่าไม่มีอะไรผิดนะคะ
ไม่ทำอะไรนะ เพราะฟังก์ชันสร้างขึ้นมา สร้างแล้ว
ขอโทษ เราจะได้รู้นะคะ
การกดตัวนี้นะ เพื่อจะได้เช็กว่า
นะคะ ตอนนี้คือสร้าง
เพื่อให้คอมพิวเตอร์มันจำ จำไว้ว่าตอนนี้เราสร้าง
ครั้งแรกเวลาโค้ดมันก็จะช้านิดหนึ่ง
เพื่อจะให้ตรวจสอบว่า
โค้ดที่เราเขียนไปมันถูกหรือเปล่า ถ้าผิดมันจะแสดง Error
ของใครขึ้น Error ยกมือ
สิ่งที่ต้องเช็ก ก็คือ 1. คำสั่ง
แล้วอย่าลืมว่ามันจะต้องมีการเรียกใช้ นึกออกนะ
ต้องสร้าง สร้างเพื่อให้มันไปโดนเรียกก่อน มันถึงจะทำงาน
ก็คือชื่อฟังก์ชัน
ใช้ตัวเล็ก และตัวที่ 3 พารามิเตอร์ พามิเตอร์จะ
ฟังก์ชันชื่อว่า hello แล้วนะคะ
ที่ให้กด Run นี่
การประกาศฟังก์ชันด้วย
โคลอนเสมอนะคะ
นะ ถ้าเขียนไม่ผิดมันก็ไม่แสดงใช่ไหมคะ
นี่ลอง Run แล้วนะคะ Error ไม่ขึ้นนะคะ
ประกาศฟังก์ชันที่ 1 ไปแล้ว
มาดูแบบที่ 2 นะคะ ฟังก์ชัน
d-e-f นะคะ definition
การประกาศฟังก์ชัน ตัวที่ 2
สลับไปสลับมา
กันอยู่นี่ล่ะเรา อันนี้ อันนี้แบบไม่มี
มีค่าอยู่ในวงเล็บเสมอ
นะคะ เสร็จแล้วต้องปิด
เราใช้เราสร้างฟังก์ชันนี้
ขึ้นมาเพื้อต้องการให้มันแสดงข้อความ เอา
ทีนี้เมื่อกี้
ตัวนี้
ทำไมหนก่อนไม่เห็นมี หรือเพราะเป็น
ที่มีการ return หรือส่งกลับค่า
เดี๋ยวขยายหน้าไอ้นี่ให้ก่อน
เป็นปัญหาในการใช้งาน
จะได้ใช้ Windows อื่นเสียล่ะมั้ง
return ค่านะ
ในตัวอย่างนี่เราสร้างฟังก์ชันชื่อ hello นะคะ
เราจะประกาศฟังก์ชัน
มีการใช้ return value หรือการคืนค่ากลับ
อีกแล้วอะไรอีกหว่า
สลับจอไม่ได้เลย น่าจะเป็นกับไอ้
โดยมีพารามิเตอร์ 2 ตัว
width แล้วก็ความ... width แล้วก็
ไอ้นี่บ่ะ Windows 11 นี่บ่ มันถึงขึ้น
ไอ้สลับไอ้จอไอ้นี่ทุกทีเลย แล้วก็
กว้างคูณยาว
เพราะฉะนั้น ค่าพารามิเตอร์ที่ไว้ใช้สำหรับเก็บค้า
สลับไอ้จอไอ้นี่
นะคะ มาดูตัวอย่างที่ 2 นะคะ
ว่า width
นั่นเองนะคะ เสร็จแล้วปิดด้วยโคลอน
ในตัวอย่างที่ 2 เป็นการประกาศ
ฟังก์ชันที่ชื่อว่า area()
สำหรับคำนวณ
ความกว้างคูณความยาว ก็คือคำนวณ
height ซึ่ง area ในที่นี้ึ
พื้นที่ สูตรการหาพื้นที่สี่เหลี่ยม ก็คือ
นะคะ ก็คือให้ส่งกลับค่าของ c
ก็คือเมื่อเอาพารามิเตอร์มาคำนวณแล้วนี่ c จะได้เท่าไหร่
ก็คือค่าความยาวกับความกว้าง
นั่นเองนะคะ ก็เลยตั้งชื่อตัวพารามิเตอร์ 2 ตัวนี้
แบบมีการ return ค่า
เพราะฉะนั้น บางคน
Statement ต่อมาสร้างตัวแปร
ชื่อว่า C ตัวแปร C
แล้วมันก็จะไม่ขึ้นไอ้หน้านี้
หาพื้นที่ของสี่เหลี่ยมนั่นเองนะคะ
แล้วทำการ return ค่า c
มันไม่สลับ Extend หรือ
ส่งกลับค่าให้ c นะคะ
นี่คือการประกาศฟังก์ชัน
โอเค ต้องสลับ
คีย์ใน Colab ไปเรียบร้อยแล้วนะคะ
เรามาเริ่มคีย์ของเราด้วยนะคะ
อย่างนั้นก็ต้องมาจัดไอ้นี่ใหม่อีกแล้วนี่
อีกแล้ว มันเป็น
อะไรกับ...
ไม่เห็นตัวหลังอีก เอา
มันไม่ขึ้นหน้าจออีกแล้วน่ะ
ไม่เห็นอีก มัน
2 รอบเชียวหรือนะคะ
เอาไว้ก่อน
แป๊บนึงนะสลับหน้าก่อน
โอเคไหม
ไปไหนแล้ว
เห็นไหม
ที่ 2 ต่อด้วยฟังก์ชันแรกได้เลยนะคะ
เมื่อหลังฟังก์ชันแรกเรากด Enter กดลงไป
น่านักเชียว
ตำแหน่งตรงกับชิดขอบ
แล้วก็เริ่มพิมพ์คำสั่ง definition
Colab
วรรคตามด้วย area
ตัวเล็กนะคะ
นะคะ
เราประกาศฟังก์ชัน
จะต้องมีพารามิเตอร์อยู่ในวงเล็บ
ก็คือพารามิเตอร์ตัวที่ 1 ชื่อว่า width w-
2 อันเลยก็ได้เด็ก ๆ สังเกตตำแหน่งมันจะ
Tab เข้าไปนะ เรากดย้อนคืน 1 ครั้ง
ขั้นพารามิเตอร์
ตัวต่อไป ด้วยเครื่องหมาย
d-e-f เพื่อประกาศใช้คำสั่งฟังก์ชัน
ที่ชื่อว่า... ชื่อฟัง์ชันของเราชื่อว่า area() นะคะ
นะคะ แล้วก็ตามด้วย
ชื่อพารามิเตอร์ตัวที่ 2 นะคะ ก็คือ h
แล้วก็
ตามด้วยเครื่องหมายวงเล็บ เพราะบอกแล้วมีชื่อฟังก์ชัน เสร็จแล้ว
นั้นเองนะคะ มีพารามิเตอร์
สำหรับเก็บความยาวกับความกว้างนะคะ ก็คือ width กับ height
i-d-
t-h นะคะ คั่น
เสมอ
เมื่อเราประกาศฟังก์ชันเสร็จแล้วนะคะ เรา
Comma
นะ คอมมาหรือไอ้ลูกน้ำเรา
อัตโนมัตินะคะ
เสร็จแล้วเราประกาศตัวแปร ชื่อว่า c เพื่อ
-i-
h-e-i-g-h-t height หรือสูง
เพราะสูตรการหาพื้นที่สี่เหลี่ยม
กว้างคูณยาวนะ เพราะฉะนั้น เราอยากรู้พื้นที่สี่เหลี่ยม
ปิดการ
ประกาศฟังก์ชันของเราด้วยเครื่องหมายโคลอน
เมื่อเราพิมพ์นี่ ให้เรา
width w-i-d-t-h เพราะอย่างนี้ทำให้เรา
กด Enter เพื่อไปพิมพ์
Statements ใหม่นะคะ เคอร์เซอร์มันจะ Tab เข้าไป
เครื่องหมาย คูณในที่นี้ก็คือเครื่องหมายดอ
ตัวแปรทางคณิตศาสตร์ของโปรแกรม
ทำการคำนวณค่าพารามิเตอร์ 2 ตัวของเรา
ก็คือเอา width
พารามิเตอร์ตัวที่ 2
h รอสักพัก แล้วหาคำว่า "height" นะคะ
เอากว้างไปคูณกับยาว เพราะฉะนั้น ก็ต้องเอาพารามิเตอร์ width
ตัวนี้เด็ก ๆ ดูนะ
เห็นไหมคะ เจอตัวนี้ปุ๊บ
คลิกเลย เพราะบางคนจะมีปัญหา เมื่อ
พิมพ์พารามิเตอร์หรือตัวแปรที่เราสร้างไว้
ไม่ผิดนะคะ แล้วใส่เครื่องหมายคูณ
Error
เพราะฉะนั้น ตัว Colab นะคะ
คอมพิวเตอร์เครื่องหมายคูณ ก็คือเครื่องหมายดอกจันนะคะ
แล้วตามด้วย
เห็นนะคะ พอเราเห้นเราคลิกเลือกมันได้เลย
นะคะ เมื่อได้
h-e-i-g-h-t
อาจจะพิมพ์ h-e ก็ได้ น่าจะขึ้น
คำสั่งหรือ code ของ
นะคะ แล้วในบรรทัดต่อไป เราจะใช้
ชื่อตัวแปรหรือพารามิเตอร์เริ่มยาวหรือยาก
จะพิมพ์ผิด แล้วพอพิมพ์ผิด พอไป Run โค้ดมันจะเกิด
พิมพ์ด้วยตัวเล็กนะคะ
ค่าที่เราต้องการให้แสดง หรือ...
ที่ดีเลย คือ เมื่อเราพิมพ์
ตัวแรกขึ้นมา ตัวแปรตัวนั้นมันก็จะขึ้นมาให้
ค่าของการที่เราคำนวณพื้นที่
c นั่นเองนะคะ เพราะฉะนั้น return c ตามด้วย c
Statement เพื่อการคำนวณแล้ว
ต่อไปเราจบ
เหมือนเดิมนะคะ
เพื่อเป็นการเช็กโค้ดของเรา ก็คือกดตัว
คำสั่งในการคืนค่าหรือ return value
โดยการพิมพ์คำว่า "return"
ว่า code ที่เราเขียนนี่
ถูกต้องแล้วนะคะ มีใคร
หรืออะไรก็แล้วแต่ ซึ่ง
ค่าที่เราต้องการให้มันแสดงหรือเห็นนี่ ก็คือ
แล้วนี่คือ
การประกาศใช้ฟังก์ชัน หรือการสร้างฟังก์ชัน ทีนี้
ไม่มั่นใจก็คลิก c
ที่มันขึ้นมาอย่างนี้นะคะ
เราต้องไปเรียกใช้งาน
มันถึงจะแสดงไอ้ผลพวกนี้ออกมาได้
Play ที่เป็นรูปเหมือนเป็น
Play Video Play Music อะไรพวกนี้ ให้มันเช็ก
ไม่สลับโหมดแล้วนะ
เดี๋ยวสลับไปสลับมา เราก็ เราก็แก้
ขึ้น Error ไหมคะ
ไม่มีนะคะ แสดงว่าเริ่มมีความชำนาญในการโค้ดแล้ว
ขอย่อให้มันพอดีหน่อย
โอเค
บอกแล้วว่าเมื่อสร้างเสร็จแล้วนี่
ไม่เห็นผลอะไรเลยใช่ไหม พอเรากด Play นี่
โหมดเป็นยังไงนี่
ขึ้นไหม ขึ้นอยู่ โอเค สลับได้
เพราะฉะนั้น เราจะมาดูเนื้อหา
ต่อไปนะคะ ก็คือ...
เมื่อสร้างเสร็จแล้ว
มันต้องเรียกใช้เสียก่อนนะคะ เราถึงจะรู้ว่าฟังก์ชันที่เราสร้าง
ไม่ได้อีก เดี๋ยวเสียเวลาในการแก้โหมด
หน้าจอนะคะ
ก็คือในนี้
พอเราสร้างฟังก์ชันแล้วนะคะ เราต้องเรียกใช้งานมัน วิธีการเรียก
ก็จะเล็กไปอีกใช่ไหมถ้าย่อ แล้วสลับ
และส่ง อาร์กิวเมนต์
อะไร เมื่อกี้มีพารามิเตอร์ มามี Argument อีก
นะคะ เมื่อกี้บอกแล้วว่าถ้าเรา
ทำใน Colab เป็นการสร้างแล้วนะ ต่อมา
ก็เป็นคำ ไม่ใช่คำ
เป็นค่าที่เราส่งเข้าไปในฟังก์ชันนะคะ
มันใช้งานได้จริงไหมนะคะ
การเรียกใช้งานฟังก์ชันนะคะ
ในฟังก์ชันเพื่อรับค่า
เมื่อกี้พารามิเตอร์ที่เรามีตัวที่ 1 ชื่อว่า
ใช้ ก็คือเราจะใช้ชื่อของ
ฟังก์ชัน เห็นไหมคะ
มันรับค่านั่นเองนะคะ
มาดูตัวอย่างวิธีการเรียกใช้ฟังก์ชันนะคะ
Argument กับ Parame
เดี๋ยวมีคำอธิบายนะคะ ว่า Argument
อะไรพิศดาลเลยเพียงแต่เราพิมพ
ชื่อฟังก์ชันนั้น แล้วตามด้วย
ตอนที่เราใช้งานนะคะ
ส่วนพารามิเตอร์น่ะ คือ ตัวแปรที่เรากำหนด
ชื่อเพราะในวงเล็บนี่
ิสิ่งที่เป็นตัวแปรชื่อว่า name นะคะ พารามิเตอร์
name นั่นคือตัวแปรที่เราใช้รับค่า
เพราะฉะนั้น Argument ก็คือชื่อที่เราจะพิมพ์เพื่อให้ตัวแปร
ที่เราจะให้
มันเก็บเลยนะ นะคะ ลองดูนะคะ
มาดูตัวอย่างกันก่อน
การจะเรียกใช้ฟังก์ชันที่เราสร้างขึ้น ไม่ได้มี
หรือมันช้า พอ... พอสลับมา Colab มันจะช้า
เห็นไหมคะ ตามด้วย Argument
ในที่นี้ ก็คือ
น่ะชื่อว่า name แล้วพอเราเรียกใช้นี่
ก็คือเราพิมพ์ชื่อฟังก์ชันนั้น แล้วตามด้วยค่า
นี่คือฟังก์ชันเวลาเรียกใช้
ไม่ได้มีอะไรพิสดารเลยนะคะ ใส่ Hashtag ก่อน
ลองเลย ลองเลย เพื่อให้เห็นภาพ
ใส่เครื่องหมา chap หรือ hahtag
อันนี้คือคอมเมนต์นั่นเองนะคะ เพื่อจะบอกให้รู้ว่า
นิดหนึ่งหรือ ไม่สลับ
อีกแล้วนะ อะไรนะ
แล้วก็ตามด้วยฟังก์ชัน f-u-n เด็ก ๆ ไม่ต้องพิมพ์ ไอ้นี
โอเค เรา
ก็จะต้องสลับกันอย่างนี้นะคะ นี่นะ เราไปประกาศไปแล้วนี่
เพื่อจะให้รู้ว่าตรงนี้เป็นส่วนของ
เราเรียกการใช้ฟังก์ชันนี้ ก็เลย
ฟังก์ชันแรกที่
ตรงนี้เราจะเรียกใช้ฟังก์ชันที่เราสร้างแล้วนะ calling
calling นะคะ calling ก็
ฟังก์ชันแรกของเรา
ชื่อว่า hello ใช่ไหมคะ แล้วตามด้วยเครื่องหมายวงเล็บ
ก็ได้นะคะ
ทีนี้เราไม่อยากใส้ Danny เราใส่ชื่อเราเองไปก็ได้
เครื่องหมายคำพูด
หรือ Double Quote นะคะ name
เราจะเรียกใช้ชื่อ ก็คือเวลาจะเรียกใช้มัน
พิมพ์ชื่อฟังก์ชันนั้นนะคะ พิมพ์ hello เลยนะคะ
นะคะ เห็นไหมคะ มันจะขึ้นมาบอกเลย name
name คืออะไร name ในที่นี้ ในตัวอย่าง ก็คือ Danny นะคะ
สมมติ
เรียกฟังก์ชัน hello ไปแล้ว ฟังก์ชันต่อมา
ชื่อนึกออกนะ เช่น
เนื่องจาก name เป็น string อย่าลืมใส่เ
เราอยากให้มันแสดงค่าพื้นที่
นะคะ ก็เลยใช้คำสั่ง
ใส่ชื่อเราแทน Danny ก็ได้นะคะเด็ก ๆ
ทำให้ดูก่อน
p-r-i-n-t
จะใส่ชื่อเล่นหรือชื่อจริง
ก็ได้ แล้วแต่นะคะ
ตำแหน่งของฟังก์ชันชิดนะคะ
ไม่วรรคนะคะ นี่ ไม่ต้อง Tab เข้าไปนะ
ที่เราจะเรียกใช้นะคะ
ก็คือ area() แต่ area() ที่เรา
print ก่อน แล้วไปเรียกฟังก์ชัน
นั้นไว้ใน print นะคะ ให้ print แสดงนะคะ ดูตัวอย่าง
ด้วยแสดงคำว่า
เป็นข้อความนะคะ เพราะฉะนั้น
ลืมแก้ภาษาขอโทษที
สี่เหลี่ยม
ตัวที่ 2 นะคะ
ใส่เครื่องหมายเท่ากับนะคะ เปลี่ยนภาษา
เราจะใช้คำสั่ง print
ฟังก์ชันนะคะ เพื่อให้แสดงแล้วก็เรียกใช้ฟังก์ชัน
เปอร์เซ็นต์แล้วก็ d
แล้วหลังเครื่องหมายคำพูด
เมื่อเป็นข้อความ พิมพ์เป็นภาษาไทยก็ได้
ไม่ต้องใช้คำว่า "area" ในภาษาอังกฤษ ก็คือพื้นที่
แล้วก็
พิมพ์ฟังก์ชัน area a-
=
e-a นะคะ
แล้วก็วงเล็บ
ก่อน =
%d นะคะ %d เท่ากับ แล้วก็
เอามากกว่านั้นก็ได้นะ
ในตัวอย่างบอกว่าความกว้าง คือ 8 ความสูง คือ 4
ตามด้วย % แล้วเรียกใช้
ฟังก์ชัน area นะคะ ตามด้วยเครื่องหมายเปอร์เซ็นต์
ความสูง 4 นี่ความสูงนี้
เท่าไหร่ ตอนนี้เราพิมพ์คำสั่งหรือโค้ด
r ปุ๊บ ขึ้นหรือยัง
A-r-
จะแสดงผลอย่างไร
Error เด้งขึ้นมา ณบัด Now
ทีนี้ใส่ Argument
ให้ 2 ตัว ก็คือ 8 นะคะ กว้าง 8
เกิดอะไรขึ้น
print
ถ้าพื้นที่ที่มี
ความกว้าง พื้นที่สี่เหลี่ยมที่มีความกว้าง 8
ตัวแปร ตัวแปรผิด เดี๋ยวนะ ค่อย ๆ ไล่นะคะ
เสร็จหมดแล้วนะคะ
เด็ก ๆ ลองกด Play ดูได้เลยนะคะ ถ้าใครพิมพ์เสร็จแล้ว
สังเกตนะคะ เมื่อขึ้น Error
เด็ก ๆ ดู เห็นไหม มันจะชี้ไปที่บรรทัดผิด
บรรทัดที่ 9
เสร็จแล้ว
มันบอกว่าในบรรทัดที่
ไม่อยู่ใน Index
S ตัวใหญ่หรือ s เล็กใช่ไหม ขอโทษที
พอขยายแล้วของตัวเองก็เล็ก
แบบนี้นะ เดี๋ยว
แก้ได้ ๆ
เห็นไหมคะ
พิมพ์ตัวแปรผิดหรือ ฟังก์ชันชื่อฟังก์ชัน
ถูกแล้วนะ hello ถูกต้องนะคะ
แม่ไม่ได้ดู s มันเป็นตัวมหญ่ตาม
คือ ไอ้พวก % d % อะไรนี่
2 % name
value error ค่า error ตรง...
ตัวพิมพ์เล็เกแค่นั้นเอง
พิมพ์ s ผิดใช่ไหมนี่
%s
พอมาไล่ฟังก์ชัน
เมื่อกี้ตรงลืมพล็อต
ให้ดูก่อน เมื่อกี้ตอนแม่พิมพ์ %s
%s' name
พิมพ์เล็กมันไม่ใช่ตัวพิมพ์ใหญ่ แม่ไปพิมพ์ใหญ่
ถ้าเด็ก ๆ ผิดตำแหน่งนี้ แก้แค่ตัว S จากตัวพิมพ์ใหญ่ เป็น
ย้อนกลับไปดู อ๋อ s ฉันพิมพ์ผ
ฉันต้องพิมพ์เป็นตัวเล็กนะคะ พอแม่แก้
การขึ้น Error นะ เดี๋ยวแก้ให้ดูนะคะ
มันก็จะแสดงขึ้นมา เห็นไหม มันก็จะพิมพ์คำว่า...
มันก็จะไปเรียกใช้ ไอ้ตัวนี้
มันจะขึ้นลูกศรชี้ไปที่บรรทัดไหน นั่นหมายความว่า
มันหมายความผิดพลาดที่
ที่จะให้มันแสดงแต่
ตอนที่ทำงานน่ะ มันมาทำงานที่ตัวนี้เห็นไหมคะ
ตรง value error เห็นไหม ค่าที่มัน error ค่ามัน
อยู่ที่คำว่า s อ๋อ
คำว่า "print" ไว้
พอเวลามาเรียกใช้เธอ เราก็เลยมาพิมพ์คำว่า...
จากตัวใหญ่เป็นตัวเล็ก
เรากด Play น่ะ Error มันก็หาย แล้วผลลัพธ์
สามเหลี่ยม 8 x 4 = 32 ถูกต้องนะคะ
มันก็จะส่งค่า c ที่มาคำ
ออกมาเลย ทั้ง ๆ ที่ ตอนเรียกนี่ เราพิมพ์แค่
ฟังก์ชัน แล้วก็ตามด้วยค่า Argument
พื้นที่ สี่เหลี่ยม
ของเรานี่นะคะ มีค่า =
ตัวคำว่า "print" แต่ตรง area นี่
นะคะ ตรงฟังก์ชัน area
แสดงทศนิยมออกมานะคะ
ลองดูอีกสักตัวอย่างหนึ่งไหมคะ
มีแถมตัว r มาจากไหนนี่
สามเหลี่ยม = %d'
เด็ก ๆ ลองนะคะ ทีนี้ให้
ใส่ชื่อเล่นตัวเองลงไป
มาแสดงตรงนี้เห็นไหมคะ
เป็น 32 นะคะ มันก็เลย print คำว่า "
%d นั่นหมายถึง
ให้แสดงเป็นเลขจำนวณเต็มนี่
เห็นไหมคะ มันจะขึ้นมาเป็น
ลอง ลองเรียกใช้
ฟังก์ชัน hello อีกนะคะ
ไม่แน่ใจว่ามันจะไปเรียกใช้ได้อีกไหม
มันจะไปเรียกใช้ได้อีกไหม
เอาแต่ hello อย่างเดียวให้เห็น
ไม่ได้ไปเรียกต่อจากเมื่อกี้
ลองพิมพ์ฟังก์ชัน hello ที่เราสร้างไว้
ใส่ชื่อเล่นเรานะ
ตัวต่อไปอันนี้ไม่มันก็จะ
ทำซ้ำไง เพราะเรายังอยู่ในตัวเดิมนะ
ลองดูสิ มันจะขึ้นอย่างไร ลองดูนะคะ
มีตัวใหม่ใช่ไหม แล้วลองเรียกใหม่
จากโค้ดที่เราเพิ่มเข้ามา ลองเรียกนะคะ
ก่อนหน้า ลืมแก้ภาษาอีกแล้ว
พิมพ์เรียกใช้ฟังก์ชัน
ทีนี้ลองใส่ชื่อเล่น
หลาย ๆ คน ใส่ชื่อเพื่อนลงไปด้วยสัก 3 คน
เพราะบอกแล้วว่า Argument นะคะ
มีกี่คนก็ได้ ลองสิขึ้นไหม
ตัวเดียว แต่เราไปใส่หลายตัวนะคะ มันจะใส่ได้
ตามจำนวนพารามิเตอร์ด้วยนะคะ เพราะฉะนั้น ในกรณีนี้
ให้มันมีหลายคนนะคะ เราต้องไปแก้ที่ฟังก์ชันเรา
แล้วลอง ลองมาใส่ที่ตัวนี้ใหม่
Syntax error เพราะอะไรคะ
เพราะไอ้ตัวนี้มันมีพารามิเตอร์ใ
ถ้าเราจะเพิ่มให้มันมีหลายคน
ถ้าเราจะเพิ่ม
เข้าใจแล้ว
แสดงว่าไม่เรียก อ๋อ
มัน มันข้ามไปสร้างตัวใหม่
Type Error ชนิดไม่ถูกต้องนะคะ เพราะ
ฟังก์ชัน Hello เราน่ะ
เราไปใส่ 3 ก็คือถ้าเราต้องการให้มีหลายตค
ไปเพิ่มตัวนี้นะคะ เพิ่มขึ้น
ไปวิธีแก้ไม่ได้ยากเลยนะคะ
ถ้าจะ... เรามาเปลี่ยนที่ตัวฟังก์ชันหลัก
นี่ไง ๆ มันขึ้นเตือนว่ามาว่า
นี่คือเมื่อ... จำไว้เลยว่าเมื่อ
ตอนจะเรียกใช้แค่พิมพ์ชื่อ
Position ให้แค่ 1 ตำแหน่ง
นะคะ ใน Argument แต่
Argument ลงไปแค่นั
มันชื่อนี้เวลาเราเรียกใช้มันนี่ เราเอามา
เพราะฉะนั้น
มัน... พอมันโดนเรียกใช้นี่มันจะกลายเป็น
Argument แต่ตอนที่มันเป็นฟังก์ชันนี่
เพราะตอนเรีกยใช้ไอ้ตัวนี้มันเรียกแค่
ใช่หรือเปล่าอย่างนี้เป็นต้นนะคะ
เราเอาฟังก์ชันนั้นมาใช้งาน สิ่งที่อยู่ใน
วงเล็บจะกลายเป็น
แล้วในวงเล็บนี่ เราพิมพ์
ค่าของ... เขาเรียกว่า "
นี่ นี่คือส่วนของการสร้าง
ฟังก์ชันและการเรียกใช้ฟังก์ชันนะคะ มาดูหัวข้อ
ทั้งชื่อฟังก์ชันกับวงเล็บ แต่สิ่งที่อยู่ใน
วงเล็บนี่ ก็คือเราใส่เข้าไปได้เลย
เหลืออีก 2 หัวข้อ
เดี๋ยวนะ เดี๋ยวนะ
ตรงในวงเล็บนี่คือ
หรือตัวแปรที่จะไว้รับค่านะคะ แต่พอ
โอเค
รับเข้าไปนั่นเอง
นะคะ
คืออะไร มันเป็นการกำหนด
Default Argument นี่
ต่อมาของเราก่อนดีกว่านะคะ เดี๋ยวเด็ก ๆ จะได้
ไปเดินงานวันวิทยาศาสตร์ต่อ
ค่าที่เราจะส่งเข้ามาในฟังก์ชันตอนแรกนะ
ทำให้สามารถเรียกใช้งานฟังก์ชัน
สลับหน้าจอก่อนไม่สลับไม่ได้
เห็นไหม
นี่นะคะ ในตัวอย่างนี่ สร้างฟังก์ชัน
ดูส่วนต่อมานะคะ ส่วนที่เรียกว่า
"Default Argument Value"
เห็นไหม ใส่ Argument เข้าไปด้วยเลย มี พ
Salary มี Argument =
กำหนดค่าเริ่มต้นนะคะ เป็นการกำหนดค่าเริ่มต้นให้
กับไอ้ค่า
แล้วกำหนด Argument ให้มันด้วยเลยนะคะ แล้วก็
สร้างพารามิเตอร์ตัวที่ 2 ชื่อว่า lang
โดยส่ง Argument ที่น้อยกว่าจำนวนที่กำหนดไว้ก็ได้นะคะ
ดูตัวอย่างจะเห็นภาพชัด
แล้วก็สั่งให้ print
ชื่อว่า show_info
ไม่ได้ใส่เป็นพารามิเตอร์
ก็คือ Argument ที่ชื่อ...
ไม่ใช่ print Argument print parameter
84360 เห็นไหมคะ
นี่คือการ Defal
ตอนเราเรียกใช้ ให้เด็ก ๆ ดูตอน Calling Function
ใน name นี่เราไม่ได้กำหนด Argument ให้เหมือน salary
หรือ Language นะคะ มาจากคำว่า "Language"
แล้วใส่ Argument ที่ชื่อว่า Python
พอ พอเราเรียกนะคะ เรียกใช้มันปุ๊บนี่
อันนี้ผิดนะนี่ พิมพ์ผิดขอโทษ มันต้องเป็น
print ที่ 1 บอกให้ print เฉพาะแค่ชื่อ
print ที่ 2
ไหง มือบอกไปพิมพ์ Java สะงั้น
สะอย่างนั้น เพราะ Argument ที่เราใส่เข้าไป
นะคะ ที่ชื่อ Salary เห็นไหม print Name print Salary
แล้วก็ print
กับ Lang Language
เห็นไหมคะ
เมื่อกี้กลับมาแก้
ดูนะคะ เดี๋ยว
Python ขึ้นมา ไม่ใช่ JAVA
เดี๋ยว ๆ ขอแก้ก่อน
นะ เพราะฉะนั้น เปิด Colab ของเรา
ขึ้นมาไว้นะคะ
ชื่อ Python นะคะ
โอเค สลับได้ เดี๋ยวสลับไป เดี๋ยวสลับไม่ได้ เดี๋ยวจะตีมือ
นะคะ โอเค
ไม่สลับอีกแล้ว ไม่เป็นไร
ทีนี้ สร้างโค้ดใหม่เลยนะ
เด็ก ๆ กด + เพิ่มโค้ดใหม่ไปเลย
เราจะลองทำฟังก์ชันแบบกำหนด Argument ด้วย
นะคะ
มาดูแบบที่ 2 ที่เราสร้างฟังก์ชันที่มีการ...
แล้วเราก็ต้องสลับ
โอเคสลับได้
นะคะ ฟังก์ชันแบบที่ 2
ให้ Argument ในฟังก์ชันเลยนะคะ ก่อนอื่น เราก็ต้องพิมพ์
คำสั่ง def
จะได้ไม่ไปงงกับอันแรกนะคะ อันแรกเป็นการสร้างฟังก์ชันแบบปกติ
ที่ไม่ได้กำหนดค่า Argument ให่
ชื่อฟังก์ชัน ซึ้งในตัวอย่างใช้คำว่า "show_info"
นะคะ ไม่อยาก
มันทะลุจอไป
จอไป
ถ้าชื่อมันเป็น 2 ประโยคนี่ เขาจะใช้ Under sco
แยกประโยคที่ 1 กับประโยคที่ 2 เห็นไหมคะ s-
ชื่อว่า Default Argument Value
นี่นะคะ แบบที่มีการกำหนดค่า
ประโยคที่ 2 คือ คำว่า "info"
ก็คือโชว์ข้อมูลนั่นเองนะคะ info ย่อมาจาก
d-e-f เพื่อประกาศตัวแปร... เพื่อประกาศ
ฟังก์ชัน แล้วก็ตามด้วย
สร้างฟังก์ชันที่ชื่อว่า show_info นะคะ โดย
ในนั้นนี่ กำหนดพารามิเตอร์
ตั้งชื่อยาวกว่านี้ก็...
สังเกตนะคะ เวลาตั้งชื่อ ฟังก์
แล้วมีพารามิเตอร์ที่ 2 คั่นด้วย
โคลอน ไม่ใช่โคลอน คอมมา
h-o-w show คือ ประโยคที่ 1
show คือแสดงนะคะ แล้วตามด้วย
แล้วก็ตามด้วยชื่อพารามิเตอร์ตัวที่ 2 ซึ่งพารามิเตอร์ตัวที่ 2 นี่
เราจะกำหนดค่า
information นั่นเองนะคะ
ตอนนี้เราสร้างฟังก์ชันที่ชื่อ
ซึ่งแปลว่าเงินเดือนนั่นเองนะคะ salary
ตัวที่ 1 ชื่อว่า name n-a-m-e
name นะคะ
อันนี้กำหนดเองได้เลยนะคะ เด็ก ๆ อยากได้เม่าไหร่ เด็ก ๆ กำหนดเอง
ใส่เข้าไปเองเลย
เรียกผิด เรียกถูกตลอดเลย
นะคะ
อันนี้
Argument ให้เขาไปเลยนะคะ เพราะฉะนั้น พารามิเตอร์
ตัวที่ 2 ชื่อว่า
สิบ ร้อย พัน หมื่น นะคะ 20,000
ปุ๊บนะคะ เสร็จแล้ว
ซึ่งแปลว่าเงินเดือน อยากได้เงินเดือนเท่าไหร่เด็ก ๆ
ตรงเครื่องหมายเท่ากับใส่เข้าไปนะลูก
ืn-g lang นะคะ
แล้วตามด้วยเครื่องหมาย =
ในที่นี้ภาษาเริ่มต้นเข้าบอกว่า Python
เขาบอกว่าค่าเริ่มต้นที่ให้ สมมติ 20,000
หน่วย หน่วย
เมื่อจบ เมื่อจบ
การประกาศฟังก์ชัน ปิดด้วยเครื่องหมาย :
เพิ่มพารามิเตอร์ตัวที่ 3 ชื่อว่า
lang ซื้อมาจากคำว่า
ชื่อว่า show_info นะคะ ดูไปด้วย
อธิบายไปด้วย มีพารามิเตอร์ทั้งหมด 3 ตัว
แล้วก็ตามด้วยชื่อ...
คำว่า Python lang
แล้วก็มี lang โดยกำหนด Argument
ของ
เมื่อเสร็จ
หลังจากนี้ ก็คือ 1. นะคะ print ค่ะ ให้ใช้คำสั่ง
print
เสมอนะคะเด็ก ๆ
ตอนนี้เรามีฟังก์ชันที่
ก็จะอยู่ในเครื่องหมายคำพูด แล้วตามด้วย
ข้อความ ซึ่งในที่นี้
คือ name salary นะคะ โดยที่ salary นี่
กำหนด Argument เริ่มต้นด้วยที่ 20,000
ก็คือชื่อนะคะ
แล้วก็ตามด้วยเครื่องหมาย :
Language นี่นะคะ ว่า Python
เมื่อประกาศฟังก์ชันเสร็จ
ใส่ %s
อย่าลืมว่าเมื่อเราใช้เปอร์เซ็นต์ ตัวอักษร
print อะไรบ้าง print แรก ก็คือต้องการ
ให้ print ชื่อ
แล้วไปที่หลังเครื่องหมาย
คำพูดนะคะ อยู่หลัง
เราจะไม่พิมพ์เป็นภาษาไทยแล้วนะ เพื่อให้รู้ว่าตรงนี้คือสิ่งที่เราต้องการให้
name มาใช้นะคะ แล้วก็พิมพ์คำว่า "name"
: ชื่อ
เปลี่ยนเป็นภาษาไทย
statemat ที่ 1 statemet ที่ 2
print ชื่อค่ะ พิมพ์ค่ะ
จะเป็นตัวเล็กเสมอ ไม่ใช่ตัวใหญ่ เพราะเราผิดไปแล้ว 1 ครั้งนะคะ
เราต้องจำให้ได้
Salary คือ เงินเดือน ขอโทษ ในเครื่องหมายคำพูด
ใส่คำว่า "เงินเดือน" ค่ะ แปลเป็นไทยเลย
เครื่องหมายคำพูดนะ เด็ก ๆ ดูดี ๆ เลื่อนตำแหน่งมานะ แล้วก็
ใส่เปอร์เซ็นต์แล้วก็เรียกพารามิเตอร์
นะคะ เมื่อเราต้องการ
เสร็จ
พิมพ์ % แล้วก็ตามด้วย d ตัวเล็กนะคะ
print พิมพ์ print เหมือนเดิม
แล้วบอกไม่ใช่ชื่อสิ
ก็คือให้แสดง... ให้ print ข้อความเพื่อแสดง
เงินเดือนนะ และตัวที่ 4 ค่ะ
เด็ก ๆ น่าจะพิมพ์ง่ายขึ้น
ก็คือ print ภาษามันเองนะคะ
Language มาจากภาษานั่นเองนะคะ
เลขที่เป็นจำนวนเต็มนะคะ ไม่มีทศนิยมนี่ เรา
ก็ใช้ %d
เพราะฉะนั้น ในเครื่องหมายคำพูด พิมพ์คำว่า "ภาษา"
โอเคไหมคะ
เราก็จะได้ Statenert
แล้วก็ตามด้วยเครื่องหมาย Colon
เอ้ย ตัวที่ 2 ตัวที่ 3 ค่ะ
พูดผิดตัวที่ 3
เพื่อให้แสดงข้อความนะคะ
ลืม
statements ที่ 3
เราต้องการให้แสดงภาษา
ค่าพารามิเตอร์ เช่น อันที่ 1 % name
ก็เป็นเปอร์เซ็นต์ salary เปอร์เซ็นต์ที ่
ว่าภาษา... เดี๋ยวจะงงนะ
ภาษา Python
ใส่เครื่องหมาย % แล้วตามด้วย
ชื่อพารามิเตอร์ตัวที่ 3 คือ lang
ถ้าเป็นข้อความหรือ string นะคะ
สิ่งที่จะกำหนด
ตัวอย่าง เช็กจากโค้ดที่เขียนนี่ เห็นไหม ทุกตัว
จะระบุว่าเมื่อมีข้อความ
เห็นไหม รูปแบบมันจะเหมือนกัน พอหลังเครื่องหมายคำพูด
เราต้องใส่อะไรคะ % แล้วตาส
แล้วก็พารามิเตอร์ที่ชื่อว่า lang นะคะ
แล้วในตัวอย่างมันมีบอก
ชื่อว่า salary จำได้นะ อันที่ 3 ก็ทำ
เหมือนกันใส่เครื่องหมาย %
p-r-i-n-t print แล้วก็ตามด้วยเครื่องหมายวงเล็บ
หรือ Language ของเรานั่นเอง l-a-n-g นะคะ
เช็กนะคะ เช็ก
เมื่อเราทำการประกาศฟังก์ชันแล้วนะคะ บอกแล้วว่า
ประกาศเสร็จจะต้องมีการทำอะไรคะ เรียกใช้
แสดงแล้ว แล้วสิ่งที่จะให้แสดง ก็คือพารามิเตอร์ที่ชื่อว่า name
พารามิเตอร์ที่ขื่อว่า na
เคอร์เซอร์เราขยับเข้ามาอยู่ตำแหน่ง print ไม่ได้
นะคะ กด Enter ลงไป 2 ครั้ง เสร็จแล้ว
print ช่องว่างอีก 1 อัน
ดูสิมันจะขึ้นชื่อว่าอะไร
เห็นไหม ให้เคอร์เซอร์มันมาอยู่ตรง
ชิดขอบน่ะนะ แล้วก็
ขึ้นมาเลย
show_
ใช่ไหม callingfunction
แต่ทีนี้ตำแหน่งในการเรียก
แล้วก็ใส่พารามิเตอร์ชื่อลงไปให้
กดเครื่องหมาย Backspace หรือ
ลูกศิษย์ย้อนหลัง
วงเล็บเสมอ เห็นไหมคะ อยากให้
show พารามิเตอร์ชื่อว่า name o
เรียกฟังก์ชัน show_info
นะคะ เราจะเรียกฟังก์ชัน show
ชื่อเรา ชื่อเล่นก็ได้นะคะ ใส่ชื่อเล่นลงไป
show แล้วก็ _ แล้วก็ตามด้วย info
ดูในตัวอย่างที่ 1 นะคะ show_info
ตอนเรียก show... เรียกฟังก์ชัน show_ info
แสดงเฉพาะพารามิเตอร์ชื่อนะคะ
เดี๋ยวเผื่อไม่เห็น ขยายให้ดูก่อน อย่าลืม
นะคะพอเรียกใช้ฟังก์ชันมันจะต้องมี
แสดงชื่อ แล้วก็เงินเดือนนะคะ
ดูนะคะ
นะคะ ในเครื่องหมายคำพูด
ก็คือคำว่า "show" ลืมแก้ภาษษอังกฤษอีกแล้ว
s-h-o-w
อันนี้พารามิเตอร์แรกนี่
ที่ต้องการให้มันแสดง ก็คือชื่อ
ขี้เกียจสลับแล้วนะ
ในตัวอย่าง
เรียกฟังก์ชัน show_info
หรือ Comma นะคะ
แล้วก็ตามด้วย
ทำเหมือนเดิม
พมิ์ชื่อฟังก์ชันที่เราจะเรียก
ในฟังก์ชันนี่ เรากำหนดที่ 20,000 แต่ใน
ตอนที่เรามาเรียกนี่ สมมติว่าเงินเดือนเราเพิ่มขึ้น
show_info นะคะ
แล้วตามด้วยค่าพารามิเตอร์
ลงไปนะคะ ถ้า
เราต้องการให้มีฟังก์ชัน เอ้ย แสดง
แล้วต้องการให้มีพารามิเตอร์ตัว
ที่ 2 ก็คือขั้นด้วยลูกน้ำ
= Python นี่ เราจะเอา
ภาษาอื่น เช่น ภาษา C นะคะ
ค่าพารามิเตอร์ในตัวที่ 2 เช่น เงินเดือน เงินเดือนนี่
ในในฟังก์ชันนี่
ก็คือในกรณีที่เรียงฟังก์ชันที่ 1 นี่ โชว์เฉพาะ
พารามิเตอร์เดียว เราก็พิมพ์แค่
หรือเงินเดือนของคนคนนี้มีมากกว่า 20,000 มี 23,000
เป็น 23,000
เรียกฟังก์ชันในอันที่ 2 นี่ แม่อยากให้
มันแสดงทุกพารามิเตอร์เลย แม่ก็เลยใส่เข้าไปครบ
พารามิเตอร์ตัวที่ 3 เราก็พิมพ์
ค่าพารามิเตอร์ตัวที่ 3 แต่เราไม่ได้เอา
นี่ เห็นไหมคะ ชื่อ เงินเดือน
เห็นไหม แบบที่ 1
ก็ใส่คำว่า c ลงไป
พร้อมจะดูผลลัพธ์หรือยังคะ
ที่มีอยู่แล้วขึ้นมาด้วย เห็นไหมคะ เพราะ
เมื่อเรียกฟังก์ชันนี้ปุ๊บ สิ่งที่มันจะแสดงมีอะไรบ้าง ชื่อ
ชื่อฟังก์ชันแล้วก็ตามด้วยพารามิเตอร์ที่เราต้องการให้แสดงพอ
แต่ใรกรณีที่
มันจะเว้นให้ 1 บรรทัด เด็ก ๆ ดู
พออันที่ 2 มามันเว้นก่อนบรรทัดหนึ่ง
3 อัน เห็นไหมคะ เดี๋ยวเล่นให้ดูนะคะ ว่าผลลัพธ์
ออกมาจะเป็นยังไง
พื้นที่สี่เหลี่ยมมันก็ติดกัน เห็นไหมคะ แต่พอ
ตัวอย่างนี้ นี่
แบบที่ 1 ตอนเรียกนี่
ให้แสดงแต่ชื่อ แต่มันก็จะแสดง
ิสิ่งที่มันแสดงมีชื่อเหมือนกัน มีเงินเดือนเหมือนกัน ภาษา
แสดง 3 อย่างเห็นไหมคะ นั่นก็คือฟังก์ชัน
มีเงินเดือน แล้วก็มีภาษา เห็นไหม
พอใส่ print แล้ววงเล็บ
นะคะ แต่มันจะแสดงตาม
อะไรเช่น เหมือนตัวแรก แสดงเฉพาะชื่อแรก
เด็ก ๆ ไปดูความแตกต่างกับอันแรก ที่ไม่มีเว้นบรรทัด
พอเราสั่ง print Hello
เห็นไหมคะ แต่พออันที่ 2 show_info อันที่ 2
แม่ไปเปลี่ยนไป แม่ไปเปลี่ยนว่า
มันมี print ในวงเล็บ
เห็นไหมขั้นมาก 1 อัน
ก็เลยเปลี่ยนเป็น 23,000 ภาษาของเขา ก็เปลี่ยนเป็นภาษา C เห็นไหม
แต่มันจะรู้ว่าพารามิเตอร์ตัวที่ 2 นี่
ีที่ชื่อว่า show_info นี่ มันจะแสดงข้อมูลของชื่อ
ของเงินเดือนแล้วก็ของภาษาขึ้นมาทุกครั้ว
มันก็ไปแสดงที่คำว่า "ภาษา" เห็นไหมคะ นี่ก็เป็น
ใช้งานฟังก์ชันที่มีการ
เพราะฉะนั้น เงินเดือนกับภาษานี่มันจะไปแสดงตามค่าที่เรา
ตั้งไว้ในครั้งแรก
ดูเอาแล้วกัน ว่า
แบบไหนใช้งานง่ายกว่าให้ศึกษา
คนนี้คนใหม่ไม่ใช่คนเดิม นิวคนละนิว
เพราะฉะนั้นเงินเดือนคนนี้
นะคะ เห็นไหมคะ เรา
กำหนดค่า Argument
คือ เงินเดือน มันก็จะไปแสดงที่ตำแหน่งเงินเดือน เห็นไหม
พารามิเตอร์ตัวที่ 3
Keyword Argument ยังเกี่ยวกับ Argument อีก มันคืออะไรกัน
keyword ชื่อก็บอกอยู่แล้ว
กำหนดค่า ค่า Argument ไว้แล้ว
นะคะ ค่าเริ่มต้นไว้แล้วนะคะ
เขาบอกว่าใช้ชื่อของ
พารามิเตอร์ในการส่ง Argument
ให้มองเห็นความแตกต่างนะคะ
แล้วก็มาสู่หัวข้อสึดท้ายของเรา
เราจะต้องไปกำหนดค่าให้พารามิเตอร์ของเราก่อน ตัวแรกนะคะ
ดูตัวอย่างตัวนี้ เห็นไหมคะ
ไปได้แล้วนะคะ ต่อมา เรื่องต่อมา
ของเราเรื่องสุดท้าย
มันจะคล้ายกับอะไร คล้ายกับเมื่อกี้นี้ แต่มีข้อแตกต่าง
คือตรงไหน Keyword
คือ คำสำคัญนะคะ มันจะเป็นฟังก์ชัน
ที่มีรูปแบบ
สังเกต สังเกตที่อะไรเด็ก ๆ นี่ เห็นไหม
Color น่ะค่ะ
โดยพารามิเตอร์นั้นต้องมีการกำหนด
Default Argument ก่อน
ที่เป็นรหัส เขาเรียกว่าเป็นรหัสหรือเป็นคีย์น่ะค่ะ
เช่น fff นี่ น่าจะเป็นสีขาว
มันจะไม่ใช่ค่าตัว ที่เป็นแบบข้อความ หรือ
เป็นตัวเลข
Argument ที่เป็นลักษณะ Keyword นะคะ
ไม่เป็นไร ถ้าอยากรู้มันคืออะไร
ค่าสี คือ ไปเรียก
ใช้ค่าสี
ดูนะคะ ค่าสีใน... ในคอมพิวเตอร์
ดูนะคะ ค่าสี ค่าสี
หรือไม่ได้เติมสีนี่ล่ะ ถ้าจำไม่ผิดนะ ให้นึกถึงนะ
นี่คือ
นี่ เห็นไหม
ไม่สลับอีกแล้ว
เหมือนปกตินะ ไอ้ตัวนี้ คือ สิ่งที่เรียกว่า "Keyword"
นึกออกนะ Keyword Argument
นี่คือคีย์เวิร์ดของค่าสีในคอมพิวเตอร์ โดยปกตินี่
เวลาถ้าเราเขียนโค้ดนี่
เดี๋ยวจะลองให้ดูนะคะเด็ก ๆ
แล้วก็... ค่า
สี 3 ฐาน 16 มันจะไม่รับ มันจะรับค่าสี
ในคอมพิวเตอร์นี่มันมีหลายแบบ
ก็คือมันต้องมาอ่านค่าของตัวนี้ก่อน แล้วมา
แสดงให้เห็นสีที่เราต้องการจะรู้ เดี๋ยว
ไม่ต้องการอะไรแบบนี้
เด็ก ๆ ดูนคะ
อยากรู้ว่าเป็นสีอะไร เดี๋ยวเปิด paint ให้ดูนะคะ โปรแกรม paint
จะเห็นชัดกว่า
โปรแกรมมันจะรับค่าสีที่เป็นค่าสี
ฐาน 16 นะคะ RGB
ตัว 0000 ff นี่ เหมือนตัวอย่างนี่ ตัวนี้
คือเป็น Keyword Argument
ไม่ใช่ paint สิ อะไรนะ Microsoft Word ก็เห็นแล้ว
เดี๋ยวนะคะ
ทำให้ดูนะคะ ตัวอย่างนี้ เดี๋ยวนะ
ไอ้ 00 สีอะไร
โปรแกรม Paint นะ
ตรงนี้จะเป็นค่าสี มันจะมีแบบ
มาตรฐานกับกำหนดเองนี่
เดี๋ยวไอ้นี่ไม่เห็นสิ
ไม่ใช่สิ อย่างนั้นเปิดให้ดู
ตารางค่าสีเลยแล้วกันนะคะ
เปิดให้ดูว่าเราจะรู้ได้อย่างไรว่าค่าสีนี้สีอะไร
เปิดใน Word ให้ดูนะคะ
ดูนะคะ ตารางค่าสีจะเป็นอย่างนี้
ดูสีนะ เด็ก ๆ ดูที่สีนะคะ
นี่เห็นไหม
ไอ้ตัวนี้ก็ไม่ขึ้นแบบนี้
ลักษณะนี้นะ อันนี้จะเห็นชัดนะคะ ว่าถ้า
สีชมพูเข้มขนาดนี้
ชักงงเอง ตารางค่าสี
มันก็ขึ้นอยู่ข้างในนี่
ตัวเลขที่แสดงค่าสีมันน่ะ
อันไหนที่จะเห็นชัด
ไม่โชว์แล้วน่ะ เดี๋ยวเทสต์ให้ดูเลยนะคะ
อย่างนี้นะคะ สมมติสีชมพู
นี่เห็นไหมตัวเลขสีมันก็จะเปลี่ยนไป
เอาแค่นี้พอ
ปุ๊บ print color ขอก๊อปก่อน
ค่าสีจะเป็นตัวนี้ อย่างนี้นะคะ
ตัวนี้ขึ้นไหม
เราไหมนี่
ถ้าอยากรู้ว่าสีไหนเป็นสีอะไร อย่างเล็ก
ไม่เอาน่ะ
ไม่วางให้นะคะ ไม่เป็นอะไร
ขอเพิ่มโค้ดให้ จะทำโค้ด
แค่สร้างสีตัวเดียวเลย
อันนี้เป็นตัวอย่างให้เห็นว่า Key
Argument def ฟังก์ชันนี้
ขี้เกียจน่ะ ขี้เกียจพิมพ์
copy ให้
c-r-e-a-t-e create color
ใส่พารามิเตอร์ ชื่อ color นะคะ โดย
มีค่าเท่ากับ
สมมติ สมมตินะคะ สร้างฟังก์ชัน
เดี๋ยวสร้างให้ดูเด็ก ๆ ไม่ต้อวง
โดย
กำหนด Default Argument ที่
จะใช้ในการสร้างสีนั่นเองนะคะ
ตัวที่บอกว่า f นี่ มันเป็นคีย์เวิร์ดของ
ค่าสีที่บอก เพราะฉะนั้น พอเรา
ขอโทษที มือไวจริง ๆ เลย
1, 2, 3, 4,
5, 6 6 นะ
เราจะ
ให้มัน print สีนั้นออกมาให้ดูนะคะ
เครื่องหมาย # F1 F2 F3 F4
f5
ดูนะคะ เห็นไหม นี่
สร้างฟังก์ชันนี้ มันจะแสดงอะไรออกมา
ดูนะคะ ทำไมเผลอไปลบ
=
4
print color
print อะไร ต้องการให้ print
ขอเพิ่มพารามิเตอร์อีกตัวหนึ่ง
ใส่สีนี้อะไรจะเกิดขึ้น อันนี้ประกาศตัวแปรจะเสร็จแล้ว จะเรียกใช้
มันนะคะ เรียกใช้
่
เราก็คลิกเลือก แล้วตามด้วย id ลำดับ
ที่ 1 นะคะ
ขอลอง print ก่อน
คือ id นะคะ id คือ ลำดับที่นั่นเอง
เพื่อให้เห็นว่าอันที่ 1
เหมือนเดิมนะคะ
Create color พิมพ์ชื่อฟังก์ชัน
a-t-e
แล้วก็ % เหมือนเดิม
%d นะคะ ตัวเลข เป็นตัวเลข
แล้วก็ตามด้วย
พิมพ์อะไรผิดนี่ p-r-
i
ลำดับที่แล้วก็ตามด้วย :
ใช้ colon แทน
% ลำดับที่เป็น % อะไรนะ
% แล้วก็ค่าพารามิเตอร์ ก็คือ id
syntax error ผิดตรงไหนนี่
อ๋อ
p-r-i-n-t print
แม่พิมพ์อะไรผิด
p-r-i-n-t
ลบแล้ว print ใหม่ p-
i-n-t
เดี๋ยว Run ให้ดูเลยนะคะ
ตำแหน่ง เดี๋ยวนะ Enter เข้าไป เอาใหม่สิ
+
print เอาใหม่
ลบก็ได้
Syntax Error Invalid
print
เดี๋ยวนะ 1
เขาก็ไม่ได้พิมพ์ผิดนี่
ทำไมมันขึ้น Error ล่ะ
ผิดได้อย่างไรล่ะ
เดี๋ยวนะ ขอ
ขยายก่อนนะ
1 2 3 4 5 6
1, 2, 3, 4,
ก็ตรง
อะไรนะ
ผิดตรงไหนนี่
ลืมอะไร ไม่ได้ลืมนี่
ทำไม Syntax นี้ Error ล่ะ
เอาอีกแล้ว
Syntax Error Print
มันบอกว่า print ไม่ได้น่ะ
print บรรทัดที่ 3 ไม่ได้ colors หรือ
ถ้าลบ
จะขึ้น Error อีกไหม
ไม่รู้จัก
รันผ่าน รันไม่ผ่าน
มันจะ Error ได้ยังไงน่ะ
อ๋อ รู้แล้ว
ผิดตรงไหน
ตรงนิดเดียว มองไม่เห็น
ลืมใส่เครื่องหมายคำพูดตรงคาบ
อะไร
นะคะ เดี๋ยวจะขอลองดู
ผิดตรงไหนหรือเปล่านี่
print คำสัง Prit
โอเคนะคะ
รู้แล้ว
อันนี้ถูกแล้วนะคะ
ของ color นะคะ
มันก็เลยคำสั่ง print สี
คิคือ fff ขึ้นมาอย่างนี้นะคะ
ก็คือจะแสดงเป็น
นี่
อยากโกรธโปรแกรมดีหรือไม่ก็ไม่รู้
สาเหตุ ก็คือนี่มันมี
เครื่องหมายคำพูดนี่ แต่ไม่ได้ใส่ให้มันนี่นะคะ
ผลลัพธ์ก็จะออกอย่างนี้ คือ พิมพ์ลำดับที่ 1 เสร็จ
มันก็จะ print สี่ที่มีค่า
เหมือนกันนั้นล่ะค่ะ default
ดี ๆ แค่นั้นเอง ว่าจะให้มันเป็น
Argument ที่เป็น Keyword นั่นเองนะคะ
ก็ต้องมาใช้รูปแบบนี้นะคะ
เขาบอก
พอเปลี่ยนฟอนต์น่ะ มันก็มาจัด
ตัวนี้ตัวเล็กตัวใหญ่ดูยากมาก
ข้างหน้าตัวนี้
พอ Run แล้วถึงจะผ่าน
นะคะ
ก็คือการกำหนดค่า Argument
ก็คือแสดงลักษณะที่เป็นคีย์เวิร์ดแบบนี้ออกมา
สงสัย
Default ที่เป็นลักษณะ... Argument ที่ให้มันแสดง
มันเป็นลักษณะไหนถ้าเป็น
ไอ้ค่าที่เราจะใส่เข้าไปนี่ล่ะค่ะ เพราะตัวนี้ ลักษณะ
คือมันเป็นค่าของเขาเรียกว่าอะไรนะ
เขาเป็น Keyword
นี่มันต้องใส่เครื่องหมายที่เป็นคำพูด
รหัสสี ซึ่งความจริง ก็คือถ้าเราใส่สีแดง
สีชมพูอะไรอย่างนี้ แต่อย่าลืมว่าสีในคอมพิวเตอร์น่ะ
ถึงจะขึ้นนะคะ
ขึ้นค่าให้
มันก็จะเป็น #ec407a
เปลี่ยนไปตามความเข้มความอะไรอย่างนี้ด้วยนะคะ
ตรงไหนหรือเปล่าคะเด็ก ๆ ความแตกต่าง แทบไม่แตกต่าง
ว่าไม่แตกต่างกัน มันต่างกันตรงค่า
นั่นก็คือเป็นคีย์เวิร์ดหรือคำสำคัญ
คือคอมพิวเตอร์น่ะจะรู้นะ คอมพิวเตอร์
เขาเรียกว่า "
เป็น code สีนะ
ในฟังก์ชันนะคะ คือ ที่เราจะทำจริง ๆ นะ
มันก็จะมีแบบที่ 1 น่ะ
มันแยกเฉดอีก เหมือน
อย่างนี้ ชมพูเข้ม
ฟังก์ชัน มีพารามิเตอร์ แล้วในพารามิเตอร์
กำหนด Argument ลงไปเลยอย่างนี้ก็ได้
เหมือนสีฟ้านี่ ค่าเขาก็จะเปลี่ยนไปตาม
ที่เห็นนนะคะ
สำหรับสัปดาห์นี้นะคะ เราก็จะจบ
บทเรียนหลักการเขียนโปรแกรม
เขาจะรู้จัก ว่าอย่างนั้นเถอะนะคะ
ถ้าไม่มีใครสงสัย
เดี๋ยวสอบแล้วจะนัดแนะอีกทีหนึ่งนะคะเด็ก ๆ
มีใครสงสัยไหม ถามได้
กำหนดฟังก์ชันขึ้นมานะคะ อย่างนี้ แล้วก็ตามด้วยพารามิเตอร์
กับแบบที่ 2 ที่มีการกำหนด
เพราะอย่าลืมว่าแล็บไม่ได้แต่เราใช้คนเดียวนะ
เมื่อเลิกใช้เราต้องออกจากระบบของเราทุกครั้งนะคะ
ได้ทั้ง 2 แบบ แล้วแต่จะเลือกใช้งาน แล้วแต่วัตถุประสงค์
การที่จะสร้างฟังก์ชัน
ของเราในเทอมนี้เพียงเท่านี้นะคะ
สัปดาห์หน้าจะให้เบรก
มันชอบมาเปลี่ยนฟอนต์ให้
เครื่องที่มี
ถ้าไม่มีจะปล่อยแล้วนะคะ
อย่าลืมออกจากระบบทุกครั้งด้วย
ขอบคุณพี่ล่ามค่ะ สำหรับการเรียนในวันนี้ขอบคุณค่ะ
(ล่าม) ฮัลโหลครับ
-
(อาจารย์สุธิรา) สวัสดีค่ะ พี่ล่ามไม่ได้ยินเรานะ
นะคะ
สำหรับวันนี้นะคะ ในสัปดาห์นี้จะเป็น
ใน Python
เราจะต้องมาเรียนเบื้องต้นนี่ ก็คือต้องมารู้จัก
นะคะ หัวข้อที่
เราจะเรียนในสัปาดาห์นี้นะคะ จะเป็น
ฝั่งล่ามไหมครับผม
(อาจารย์สุธิรา) ได้ยินค่ะ (ล่าม) โอเคครับ
วันนี้เราจะพูดถึงการ
นะคะ การเรียกใช้งาน
(ล่าม) ได้ยินครับ ได้ยินครับ
(อาจารย์สุธิรา) ได้ยินไหม ได้ยินนะคะ โอเค นึกว่าไม่ได้ยิน
นะคะ อ้าวทำไมหน้าจอไม่ขึ้น
เรื่องเกี่ยวกับ
ฟังก์ชันนะ
โอเคนะคะ ก่อนอื่น
สิ่งที่เรียกว่า Function ก่อนนะคะ
คือ ถ้าพูดถึงโดยทั่วไปนะคะ
หัวข้อสุดท้ายของปีนี้
เทอมนี้นะคะ ภาคเรียนนี้ ก็คือฟังก์ชัน
สั่งพิเศษ
ีที่ให้ทำงานเฉพาะสิ่งใดสิ่งหนึ่งนะคะ
แล้วก็พูดถึง
Default Argument Values แล้วก็ Keyword Argument
ในส่วนของภาษา python
ฟังก์ชันจะเป็นโค้ด หรือโปรแกรมที่เรา
อีกแล้ว...
เหมือนตั้งขึ้นมาว่าฟังก์ชันนี้จะตั
นะคะ เช่น
ก่อนจะรู้วิธีการสร้าง
การเลือกใช้งานนี่ เราก็ต้องรู้ก่อนว่าฟังก์ชันมันคืออะไรนะคะ
แล้วไปเรียกฟังก์ชันนี้มาเพื่อให้มัน
ทำกาารคำนวณค่านี้ให้อย่างนี้นะคะ นั่นคือจุดประสงค์
ก็คือถ้าเราเป็นโปรแกรมเมอร์หรือ
ในวิธีการเขียนโปรแกรมคอมพิวเตอร์นี่ ฟังก์ชันมันจะเป็น
บอกแล้วว่าในสัปดาห์นี้เราจะสร้าง
ขึ้นมาใช้งานเองนะคะ แล้วเมื่อสร้างเสร็จแล้วนี่
ซึ่งแต่เดิมนี่ฟังก์ชันมันจะเป็น
ที่เขาพัฒนาไว้แล้วก็มี แต่ใน Python นะคะ
มาใช้โดยวิธีการใด
หรือเรียกใช้อย่างไรนะคะ แล้วก็จะพูดถึง Default Argument
สร้างขึ้นได้เองนะคะ
เพื่อเอาไปใช้กับ...
กระบวนการที่เราจะต้องทำ
ก็คือเมื่อเราจะทำฟังกชันขึ้นมา
เหมือนบางครั้งนี่ การคำนวณบางอย่าง
ไม่จำเป็นต้องไปเขียนโค้ดใหม่ทุกครั้ง เราก็เลยสร้างฟังก์ชันไว้เลย
ใน python
เราสามารถสร้างขึ้นเองได้นะคะ โดย
จะนำไปใช้ในสิ่งใดสิ่งหนึ่งนะคะ
เป็นการเฉพาะ โดยใน
ที่ที่บอกแล้วว่ามันสามารถ
ทำงานสิ่งใดสิ่งหนึ่งได้
จะต้องรู้ว่า
มันจะต้องเรียกฟังก์ชันที่เราใช้งานนี่จะถูกเรียก
ใช้ code นี้ซ้ำได้
ถ้าจะทำฟังก์ชันมาใช้งาน มันควรเป็น
ด้วยว่ามันคืออะไรแล้วก็ Keyword Argument ด้วย
ว่ามันคืออะไรนะคะ ทีนี้ก็จะเริ่มเข้าสู่
เราจะหาค่า vad นี่
คือ ถ้ามาเขียนโค้ด เราต้องมานั่งเขียนว่า Vat เกิดจากการ
เราจะสร้างมันอย่างไรนะคะ
การสร้างฟังก์ชันใน Python นะคะ
การที่เอาราคาสินค้ามาคูณกับ
ปริมาณที่ 7 เปอร์เซ็นต์เท่ากับเท่าไหร่ แล้วจะทำอย่างไร
วิธีการนี้นะคะ จะเป็น
ให้นึกถึงว่าเราจะเป็นคนเขียนโค้ด
นะคะ แล้วพอครั้งหน้าจะใช้ก็
เอาไปใช้ได้ หรืออย่างอื่น หรือคนอื่นจะเอาไปใช้ได้
แล้วเอาไปเรียกใช้ซ้ำได้อีกนะคะ จะเรียกว่า
"การนำโค้ดนี้กลับมาใช้" นี้ว่า "Code Reuse"
ขั้นตอนในการสร้างนะคะ
ก็คือมันจะมีรูปแบบ เราจะต้องเขียนโค้ด
ตัวที่เหมือน
สามารถเรียกใช้ได้บ่อย ๆ เช่น สมมตินะคะ
de
นั่นก็คือการประกาศตัวแปรนะคะ
ที่เอา
7 เปอร์เซ็นต์น่ะค่ะ Vat ก็คือ 7 เปอร์เซ็นต์ใช่ไหมคะ
แล้วตามด้วย function_name
เราจะให้รู้ว่าตัวนี้เป็นค่า Vat เราก็อาจจะ
สร้างฟังก์ชันสำหรับการคิด Vat ขึ้นมาอย่างนี้
ให้เห็นว่าคำว่า def นะคะ
ตัวเล็กเท่านั้นนะคะ ไม่ใช่พิมพ์ด้วยตัวพิมพ์ใหญ่
เมื่อรู้ว่าแต่ต้องรู้ด้วยนะว่า
มีฟังก์ชันนี้อยู่ อย่างนี้นะคะ ทีนี้
เราต้องพิมพ์คำว่า def
เป็นตัวแรกนะคะ แล้วตามด้วย function_name function_name
น่ะค่ะ เขียนโค้ดให้ฟังก์ชันเราโดยตามรูปแบบ
ในที่เห็นนะคะ จะต้องมีคำว่า "def"
ให้นึกถึงฟังก์ชันเนม
ตั้งชื่อให้ตัวแปร แต่อันนี้เป็นการตั้งชื่อ
บอกให้รู้ว่านี่นะ ฉันจะประกาศ
จะประกาศค่า ประกาศฟังก์ชัน ไม่ใช่ประกาศตัวแปร พูดผิด
ใส่ชื่อฟังก์ชันเราต้องต้องพิมพ์วงเล็บ
เสมอนะคะ แต่ถ้าเราพิมพ์ใน Colab ตัววงเล็บนี้จะ
เราต้องพิมพ์ d-e-f พิมพ์ด้วย
ตัวเล็กเสมอ ถึงได้ทำเป็นสีแดง
พารามิเตอร์
ถ้าเป็นเขียนโค้ดปกติ มันก็จะหมายถึงตัวแปร
นึกออกนะนะคะ
ก็คือทุกครั้งที่พอจะมีการสร้างฟังก์ชัน
อะไรล่ะ เขาเรียก
นี่ เขาบอกว่าพารามิเตอร์ของฟังก์ชันนี่
นั่นก็คือชื่อ ชื่อ
ของฟังก์ชันที่เราจะไว้เรียกใช้ในครั้งต่อไป เราจะเป็นคนตั้งเอง
พารามิเตอร์ตัวนั้นก็จะเป็นตัวเก็บให้เรา
สมมตินะคะ สมมติเราต้องการตำนวณหาค่า
ฟังก์ชันนี้คือฟังก์ชันอะไรนะคะ เสร็จ
แล้วก็จะมีวงเล็บ พอใส่คำว่า "def" แล้วก็
ค่าของรัศมีวงกลม
หรือมีค่าของอะไรนะ
ขึ้นมานะคะ แล้วส่วนข้างในนี่
นะคะ เขาบอกว่ามันเป็นการกำหนดค่า Paramiter
นี้นะคะ เสร็จแล้ว
เมื่อพิมพ์ function_name ใส่ค่าพารามิเตอร์
นะคะ แต่ในฟังก์ชันนี่เราจะ
เรียกว่า "พารามิเตอร์" เพื่อไว้สำหรับ
สังเกตนะคะ เมื่อใดที่
ตัวนั้นจะต้องปิดด้วยเสมอ แล้วขึ้นบรรทัด
มีจำนวนเท่าไรก็ได้ ก็คือในฟังก์ชันนี้
เราจะมีการเก็บค่าของอะไรบ้าง
แล้วเด็ก ๆ สังเกต
ดูนะคะ ว่าในการประกาศฟังก์ชันตัวที่ 1
พื้นที่
วงกลมอย่างนี้นะคะ ค่าพารามิเตอร์ที่จะเก็บก็อาจจะมี
คือการคืนส่งค่าคืนกลับ
ซึ่งฟังก์ชันที่เราเขียน อาจจะ
เส้นรอบวงอะไรอย่างนี้เข้ามานะคะ นั่นก็คือ
ค่าพารามิเตอร์ที่เราจะไว้เก็บข้อมูลในฟังก์ชัน
รูปแบบนี้ให้เห็นทั้ง 2 แบบ
เป็นแบบที่ไม่มีการ return ค่า
อะไรเสร็จ เราจะปิดคำสั่ง
การประกาศฟังก์ชันด้วยโคลอนเสมอนะคะ
เราต้องพิมพ์คำว่า return ด้วย
ตามด้วยค่าที่เราต้องการให้ส่งกลับ เช่น เดี๋ยวดู
ใหม่มันจะเข้าสู่ย่อหน้าใหม่
ตัว statements ในที่นี้หมายถึงคำสั่งอื่น ๆ นะคะ
ค่าที่ส่งกลับนั้นจะเรียกว่า
นะคะ
นะคะ กับตัวที่ 2 ตัวที่ 2
จะมีคำว่า return value return ก็
ตัวแปรแลลไม่มีการ return
ไม่มีคำสั่ง return เพื่อคืนค่านี่ ใน
เขียนแล้วมี return หรือ
ไม่มีก็ได้นะคะ แต่ที่เขียนให้ดูเป็นตัวอย่างนี่ ให้เห็น
hello()
def ก็คือ definition
แต่แบบที่ 2 นี่มี มีการส่งคืน
ค่ากลับ ก็เลยจะมีคำว่า "return value" ก็คือ
คือ def
แล้วก็ตามด้วย function_name ซึ่งในที่นี้ตั้งชื่อว่า
ในตัวอย่างจะเห็นชัดนะคะ เดี๋ยวยกตัวอย่าง
แล้วจะมองภาพไม่ออก ซึ่งเขาบอกว่า
นะคะ แล้วทีนี้
พอเวลาเรียกใช้ฟังก์ชันนี้นะคะ มันจะสั้น
ทีนี้เรามาดูตัวอย่างแรกก่อน
เพื่อจะให้เห็นว่าถ้าเราต้องการประกาศ
แล้วตามด้วย พารามิเตอร์หรือ
ที่เราไว้เก็บค่า ก็คือ name นะคะ เสร็จแล้ว ตาม
ตัวอย่างนี้เราจะประกาศตัวแปร
ชื่อ เห็นไหมคะ ตรง def แล้วตามด้วย
นะคะ แสดงคำทักทาย
ชื่อที่เรารับค่าเข้าไปนี่ หรือพารามิเตอร์ที่เรา
ก็คือคำสั่งเพื่อใช้
และติดประกาศตัวแปร ประกาศฟังก์ชัน ขอโทษทีนะคะ
ไปที่ web browser
แล้วเปิดเหมือนเดิมนะคะ พิมพ์คำว่า "Colab" น่ะ
hello นะคะ ฟังก์ชัน hello ก็คือ
ฟังก์ชันที่เราต้องใช้เพื่อแสดงคำทักทายออกมานั่นเอง
แล้วกด Enter เลย
เพราะสังเกตว่าเว็บไหนที่เราเปิดมันจะ
นึกออกนะ การเขียนโค้ดมันจะสั้น
กว่าที่เราเคยทำ
ที่เราใช้งานนะ แล้วก็คลิก
ด้วย statement ตามด้วยข้อความหรือคำสั่ง
หรือโค้ดอะไรก็แล้วแต่นะคะ ซึ่งในทีนี้เราต้องการให้แสดง
run มันไม่ได้นะคะ เด็ก ๆ อย่าลืม
ลงชื่อเข้าสู่ระบบด้วย Login เข้าไปด้วย
ส่งเข้าไป ก่อนอื่น เด็ก ๆ
เปิด Colab หรือยังคะ เปิด Colab ด้วย
ของเราให้เรียบร้อยด้วย
c-o ต้องบอกว่า co สิ
Colab l-a-b นะคะ พิมพ์ l-a-b
ไปที่เขียน code เหมือนเดิมนะคะ เด็ก ๆ
กดที่คำว่า "code" นะคะ ในบรรทัด
อัตโนมัติเด็ก ๆ กด Enter ได้เลนย
มันก็จะเข้ามาหน้า
de แล้วกฌ f
ใช่ไหมคะ พิมพ์ด้วยตัวพิมพ์เล็กเสมอนะคะ
Code นะคะ ลืมไป
อย่าลืมทำอะไรก่อน เข้าสู่ระบบนะ ไม่อย่างนั้นเราจะ
ตัวใหญ่นี่ถือว่าไม่ถูกต้องนะคะ
def นะคะ แล้วก็กด
นะคะ
แล้วตามด้วชื่อของฟังก์ชัน
ชื่อของฟังก์ชัน ในตัวอย่างเรา ชื่อว่า Hello
โอเคนะคะ เสร็จแล้วเราก็เริ่ม
นะคะ ไม่ใช่ตัวพิมพ์ใหญ่นะคะ
ดูดี ๆ นะคะ เพราะฉะนั้น
แรกของเรานะคะ เราก็เริ่ม
ประกาศฟังก์ชัน โดยพิมพ์คำว่าอะไรคะ
e-
l-l-o แล้วก็ใส่วงเล็บเข้าไป
ไม่ใช่พิมพ์ใหญ่แบบนี้นะ ไม่ใช่พิมพ์ D-e-f
Def แบบนี้ ตัวใหญ่นี่ถือว่าไม่ถูกต้องนะคะ
name นะคะ ตัวพิมพ์เล็ก
เพราะมันเป็นตัวแปรชื่อว่า name เมื่อ
Space bar เพื่อวรรค 1 ครั้งนะคะ
บอกแล้วว่าวิธีการประกาศฟังก์ชัน ก็คือพิมพ์คำว่า "def"
แล้วกด Enter 1 ครั้ง
ใช้วิธีกด Enter นะ ไม่ใช่เลื่อนเมาส์
ทีนี้มาดูชื่อ ชื่อของฟังก์ชันนี่
ก็ต้องใช้ตัวพิมพ์เล็กเหมือนกัน
Stagement
หรือคำสั่งต่อไปที่เราจะใช้ ก็คือคำสั่งแสดง
พิมพ์ตัว h
ด้วยตัวพิมพ์เล็กนะคะ h-
n-t
print แล้วก็ตามด้วยวงเล็บเหมือนเดิม print อะไร
แล้วก็ตามด้วย
พารามิเตอร์ ในวงเล็บพารามิเตอร์ของเรา ก็คือคำว่า "
เดี๋ยว
อ๋อ ขอโทษ ไม่ได้สลับหน้า
เสร็จฟังก์ชันใช่ไหม
เสร็จคำสั่งฟังก์ชันต้องปิดด้วยเครื่องหมายโคลอนเสมอ
เราก็ว่าอยู่แต่เด็ก
พิมพ์ตามใน PowerPoint แต่อยากให้เห็นใน Colab
ลงไป สังเกตบอกแล้วพอกด Enter นี่
ตำแหน่งของเคอร์เซอร์มันจะ Tab เข้าไปนะ
นั่นน่ะสิ
เดี๋ยวเลื่อนไอ้นี่เอาก็ได้นะ
ผลนะคะ ก็คือคำสั่ง print
p-r-i
ไอ้ตัวข้อความด้วย
เดี๋ยวสิ้นสุดการนำเสนอก่อน
สิ่งที่อยู่ในวงเล็บอย่าลืมนะคะ เมื่อใดที่
บอกให้พิมพ์วงเล็บนี่ สังเกตมันจะมี () ขึ้นมานะ
โอเคไหม
เดี๋ยวนะ กำลัง
มันไม่สลับหน้า
ตลอดเลย
โอเคน่า
จะได้เห็น 2 อย่างนะ เห็นไหมคะ จะมาที่คำสั่ง print ของเรานะ
เพราะว่าเมาส์หาย
เมาส์จ๋า เมาส์จ๋า
แป๊บหนึ่ง
ขยับ
โอเคนะคะ นะ
ในนี้จะพิมพ์คำว่า "print" นะคะ เดี๋ยวจะโชว์
ขอ 2 ทำไมได้ 4 นี่
เดี๋ยวนะ เดี๋ยวจะ
เดี๋ยวให้เห็น 2 หน้า
ด้วยกัน ไม่สิ ไม่สิ
แล้วก็
หามุม มุมให้เธออยู่
โอเคไหม
อีกหน่อยหนึ่ง นะคะ
แล้วในวงเล็บของ print
ลืมทำให้มันขึ้น 2 หน้าคู่กัน เดี๋ยวนะคะ
แล้วตามด้วย
เห็นไหม ตรงก่อน... ตรงก่อน Hello มี
ได้ไหม
ไม่เห็นหน้านี้อีก
แล้วค่อยพิมพ์ Hello ด้วยตัวใหญ่
แล้วก็ตามด้วย
กระเถิบ
แล้วหลังเครื่องหมายคำพูด
เด็ก ๆ ต้องเลื่อนไอ้ตัวนี้ไปหลังเครื่องหมายคำพูดนะ
ไม่เห็นในสไลด์อีกสิ
ส่วนแบ่งทางการตลาดเยอะ
name ตัวเล็กนะ ดูดี ๆ นะ เราเรียกใช้ เราสร้าง
วงเล็บในวงเล็บของคำว่า "print"
เราจะ print คำว่า "hello" นะคะ
นี่คือเสร็จฟังก์ชันนี้แล้ว
ลองเรียกใช้งาน ลองกด Play ก่อน
เครื่องหมายคำพูดนะดูดี ๆ อาจจะเห็นไม่ชัด
ใส่เครื่องหมายคำพูดนะคะ Single Quote หรือ
ที่เรา code
ที่เราเขียนไปนี่มันถูกไหม ถ้าผิดมันจะขึ้น Error ใช่ไหมคะ
เครื่องหมาย % %s
นั่นคือ ข้อความนี้เป็น String นะคะ
มันก็จะยังหมุนติ้ว ๆ อยู่นะคะ เราก็ต้องรอนะคะ
พิมพ์ % name
แล้วก็พิมพ์เปอร์เซ็นต์ แล้วตามด้วย
แสดงว่าไม่มีอะไรผิดนะคะ
ไม่ทำอะไรนะ เพราะฟังก์ชันสร้างขึ้นมา สร้างแล้ว
พารามิเตอร์ด้วย name ตัวเล็กเวลาเรียกใช้ก็ต้องใช้ตัวเล็ก
นะคะ
นะคะ ตอนนี้คือสร้าง
เพื่อให้คอมพิวเตอร์มันจำ จำไว้ว่าตอนนี้เราสร้าง
ขอโทษ เราจะได้รู้นะคะ
การกดตัวนี้นะ เพื่อจะได้เช็กว่า
เพื่อจะให้ตรวจสอบว่า
โค้ดที่เราเขียนไปมันถูกหรือเปล่า ถ้าผิดมันจะแสดง Error
ครั้งแรกเวลาโค้ดมันก็จะช้านิดหนึ่ง
ของใครขึ้น Error ยกมือ
สิ่งที่ต้องเช็ก ก็คือ 1. คำสั่ง
ก็คือชื่อฟังก์ชัน
ใช้ตัวเล็ก และตัวที่ 3 พารามิเตอร์ พามิเตอร์จะ
แล้วอย่าลืมว่ามันจะต้องมีการเรียกใช้ นึกออกนะ
ต้องสร้าง สร้างเพื่อให้มันไปโดนเรียกก่อน มันถึงจะทำงาน
การประกาศฟังก์ชันด้วย
โคลอนเสมอนะคะ
ฟังก์ชันชื่อว่า hello แล้วนะคะ
ที่ให้กด Run นี่
ประกาศฟังก์ชันที่ 1 ไปแล้ว
มาดูแบบที่ 2 นะคะ ฟังก์ชัน
นะ ถ้าเขียนไม่ผิดมันก็ไม่แสดงใช่ไหมคะ
นี่ลอง Run แล้วนะคะ Error ไม่ขึ้นนะคะ
สลับไปสลับมา
กันอยู่นี่ล่ะเรา อันนี้ อันนี้แบบไม่มี
d-e-f นะคะ definition
การประกาศฟังก์ชัน ตัวที่ 2
เราใช้เราสร้างฟังก์ชันนี้
ขึ้นมาเพื้อต้องการให้มันแสดงข้อความ เอา
มีค่าอยู่ในวงเล็บเสมอ
นะคะ เสร็จแล้วต้องปิด
ตัวนี้
ทำไมหนก่อนไม่เห็นมี หรือเพราะเป็น
ทีนี้เมื่อกี้
เป็นปัญหาในการใช้งาน
จะได้ใช้ Windows อื่นเสียล่ะมั้ง
ที่มีการ return หรือส่งกลับค่า
เดี๋ยวขยายหน้าไอ้นี่ให้ก่อน
เราจะประกาศฟังก์ชัน
มีการใช้ return value หรือการคืนค่ากลับ
return ค่านะ
ในตัวอย่างนี่เราสร้างฟังก์ชันชื่อ hello นะคะ
โดยมีพารามิเตอร์ 2 ตัว
width แล้วก็ความ... width แล้วก็
อีกแล้วอะไรอีกหว่า
สลับจอไม่ได้เลย น่าจะเป็นกับไอ้
กว้างคูณยาว
เพราะฉะนั้น ค่าพารามิเตอร์ที่ไว้ใช้สำหรับเก็บค้า
ไอ้นี่บ่ะ Windows 11 นี่บ่ มันถึงขึ้น
ไอ้สลับไอ้จอไอ้นี่ทุกทีเลย แล้วก็
ว่า width
นั่นเองนะคะ เสร็จแล้วปิดด้วยโคลอน
สลับไอ้จอไอ้นี่
นะคะ มาดูตัวอย่างที่ 2 นะคะ
สำหรับคำนวณ
ความกว้างคูณความยาว ก็คือคำนวณ
ในตัวอย่างที่ 2 เป็นการประกาศ
ฟังก์ชันที่ชื่อว่า area()
นะคะ ก็คือให้ส่งกลับค่าของ c
ก็คือเมื่อเอาพารามิเตอร์มาคำนวณแล้วนี่ c จะได้เท่าไหร่
height ซึ่ง area ในที่นี้ึ
พื้นที่ สูตรการหาพื้นที่สี่เหลี่ยม ก็คือ
แบบมีการ return ค่า
เพราะฉะนั้น บางคน
ก็คือค่าความยาวกับความกว้าง
นั่นเองนะคะ ก็เลยตั้งชื่อตัวพารามิเตอร์ 2 ตัวนี้
แล้วมันก็จะไม่ขึ้นไอ้หน้านี้
Statement ต่อมาสร้างตัวแปร
ชื่อว่า C ตัวแปร C
มันไม่สลับ Extend หรือ
หาพื้นที่ของสี่เหลี่ยมนั่นเองนะคะ
แล้วทำการ return ค่า c
โอเค ต้องสลับ
ส่งกลับค่าให้ c นะคะ
นี่คือการประกาศฟังก์ชัน
อย่างนั้นก็ต้องมาจัดไอ้นี่ใหม่อีกแล้วนี่
คีย์ใน Colab ไปเรียบร้อยแล้วนะคะ
เรามาเริ่มคีย์ของเราด้วยนะคะ
ไม่เห็นตัวหลังอีก เอา
อีกแล้ว มันเป็น
อะไรกับ...
ไม่เห็นอีก มัน
มันไม่ขึ้นหน้าจออีกแล้วน่ะ
แป๊บนึงนะสลับหน้าก่อน
โอเคไหม
2 รอบเชียวหรือนะคะ
เอาไว้ก่อน
ไปไหนแล้ว
ที่ 2 ต่อด้วยฟังก์ชันแรกได้เลยนะคะ
เมื่อหลังฟังก์ชันแรกเรากด Enter กดลงไป
เห็นไหม
ตำแหน่งตรงกับชิดขอบ
แล้วก็เริ่มพิมพ์คำสั่ง definition
น่านักเชียว
วรรคตามด้วย area
ตัวเล็กนะคะ
Colab
จะต้องมีพารามิเตอร์อยู่ในวงเล็บ
ก็คือพารามิเตอร์ตัวที่ 1 ชื่อว่า width w-
นะคะ
เราประกาศฟังก์ชัน
ขั้นพารามิเตอร์
ตัวต่อไป ด้วยเครื่องหมาย
2 อันเลยก็ได้เด็ก ๆ สังเกตตำแหน่งมันจะ
Tab เข้าไปนะ เรากดย้อนคืน 1 ครั้ง
นะคะ แล้วก็ตามด้วย
ชื่อพารามิเตอร์ตัวที่ 2 นะคะ ก็คือ h
d-e-f เพื่อประกาศใช้คำสั่งฟังก์ชัน
ที่ชื่อว่า... ชื่อฟัง์ชันของเราชื่อว่า area() นะคะ
นั้นเองนะคะ มีพารามิเตอร์
สำหรับเก็บความยาวกับความกว้างนะคะ ก็คือ width กับ height
แล้วก็
ตามด้วยเครื่องหมายวงเล็บ เพราะบอกแล้วมีชื่อฟังก์ชัน เสร็จแล้ว
เสมอ
เมื่อเราประกาศฟังก์ชันเสร็จแล้วนะคะ เรา
i-d-
t-h นะคะ คั่น
อัตโนมัตินะคะ
เสร็จแล้วเราประกาศตัวแปร ชื่อว่า c เพื่อ
Comma
นะ คอมมาหรือไอ้ลูกน้ำเรา
เพราะสูตรการหาพื้นที่สี่เหลี่ยม
กว้างคูณยาวนะ เพราะฉะนั้น เราอยากรู้พื้นที่สี่เหลี่ยม
-i-
h-e-i-g-h-t height หรือสูง
เมื่อเราพิมพ์นี่ ให้เรา
width w-i-d-t-h เพราะอย่างนี้ทำให้เรา
ปิดการ
ประกาศฟังก์ชันของเราด้วยเครื่องหมายโคลอน
เครื่องหมาย คูณในที่นี้ก็คือเครื่องหมายดอ
ตัวแปรทางคณิตศาสตร์ของโปรแกรม
กด Enter เพื่อไปพิมพ์
Statements ใหม่นะคะ เคอร์เซอร์มันจะ Tab เข้าไป
พารามิเตอร์ตัวที่ 2
h รอสักพัก แล้วหาคำว่า "height" นะคะ
ทำการคำนวณค่าพารามิเตอร์ 2 ตัวของเรา
ก็คือเอา width
เห็นไหมคะ เจอตัวนี้ปุ๊บ
คลิกเลย เพราะบางคนจะมีปัญหา เมื่อ
เอากว้างไปคูณกับยาว เพราะฉะนั้น ก็ต้องเอาพารามิเตอร์ width
ตัวนี้เด็ก ๆ ดูนะ
Error
เพราะฉะนั้น ตัว Colab นะคะ
พิมพ์พารามิเตอร์หรือตัวแปรที่เราสร้างไว้
ไม่ผิดนะคะ แล้วใส่เครื่องหมายคูณ
เห็นนะคะ พอเราเห้นเราคลิกเลือกมันได้เลย
นะคะ เมื่อได้
คอมพิวเตอร์เครื่องหมายคูณ ก็คือเครื่องหมายดอกจันนะคะ
แล้วตามด้วย
คำสั่งหรือ code ของ
นะคะ แล้วในบรรทัดต่อไป เราจะใช้
h-e-i-g-h-t
อาจจะพิมพ์ h-e ก็ได้ น่าจะขึ้น
พิมพ์ด้วยตัวเล็กนะคะ
ค่าที่เราต้องการให้แสดง หรือ...
ชื่อตัวแปรหรือพารามิเตอร์เริ่มยาวหรือยาก
จะพิมพ์ผิด แล้วพอพิมพ์ผิด พอไป Run โค้ดมันจะเกิด
ค่าของการที่เราคำนวณพื้นที่
c นั่นเองนะคะ เพราะฉะนั้น return c ตามด้วย c
ที่ดีเลย คือ เมื่อเราพิมพ์
ตัวแรกขึ้นมา ตัวแปรตัวนั้นมันก็จะขึ้นมาให้
เหมือนเดิมนะคะ
เพื่อเป็นการเช็กโค้ดของเรา ก็คือกดตัว
Statement เพื่อการคำนวณแล้ว
ต่อไปเราจบ
ว่า code ที่เราเขียนนี่
ถูกต้องแล้วนะคะ มีใคร
คำสั่งในการคืนค่าหรือ return value
โดยการพิมพ์คำว่า "return"
แล้วนี่คือ
การประกาศใช้ฟังก์ชัน หรือการสร้างฟังก์ชัน ทีนี้
หรืออะไรก็แล้วแต่ ซึ่ง
ค่าที่เราต้องการให้มันแสดงหรือเห็นนี่ ก็คือ
เราต้องไปเรียกใช้งาน
มันถึงจะแสดงไอ้ผลพวกนี้ออกมาได้
ไม่มั่นใจก็คลิก c
ที่มันขึ้นมาอย่างนี้นะคะ
ไม่สลับโหมดแล้วนะ
เดี๋ยวสลับไปสลับมา เราก็ เราก็แก้
Play ที่เป็นรูปเหมือนเป็น
Play Video Play Music อะไรพวกนี้ ให้มันเช็ก
ขอย่อให้มันพอดีหน่อย
โอเค
ขึ้น Error ไหมคะ
ไม่มีนะคะ แสดงว่าเริ่มมีความชำนาญในการโค้ดแล้ว
โหมดเป็นยังไงนี่
ขึ้นไหม ขึ้นอยู่ โอเค สลับได้
บอกแล้วว่าเมื่อสร้างเสร็จแล้วนี่
ไม่เห็นผลอะไรเลยใช่ไหม พอเรากด Play นี่
เมื่อสร้างเสร็จแล้ว
มันต้องเรียกใช้เสียก่อนนะคะ เราถึงจะรู้ว่าฟังก์ชันที่เราสร้าง
เพราะฉะนั้น เราจะมาดูเนื้อหา
ต่อไปนะคะ ก็คือ...
ก็คือในนี้
พอเราสร้างฟังก์ชันแล้วนะคะ เราต้องเรียกใช้งานมัน วิธีการเรียก
ไม่ได้อีก เดี๋ยวเสียเวลาในการแก้โหมด
หน้าจอนะคะ
และส่ง อาร์กิวเมนต์
อะไร เมื่อกี้มีพารามิเตอร์ มามี Argument อีก
ก็จะเล็กไปอีกใช่ไหมถ้าย่อ แล้วสลับ
ก็เป็นคำ ไม่ใช่คำ
เป็นค่าที่เราส่งเข้าไปในฟังก์ชันนะคะ
นะคะ เมื่อกี้บอกแล้วว่าถ้าเรา
ทำใน Colab เป็นการสร้างแล้วนะ ต่อมา
ในฟังก์ชันเพื่อรับค่า
เมื่อกี้พารามิเตอร์ที่เรามีตัวที่ 1 ชื่อว่า
มันใช้งานได้จริงไหมนะคะ
การเรียกใช้งานฟังก์ชันนะคะ
มันรับค่านั่นเองนะคะ
มาดูตัวอย่างวิธีการเรียกใช้ฟังก์ชันนะคะ
ใช้ ก็คือเราจะใช้ชื่อของ
ฟังก์ชัน เห็นไหมคะ
อะไรพิศดาลเลยเพียงแต่เราพิมพ
ชื่อฟังก์ชันนั้น แล้วตามด้วย
Argument กับ Parame
เดี๋ยวมีคำอธิบายนะคะ ว่า Argument
ชื่อเพราะในวงเล็บนี่
ิสิ่งที่เป็นตัวแปรชื่อว่า name นะคะ พารามิเตอร์
ตอนที่เราใช้งานนะคะ
ส่วนพารามิเตอร์น่ะ คือ ตัวแปรที่เรากำหนด
ที่เราจะให้
มันเก็บเลยนะ นะคะ ลองดูนะคะ
name นั่นคือตัวแปรที่เราใช้รับค่า
เพราะฉะนั้น Argument ก็คือชื่อที่เราจะพิมพ์เพื่อให้ตัวแปร
หรือมันช้า พอ... พอสลับมา Colab มันจะช้า
มาดูตัวอย่างกันก่อน
การจะเรียกใช้ฟังก์ชันที่เราสร้างขึ้น ไม่ได้มี
เห็นไหมคะ ตามด้วย Argument
ในที่นี้ ก็คือ
นี่คือฟังก์ชันเวลาเรียกใช้
ไม่ได้มีอะไรพิสดารเลยนะคะ ใส่ Hashtag ก่อน
น่ะชื่อว่า name แล้วพอเราเรียกใช้นี่
ก็คือเราพิมพ์ชื่อฟังก์ชันนั้น แล้วตามด้วยค่า
ใส่เครื่องหมา chap หรือ hahtag
อันนี้คือคอมเมนต์นั่นเองนะคะ เพื่อจะบอกให้รู้ว่า
ลองเลย ลองเลย เพื่อให้เห็นภาพ
แล้วก็ตามด้วยฟังก์ชัน f-u-n เด็ก ๆ ไม่ต้องพิมพ์ ไอ้นี
นิดหนึ่งหรือ ไม่สลับ
อีกแล้วนะ อะไรนะ
โอเค เรา
ก็จะต้องสลับกันอย่างนี้นะคะ นี่นะ เราไปประกาศไปแล้วนี่
ฟังก์ชันแรกที่
เพื่อจะให้รู้ว่าตรงนี้เป็นส่วนของ
เราเรียกการใช้ฟังก์ชันนี้ ก็เลย
ฟังก์ชันแรกของเรา
ชื่อว่า hello ใช่ไหมคะ แล้วตามด้วยเครื่องหมายวงเล็บ
ตรงนี้เราจะเรียกใช้ฟังก์ชันที่เราสร้างแล้วนะ calling
calling นะคะ calling ก็
ทีนี้เราไม่อยากใส้ Danny เราใส่ชื่อเราเองไปก็ได้
ก็ได้นะคะ
เครื่องหมายคำพูด
หรือ Double Quote นะคะ name
เราจะเรียกใช้ชื่อ ก็คือเวลาจะเรียกใช้มัน
พิมพ์ชื่อฟังก์ชันนั้นนะคะ พิมพ์ hello เลยนะคะ
สมมติ
เรียกฟังก์ชัน hello ไปแล้ว ฟังก์ชันต่อมา
นะคะ เห็นไหมคะ มันจะขึ้นมาบอกเลย name
name คืออะไร name ในที่นี้ ในตัวอย่าง ก็คือ Danny นะคะ
เราอยากให้มันแสดงค่าพื้นที่
นะคะ ก็เลยใช้คำสั่ง
ชื่อนึกออกนะ เช่น
เนื่องจาก name เป็น string อย่าลืมใส่เ
ทำให้ดูก่อน
p-r-i-n-t
ใส่ชื่อเราแทน Danny ก็ได้นะคะเด็ก ๆ
ตำแหน่งของฟังก์ชันชิดนะคะ
ไม่วรรคนะคะ นี่ ไม่ต้อง Tab เข้าไปนะ
จะใส่ชื่อเล่นหรือชื่อจริง
ก็ได้ แล้วแต่นะคะ
ที่เราจะเรียกใช้นะคะ
ก็คือ area() แต่ area() ที่เรา
ด้วยแสดงคำว่า
เป็นข้อความนะคะ เพราะฉะนั้น
print ก่อน แล้วไปเรียกฟังก์ชัน
นั้นไว้ใน print นะคะ ให้ print แสดงนะคะ ดูตัวอย่าง
สี่เหลี่ยม
ลืมแก้ภาษาขอโทษที
ใส่เครื่องหมายเท่ากับนะคะ เปลี่ยนภาษา
ตัวที่ 2 นะคะ
เปอร์เซ็นต์แล้วก็ d
แล้วหลังเครื่องหมายคำพูด
เราจะใช้คำสั่ง print
ฟังก์ชันนะคะ เพื่อให้แสดงแล้วก็เรียกใช้ฟังก์ชัน
แล้วก็
พิมพ์ฟังก์ชัน area a-
เมื่อเป็นข้อความ พิมพ์เป็นภาษาไทยก็ได้
ไม่ต้องใช้คำว่า "area" ในภาษาอังกฤษ ก็คือพื้นที่
e-a นะคะ
แล้วก็วงเล็บ
=
เอามากกว่านั้นก็ได้นะ
ในตัวอย่างบอกว่าความกว้าง คือ 8 ความสูง คือ 4
ก่อน =
%d นะคะ %d เท่ากับ แล้วก็
ความสูง 4 นี่ความสูงนี้
เท่าไหร่ ตอนนี้เราพิมพ์คำสั่งหรือโค้ด
ตามด้วย % แล้วเรียกใช้
ฟังก์ชัน area นะคะ ตามด้วยเครื่องหมายเปอร์เซ็นต์
จะแสดงผลอย่างไร
Error เด้งขึ้นมา ณบัด Now
r ปุ๊บ ขึ้นหรือยัง
A-r-
เกิดอะไรขึ้น
print
ทีนี้ใส่ Argument
ให้ 2 ตัว ก็คือ 8 นะคะ กว้าง 8
ตัวแปร ตัวแปรผิด เดี๋ยวนะ ค่อย ๆ ไล่นะคะ
ถ้าพื้นที่ที่มี
ความกว้าง พื้นที่สี่เหลี่ยมที่มีความกว้าง 8
สังเกตนะคะ เมื่อขึ้น Error
เด็ก ๆ ดู เห็นไหม มันจะชี้ไปที่บรรทัดผิด
เสร็จหมดแล้วนะคะ
เด็ก ๆ ลองกด Play ดูได้เลยนะคะ ถ้าใครพิมพ์เสร็จแล้ว
เสร็จแล้ว
มันบอกว่าในบรรทัดที่
บรรทัดที่ 9
ไม่อยู่ใน Index
S ตัวใหญ่หรือ s เล็กใช่ไหม ขอโทษที
แก้ได้ ๆ
เห็นไหมคะ
พอขยายแล้วของตัวเองก็เล็ก
แบบนี้นะ เดี๋ยว
แม่ไม่ได้ดู s มันเป็นตัวมหญ่ตาม
คือ ไอ้พวก % d % อะไรนี่
พิมพ์ตัวแปรผิดหรือ ฟังก์ชันชื่อฟังก์ชัน
ถูกแล้วนะ hello ถูกต้องนะคะ
ตัวพิมพ์เล็เกแค่นั้นเอง
2 % name
value error ค่า error ตรง...
พอมาไล่ฟังก์ชัน
พิมพ์ s ผิดใช่ไหมนี่
%s
%s' name
เมื่อกี้ตรงลืมพล็อต
ให้ดูก่อน เมื่อกี้ตอนแม่พิมพ์ %s
ย้อนกลับไปดู อ๋อ s ฉันพิมพ์ผ
ฉันต้องพิมพ์เป็นตัวเล็กนะคะ พอแม่แก้
พิมพ์เล็กมันไม่ใช่ตัวพิมพ์ใหญ่ แม่ไปพิมพ์ใหญ่
ถ้าเด็ก ๆ ผิดตำแหน่งนี้ แก้แค่ตัว S จากตัวพิมพ์ใหญ่ เป็น
มันก็จะแสดงขึ้นมา เห็นไหม มันก็จะพิมพ์คำว่า...
มันก็จะไปเรียกใช้ ไอ้ตัวนี้
การขึ้น Error นะ เดี๋ยวแก้ให้ดูนะคะ
ที่จะให้มันแสดงแต่
ตอนที่ทำงานน่ะ มันมาทำงานที่ตัวนี้เห็นไหมคะ
มันจะขึ้นลูกศรชี้ไปที่บรรทัดไหน นั่นหมายความว่า
มันหมายความผิดพลาดที่
คำว่า "print" ไว้
พอเวลามาเรียกใช้เธอ เราก็เลยมาพิมพ์คำว่า...
ตรง value error เห็นไหม ค่าที่มัน error ค่ามัน
อยู่ที่คำว่า s อ๋อ
สามเหลี่ยม 8 x 4 = 32 ถูกต้องนะคะ
มันก็จะส่งค่า c ที่มาคำ
จากตัวใหญ่เป็นตัวเล็ก
เรากด Play น่ะ Error มันก็หาย แล้วผลลัพธ์
พื้นที่ สี่เหลี่ยม
ของเรานี่นะคะ มีค่า =
ออกมาเลย ทั้ง ๆ ที่ ตอนเรียกนี่ เราพิมพ์แค่
ฟังก์ชัน แล้วก็ตามด้วยค่า Argument
แสดงทศนิยมออกมานะคะ
ลองดูอีกสักตัวอย่างหนึ่งไหมคะ
ตัวคำว่า "print" แต่ตรง area นี่
นะคะ ตรงฟังก์ชัน area
เด็ก ๆ ลองนะคะ ทีนี้ให้
ใส่ชื่อเล่นตัวเองลงไป
มีแถมตัว r มาจากไหนนี่
สามเหลี่ยม = %d'
มาแสดงตรงนี้เห็นไหมคะ
เป็น 32 นะคะ มันก็เลย print คำว่า "
เห็นไหมคะ มันจะขึ้นมาเป็น
%d นั่นหมายถึง
ให้แสดงเป็นเลขจำนวณเต็มนี่
ไม่แน่ใจว่ามันจะไปเรียกใช้ได้อีกไหม
มันจะไปเรียกใช้ได้อีกไหม
ลอง ลองเรียกใช้
ฟังก์ชัน hello อีกนะคะ
ไม่ได้ไปเรียกต่อจากเมื่อกี้
ลองพิมพ์ฟังก์ชัน hello ที่เราสร้างไว้
เอาแต่ hello อย่างเดียวให้เห็น
ใส่ชื่อเล่นเรานะ
ลองดูสิ มันจะขึ้นอย่างไร ลองดูนะคะ
ตัวต่อไปอันนี้ไม่มันก็จะ
ทำซ้ำไง เพราะเรายังอยู่ในตัวเดิมนะ
มีตัวใหม่ใช่ไหม แล้วลองเรียกใหม่
จากโค้ดที่เราเพิ่มเข้ามา ลองเรียกนะคะ
ก่อนหน้า ลืมแก้ภาษาอีกแล้ว
พิมพ์เรียกใช้ฟังก์ชัน
ทีนี้ลองใส่ชื่อเล่น
หลาย ๆ คน ใส่ชื่อเพื่อนลงไปด้วยสัก 3 คน
เพราะบอกแล้วว่า Argument นะคะ
มีกี่คนก็ได้ ลองสิขึ้นไหม
ตัวเดียว แต่เราไปใส่หลายตัวนะคะ มันจะใส่ได้
ตามจำนวนพารามิเตอร์ด้วยนะคะ เพราะฉะนั้น ในกรณีนี้
ให้มันมีหลายคนนะคะ เราต้องไปแก้ที่ฟังก์ชันเรา
แล้วลอง ลองมาใส่ที่ตัวนี้ใหม่
Syntax error เพราะอะไรคะ
เพราะไอ้ตัวนี้มันมีพารามิเตอร์ใ
ถ้าเราจะเพิ่มให้มันมีหลายคน
ถ้าเราจะเพิ่ม
เข้าใจแล้ว
แสดงว่าไม่เรียก อ๋อ
มัน มันข้ามไปสร้างตัวใหม่
Type Error ชนิดไม่ถูกต้องนะคะ เพราะ
ฟังก์ชัน Hello เราน่ะ
เราไปใส่ 3 ก็คือถ้าเราต้องการให้มีหลายตค
ไปเพิ่มตัวนี้นะคะ เพิ่มขึ้น
ไปวิธีแก้ไม่ได้ยากเลยนะคะ
ถ้าจะ... เรามาเปลี่ยนที่ตัวฟังก์ชันหลัก
นี่คือเมื่อ... จำไว้เลยว่าเมื่อ
ตอนจะเรียกใช้แค่พิมพ์ชื่อ
นี่ไง ๆ มันขึ้นเตือนว่ามาว่า
Argument ลงไปแค่นั
มันชื่อนี้เวลาเราเรียกใช้มันนี่ เราเอามา
Position ให้แค่ 1 ตำแหน่ง
นะคะ ใน Argument แต่
มัน... พอมันโดนเรียกใช้นี่มันจะกลายเป็น
Argument แต่ตอนที่มันเป็นฟังก์ชันนี่
เพราะฉะนั้น
เราเอาฟังก์ชันนั้นมาใช้งาน สิ่งที่อยู่ใน
วงเล็บจะกลายเป็น
เพราะตอนเรีกยใช้ไอ้ตัวนี้มันเรียกแค่
ใช่หรือเปล่าอย่างนี้เป็นต้นนะคะ
นี่ นี่คือส่วนของการสร้าง
ฟังก์ชันและการเรียกใช้ฟังก์ชันนะคะ มาดูหัวข้อ
แล้วในวงเล็บนี่ เราพิมพ์
ค่าของ... เขาเรียกว่า "
เหลืออีก 2 หัวข้อ
เดี๋ยวนะ เดี๋ยวนะ
ทั้งชื่อฟังก์ชันกับวงเล็บ แต่สิ่งที่อยู่ใน
วงเล็บนี่ ก็คือเราใส่เข้าไปได้เลย
โอเค
ตรงในวงเล็บนี่คือ
หรือตัวแปรที่จะไว้รับค่านะคะ แต่พอ
คืออะไร มันเป็นการกำหนด
Default Argument นี่
รับเข้าไปนั่นเอง
นะคะ
ค่าที่เราจะส่งเข้ามาในฟังก์ชันตอนแรกนะ
ทำให้สามารถเรียกใช้งานฟังก์ชัน
ต่อมาของเราก่อนดีกว่านะคะ เดี๋ยวเด็ก ๆ จะได้
ไปเดินงานวันวิทยาศาสตร์ต่อ
เห็นไหม
นี่นะคะ ในตัวอย่างนี่ สร้างฟังก์ชัน
สลับหน้าจอก่อนไม่สลับไม่ได้
เห็นไหม ใส่ Argument เข้าไปด้วยเลย มี พ
Salary มี Argument =
ดูส่วนต่อมานะคะ ส่วนที่เรียกว่า