เรียนเขียนโปรแกรมง่ายๆกับ Expert Programming Tutor วันนี้เราจะมาเข้าสู่บทFunction
ฟังก์ชั่นเป็นบล็อกของโค้ดซึ่งจะทำงานเฉพาะเมื่อมันถูกเรียกใช้งาน นักเรียนสามารถส่งผ่านข้อมูลหรือที่เรียกว่าพารามิเตอร์ไปยังฟังก์ชันได้ ฟังก์ชั่นสามารถส่งคืนข้อมูลออกมาเป็นผลลัพธ์
การสร้างฟังก์ชั่น
ใน Python ฟังก์ชั่นถูกกำหนดโดยใช้คำหลัก def
ตัวอย่าง
def my_function(): |
เรียกฟังก์ชั่น
ในการเรียกใช้ฟังก์ชันให้ใช้ชื่อฟังก์ชันตามด้วยวงเล็บ()
ตัวอย่าง
def my_function(): |
ผลลัพธ์
Hello from a function |
Arguments
ข้อมูลสามารถส่งผ่านไปยังฟังก์ชั่นเป็นอาร์กิวเมนต์ อาร์กิวเมนต์จะถูกระบุหลังชื่อฟังก์ชันภายในวงเล็บ() นักเรียนสามารถเพิ่มอาร์กิวเมนต์ได้เท่าที่นักเรียนต้องการเพียงแยกมันด้วยเครื่องหมายจุลภาค(,)
ตัวอย่างต่อไปนี้มีฟังก์ชั่นที่มีหนึ่งอาร์กิวเมนต์ (fname) เมื่อเรียกใช้ฟังก์ชันเราจะส่งผ่านชื่อแรกซึ่งใช้ภายในฟังก์ชันเพื่อปรินต์ชื่อเต็ม
def my_function(fname): my_function("Emil") |
ผลลัพธ์
Emil Refsnes |
พารามิเตอร์หรืออาร์กิวเมนต์?
พารามิเตอร์และอาร์กิวเมนต์สองตัวนี้สามารถเรียกใช้ได้เหมือนกัน ข้อมูลที่ส่งผ่านไปยังฟังก์ชั่น
ในรูปแบบของฟังก์ชั่น: พารามิเตอร์คือตัวแปรที่อยู่ภายในวงเล็บในคำจำกัดความของฟังก์ชัน อาร์กิวเมนต์คือค่าที่ส่งไปยังฟังก์ชันเมื่อมีการเรียกใช้
จำนวนอาร์กิวเมนต์
โดยค่าเริ่มต้นฟังก์ชันจะต้องถูกเรียกด้วยจำนวนอาร์กิวเมนต์ที่ถูกต้อง หมายความว่าหากฟังก์ชันของนักเรียนคาดว่าจะมี 2 ข้อขัดแย้ง นักเรียนต้องเรียกใช้ฟังก์ชันที่มี 2 ข้อขัดแย้งมานั่นเอง
ตัวอย่าง
ฟังก์ชันนี้คาดว่าจะมี 2 ข้อขัดแย้ง และรับ 2 ข้อขัดแย้งมา
def my_function(fname, lname): my_function("Emil", "Refsnes") |
ผลลัพธ์
Emil Refsnes |
หากนักเรียนลองเรียกใช้ฟังก์ชันด้วยอาร์กิวเมนต์ 1 หรือ 3 จะเกิด Error ขึ้น
ตัวอย่าง
ฟังก์ชันนี้คาดว่าจะมี 2 ข้อขัดแย้ง แต่รับมาเพียง 1
def my_function(fname, lname): |
Arbitrary Arguments, *args
หากนักเรียนไม่ทราบจำนวนอาร์กิวเมนต์ที่จะถูกส่งผ่านไปยังฟังก์ชันของนักเรียนให้เพิ่ม * ก่อนชื่อพารามิเตอร์ในนิยามฟังก์ชัน วิธีนี้ฟังก์ชั่นจะได้รับ tuple ของข้อขัดแย้งและสามารถเข้าถึงรายการตามที่กำหนดไว้
ตัวอย่าง
หากไม่ทราบจำนวนอาร์กิวเมนต์ให้เพิ่ม * หน้าชื่อพารามิเตอร์
def my_function(*kids): |
ผลลัพธ์
The youngest child is Linus |
อาร์กิวเมนต์ Arbitrary มักย่อให้เหลือเป็นชื่อ * args ใน Python
Keyword Arguments
นักเรียนยังสามารถส่งอาร์กิวเมนต์ด้วยไวยากรณ์ key = value วิธีนี้ลำดับของอาร์กิวเมนต์ไม่สำคัญ
ตัวอย่าง
def my_function(child3, child2, child1): |
ผลลัพธ์
The youngest child is Linus |
Arbitrary Keyword Arguments, **kwargs
หากนักเรียนไม่ทราบจำนวนอาร์กิวเมนต์ของkeyword argumentsที่จะถูกส่งผ่านไปยังฟังก์ชันของนักเรียน ให้เพิ่มเครื่องหมายดอกจันสองอัน** หน้าชื่อพารามิเตอร์ในนิยามฟังก์ชัน วิธีนี้ฟังก์ชั่นจะได้รับดิกชินนารีของการขัดแย้งและสามารถเข้าถึงรายการตามที่กำหนดไว้
ตัวอย่าง
หากไม่ทราบจำนวนอาร์กิวเมนต์ของkeyword arguments ให้เพิ่ม double ** ข้างหน้าชื่อพารามิเตอร์
def my_function(**kid): |
ผลลัพธ์
His last name is Refsnes |
Default Parameter Value
ตัวอย่างต่อไปนี้แสดงวิธีใช้ค่าพารามิเตอร์เริ่มต้น ถ้าเราเรียกใช้ฟังก์ชั่นโดยไม่มีอาร์กิวเมนต์มันจะใช้ค่าเริ่มต้น
def my_function(country = "Norway"): my_function("Sweden") |
ผลลัพธ์
I am from Sweden |
คำหลักที่อาร์กิวเมนต์มักย่อให้เป็นชื่อ kwargs ใน Python
Passing a List as an Argument
นักเรียนสามารถส่งประเภทข้อมูลใด ๆ ของการขัดแย้งไปยังฟังก์ชั่น (str, number, set, dictionary ฯลฯ ) และมันจะถือว่าเป็นชนิดข้อมูลเดียวกันภายในฟังก์ชั่น เช่น. ถ้าคุณส่ง List เป็นอาร์กิวเมนต์มันจะยังคงเป็น List เมื่อมันมาถึงฟังก์ชั่น
ตัวอย่าง
def my_function(food): |
ผลลัพธ์
apple |
การใช้คีย์เวิร์ด return
เพื่อให้ฟังก์ชันคืนค่าใช้คำสั่ง return
ตัวอย่าง
def my_function(x): print(my_function(3)) |
ผลลัพธ์
15 |
ผลลัพท์ที่ต้องการส่งกลับไปให้ส่วนที่เรียกฟังก์ชัน
The pass Statement
นิยามฟังก์ชันไม่สามารถมีเนื้อหาว่างเปล่าได้ แต่ถ้านักเรียนมีเหตุผลบางอย่างที่มีคำจำกัดความของฟังก์ชันที่ไม่มีเนื้อหาให้ใส่คำสั่ง pass เพื่อหลีกเลี่ยงการError
ตัวอย่าง
def myfunction(): |
recursion
Python รับฟังก์ชั่นการเรียกซ้ำซึ่งหมายความว่าฟังก์ชั่นที่กำหนดสามารถเรียกตัวเองได้ การเรียกซ้ำเป็นแนวคิดทางคณิตศาสตร์และการเขียนโปรแกรมทั่วไป มันหมายความว่าฟังก์ชั่นเรียกตัวมันเอง สะดวกที่นักเรียนสามารถวนซ้ำข้อมูลเพื่อให้ได้ผลลัพธ์ นักเรียนควรระมัดระวังอย่างมากกับการเรียกซ้ำเนื่องจากมันง่ายในการเขียนฟังก์ชั่นที่จะไม่ใช้หน่วยความจำหรือค่าประมวลผลจำนวนมากเกินไป อย่างไรก็ตามเมื่อการเรียกซ้ำการเขียนอย่างถูกต้องอาจเป็นวิธีการเขียนโปรแกรมที่มีประสิทธิภาพและสวยงามในทางคณิตศาสตร์
ในตัวอย่างนี้ tri_recursion () เป็นฟังก์ชันที่เราได้กำหนดให้เรียกตัวมันเอง ("recurse") เราใช้ตัวแปร k เป็นข้อมูลซึ่งจะลดลง (-1) ทุกครั้งที่เราเรียกเก็บข้อมูล การเรียกซ้ำจะสิ้นสุดลงเมื่อเงื่อนไขไม่มากกว่า 0 (เช่นเมื่อเป็น 0) สำหรับนักพัฒนาใหม่อาจต้องใช้เวลาพอสมควรกว่าจะได้ผลว่าทำงานได้อย่างไรวิธีที่ดีที่สุดในการหาคือการทดสอบและแก้ไข
ตัวอย่าง
def tri_recursion(k): print("\n\nRecursion Example Results") |
ผลลัพธ์
Recursion Example Results |
ในบทนี้ค่อนข้างที่จะกระชับ เเละตัวอย่างเยอะ บทนี้ไม่ยากอะไร เข้าใจได้ง่ายๆ ฝึกเขียนโค้ดบ่อยๆ จะสามารถพัฒนาตัวเองได้อีกเรื่อยๆครับ เป็นกำลังใจให้นะครับ
Tag ที่น่าสนใจ: python_functions programming_paradigm defining_functions calling_functions arguments_in_functions parameters_vs_arguments arbitrary_arguments_*args keyword_arguments arbitrary_keyword_arguments_**kwargs
หากมีข้อผิดพลาด/ต้องการพูดคุยเพิ่มเติมเกี่ยวกับบทความนี้ กรุณาแจ้งที่ http://m.me/Expert.Programming.Tutor
085-350-7540 (DTAC)
084-88-00-255 (AIS)
026-111-618
หรือทาง EMAIL: NTPRINTF@GMAIL.COM