วิธีเรียกใช้ฟังก์ชันใน Python: สุดยอดคู่มือ

ฟังก์ชันเป็นแนวคิดที่สำคัญในการเขียนโปรแกรมที่ช่วยให้คุณสามารถจัดการและนำบล็อกโค้ดกลับมาใช้ใหม่ได้ การรู้วิธีเรียกใช้ฟังก์ชันใน Python เป็นทักษะสำคัญที่ต้องเรียนรู้

ในบทช่วยสอนนี้ คุณจะได้เรียนรู้พื้นฐานของการเรียกใช้ฟังก์ชัน พร้อมด้วยเคล็ดลับบางประการสำหรับการเขียนโค้ดที่มีประสิทธิภาพซึ่งง่ายต่อการเข้าใจ

ฟังก์ชันการเรียนรู้จะไม่เพียงช่วยให้คุณสร้างโค้ดที่หลากหลายมากขึ้น แต่ยังปรับปรุงกระบวนการเขียนโปรแกรมของคุณ และปรับปรุงประสิทธิภาพโดยรวมของคุณในฐานะนักพัฒนา

ฟังก์ชันมีหลักการพื้นฐานที่เหมือนกัน และเมื่อคุณเชี่ยวชาญฟังก์ชันใน Python แล้ว คุณจะสามารถขยายความเข้าใจเกี่ยวกับฟังก์ชันของคุณเมื่อเทียบกับภาษาโปรแกรมอื่นๆ เช่น Java, R, JavaScript, PHP เป็นต้น

สารบัญ

• ฟังก์ชั่นคืออะไร?
• การกำหนดฟังก์ชันใน Python
  • ไวยากรณ์ของฟังก์ชัน
  • พารามิเตอร์และอาร์กิวเมนต์
    • ข้อโต้แย้ง kwargs
• การเรียกใช้ฟังก์ชัน
  • การเรียกใช้ฟังก์ชันพื้นฐาน
  • อาร์กิวเมนต์ตำแหน่ง
  • อาร์กิวเมนต์คำหลัก
• คืนค่า
  • ค่าส่งคืนเดียว
  • ค่าส่งคืนหลายรายการ
• ส่งผ่านฟังก์ชัน Python เป็นอาร์กิวเมนต์
• ฟังก์ชันที่ซ้อนกัน
• ฟังก์ชันแลมบ์ดา
• การเรียกซ้ำ
• ข้อผิดพลาดทั่วไปและการแก้ไขปัญหา
• บทสรุป

ฟังก์ชั่นคืออะไร?

ฟังก์ชันใน Python ช่วยให้คุณสร้างโค้ดที่ใช้ซ้ำได้ซึ่งสามารถเรียกใช้ได้ตลอดทั้งโปรแกรม ทำให้โค้ดของคุณง่ายขึ้นและปรับปรุงความสามารถในการอ่าน มันทำงานเฉพาะหรือชุดของงานและสามารถเรียกได้หลายครั้งภายในโปรแกรม 

การกำหนดฟังก์ชันใน Python

มีสองประเภทหลักของฟังก์ชันใน Python:

• User-defined Functions:ฟังก์ชั่นที่โปรแกรมเมอร์กำหนดเพื่อหลีกเลี่ยงการทำซ้ำของรหัส
• ฟังก์ชันในตัว : ฟังก์ชันที่กำหนดโดยคนอื่นและสามารถใช้ในรหัสของคุณหลังจากติดตั้งแพ็คเกจที่จำเป็น

ส่วนนี้ของบทช่วยสอน Pythonมุ่งเน้นไปที่ฟังก์ชันที่ผู้ใช้กำหนด คุณจะได้เรียนรู้:

• วิธีกำหนดฟังก์ชันใน Python
• ไวยากรณ์ของฟังก์ชัน
• วิธีใช้พารามิเตอร์และอาร์กิวเมนต์

ไวยากรณ์ของฟังก์ชัน

คำdef หลัก ตามด้วยชื่อฟังก์ชันและวงเล็บ ช่วยให้คุณสามารถกำหนดฟังก์ชันใน Python ได้ เนื้อหาของฟังก์ชันถูกเยื้องและมีรหัสที่จะดำเนินการเมื่อเรียกใช้ฟังก์ชัน ตัวอย่างของฟังก์ชันพื้นฐานใน Python แสดงไว้ด้านล่าง:

def ทักทาย (): พิมพ์ ("สวัสดีชาวโลก!") ทักทาย ()

คำdef หลักกำหนดฟังก์ชันใหม่ด้วยชื่อทักทาย โค้ดบรรทัดที่สามเรียกใช้ฟังก์ชัน ซึ่งเรียกใช้โค้ดภายในฟังก์ชัน

บรรทัดprintในโค้ดด้านบนยังเป็นฟังก์ชัน อย่างไรก็ตาม หากคุณกำลังทำงานในสภาพแวดล้อม Python 2 ระบบจะกำหนดเป็นคำสั่ง ต่อมาใน Python 3 ได้เปลี่ยนจากคำสั่งเป็นฟังก์ชัน

พารามิเตอร์และอาร์กิวเมนต์

พารามิเตอร์คือตัวยึดตำแหน่งในนิยามของฟังก์ชัน ในขณะที่อาร์กิวเมนต์คือค่าที่ส่งผ่านเมื่อเรียกใช้ฟังก์ชัน

ในการระบุพารามิเตอร์ ให้รวมไว้ในวงเล็บของนิยามฟังก์ชัน โดยคั่นด้วยเครื่องหมายจุลภาคหากมีหลายพารามิเตอร์ เมื่อคุณเรียกใช้ฟังก์ชัน คุณต้องป้อนค่าอินพุตที่เรียกว่าอาร์กิวเมนต์ ตัวอย่างต่อไปนี้สาธิตการกำหนดฟังก์ชันที่รับพารามิเตอร์สองตัว:

def add_numbers(a, b): คืนค่า a+b

คำreturn สั่งในเนื้อความของฟังก์ชันจะส่งกลับการบวกของอาร์กิวเมนต์สองตัวที่ส่งผ่านเข้าไป คุณสามารถคิดว่ามันเป็นเครื่องคิดเลขที่คุณป้อนค่าและรับผลลัพธ์ที่ต้องการเป็นการตอบแทน

หลังจากกำหนดฟังก์ชันแล้ว เราสามารถเรียกมันด้วยอาร์กิวเมนต์ที่เราเลือกได้

add_numbers(3, 5)

ข้อโต้แย้ง kwargs

kwargs ย่อมาจาก “keyword arguments” ใน Python ช่วยให้คุณขยายความยืดหยุ่นของฟังก์ชันโดยอนุญาตให้ผู้เรียกระบุอาร์กิวเมนต์คำหลักจำนวนเท่าใดก็ได้เมื่อเรียกใช้ฟังก์ชัน อาร์กิวเมนต์คำหลักจะถูกส่งผ่านเป็นพจนานุกรมไปยังฟังก์ชัน

ในนิยามของฟังก์ชัน คุณสามารถใช้**ไวยากรณ์เครื่องหมายดอกจันคู่หน้าชื่อพารามิเตอร์เพื่อยอมรับอาร์กิวเมนต์ของคีย์เวิร์ด

def my_function(**kwargs): สำหรับคีย์ ค่าใน kwargs.items(): พิมพ์(f"{key} = {value}") my_function(a=1, b=2, c=3)

ในตัวอย่างนี้kwargs จะเป็นพจนานุกรมที่มีอาร์กิวเมนต์ของคีย์เวิร์ดที่ส่งผ่านไปยังฟังก์ชัน ผลลัพธ์จะแสดงในภาพด้านล่าง:

การเรียกใช้ฟังก์ชัน

การเรียกใช้ฟังก์ชันหมายถึงการรันโค้ดภายในเนื้อความของฟังก์ชัน การเรียกใช้ฟังก์ชันใน Python มีสี่ประเภท:

• การเรียกใช้ฟังก์ชันพื้นฐาน
• การโทรด้วยอาร์กิวเมนต์ตำแหน่ง
• การโทรด้วยอาร์กิวเมนต์คำหลัก

การเรียกใช้ฟังก์ชันพื้นฐาน

การเรียกใช้ฟังก์ชันพื้นฐานจะเรียกใช้ฟังก์ชันโดยไม่ผ่านอาร์กิวเมนต์ใดๆ ในฟังก์ชัน หลังจากกำหนดฟังก์ชันแล้ว คุณสามารถเรียกฟังก์ชันนั้นโดยใช้ชื่อตามด้วยวงเล็บ

หากฟังก์ชันไม่มีอาร์กิวเมนต์ใดๆ วงเล็บจะว่างเปล่า โค้ดด้านล่างเป็นตัวอย่างของฟังก์ชันพื้นฐาน

def welcome_message(): พิมพ์("ยินดีต้อนรับสู่ LuckyTemplates!") welcome_message()

การรันโค้ดด้านบนให้ผลลัพธ์ต่อไปนี้:

อาร์กิวเมนต์ตำแหน่ง

อาร์กิวเมนต์ตำแหน่งเป็นประเภทอาร์กิวเมนต์ที่พบมากที่สุด และจะถูกส่งผ่านไปยังฟังก์ชันในลำดับเดียวกับที่ระบุไว้ ต่อไปนี้เป็นตัวอย่างของการเรียกใช้ฟังก์ชันที่มีอาร์กิวเมนต์ระบุตำแหน่ง:

def welcome_message(ชื่อ): พิมพ์(f"ยินดีต้อนรับสู่ LuckyTemplates, {ชื่อ}!") welcome_message("John")

ในตัวอย่างข้างต้นฟังก์ชันwelcome_message()รับหนึ่งอาร์กิวเมนต์ nameเมื่อคุณเรียกใช้ฟังก์ชันนี้ด้วยอาร์กิวเมนต์Johnมันจะพิมพ์ข้อความถัดจากชื่อ

รหัสด้านบนให้ผลลัพธ์ต่อไปนี้:

อาร์กิวเมนต์คำหลัก

อีกวิธีในการส่งอาร์กิวเมนต์ไปยังฟังก์ชันคือการใช้อาร์กิวเมนต์ของคีย์เวิร์ด อาร์กิวเมนต์คีย์เวิร์ดทำให้คุณสามารถระบุชื่อของพารามิเตอร์พร้อมกับค่า ทำให้โค้ดอ่านง่ายขึ้น และลดโอกาสในการส่งอาร์กิวเมนต์ในลำดับที่ไม่ถูกต้อง 

ตัวอย่างด้านล่างใช้อาร์กิวเมนต์ของคีย์เวิร์ดเพื่อเรียกใช้welcome_messageฟังก์ชัน:

def welcome_message(ชื่อ, ข้อความ='ยินดีต้อนรับสู่ LuckyTemplates!'): พิมพ์(ข้อความ, ชื่อ) welcome_message(ชื่อ='Alice', ข้อความ='อรุณสวัสดิ์')

ในตัวอย่างนี้ เราได้กำหนดฟังก์ชันwelcome_message()ที่มีพารามิเตอร์ 2 ตัวคือnameและ messageพารามิเตอร์ข้อความมีอาร์กิวเมนต์เริ่มต้นเป็นWelcome to LuckyTemplates!เมื่อเรียกใช้ฟังก์ชัน เราใช้อาร์กิวเมนต์ของคีย์เวิร์ดเพื่อส่งค่า ส่งJohnผลให้เอาต์พุตWelcome to LuckyTemplates! John.

คืนค่า

เมื่อทำงานกับฟังก์ชัน คุณมักจะต้องการส่งคืนผลลัพธ์ของการดำเนินการภายในเนื้อหาของฟังก์ชันของคุณ ค่าที่ส่งกลับทำให้ฟังก์ชันสามารถส่งผลลัพธ์กลับไปยังผู้โทรได้ เมื่อเข้าใจวิธีการทำงานกับค่าส่งคืนเดียวและหลายค่า คุณสามารถปรับปรุงการทำงานของโปรแกรม Python ของคุณได้

ค่าส่งคืนเดียว

ฟังก์ชันค่าส่งคืนค่าเดียวจะคืนค่าหนึ่งค่าจากการดำเนินการในฟังก์ชัน

ตัวอย่างของฟังก์ชันค่าส่งคืนเดียวแสดงไว้ด้านล่าง:

def get_greeting(ชื่อ): ส่งคืน "สวัสดี" + ชื่อ + "!" ทักทาย = get_greeting ("อลิซ") พิมพ์ (ทักทาย)

ในตัวอย่างข้างต้น ฟังก์ชันget_greetingใช้ชื่อเมื่ออาร์กิวเมนต์ของฟังก์ชันคอมไพล์และส่งคืนคำทักทายส่วนตัว ค่าที่ส่งคืนจะถูกเก็บไว้ในคำทักทาย ตัวแปร และพิมพ์ไปยังคอนโซล

ค่าส่งคืนหลายรายการ

ในบางครั้ง คุณจะต้องส่งคืนค่ามากกว่าหนึ่งค่าจากฟังก์ชันใน Python เพื่อให้บรรลุเป้าหมายนี้ คุณสามารถใช้ทูเพิลหรือรายการเพื่อรวมค่าที่ส่งคืน

ต่อไปนี้เป็นตัวอย่างของฟังก์ชันค่าส่งคืนหลายค่าในภาษาโปรแกรม Python

def get_name_and_age(): return ("John", 30) name, age = get_name_and_age() พิมพ์(ชื่อ) พิมพ์(อายุ)

ในตัวอย่างนี้get_name_and_ageเป็นฟังก์ชันที่คืนค่าทูเพิลด้วยค่าสองค่า: a name และagean

คุณยังสามารถส่งคืนรายการค่าจากฟังก์ชันใน Python ฟังก์ชันด้านล่างแสดงรายการค่าส่งคืนจากฟังก์ชัน

def คำนวณพื้นที่ (ความสูง, ความกว้าง): ส่งคืน [ความสูง * ความกว้าง, (ความสูง * ความกว้าง) / 2] พื้นที่, สามเหลี่ยม_area = การคำนวณพื้นที่ (10, 5) พิมพ์ (พื้นที่) พิมพ์ (สามเหลี่ยม_พื้นที่)

ในกรณีนี้ ฟังก์ชันcalculate_areasจะรับอาร์กิวเมนต์ 2 ตัว คือ , heightและwidth, และส่งคืนรายการที่มีพื้นที่ของสี่เหลี่ยมผืนผ้าและพื้นที่ของสามเหลี่ยม

ส่งผ่านฟังก์ชัน Python เป็นอาร์กิวเมนต์

Python อนุญาตให้คุณส่งฟังก์ชันเป็นอาร์กิวเมนต์ไปยังฟังก์ชันอื่นๆ เมื่อฟังก์ชันยอมรับฟังก์ชันอื่นเป็นอาร์กิวเมนต์ จะเรียกว่าฟังก์ชันที่มีลำดับสูงกว่า

โค้ดด้านล่างเป็นตัวอย่างของการส่งผ่านฟังก์ชันไปยังฟังก์ชันอื่นใน Python:

def สแควร์ (x): ส่งคืน x * x def สองเท่า (x): ส่งคืน x * 2 def apply_func (func, x): ส่งคืน func (x) ผลลัพธ์ = apply_func (สแควร์, 5)

ฟังก์ชันที่ซ้อนกัน

ฟังก์ชันที่ซ้อนกันคือฟังก์ชันที่กำหนดภายในฟังก์ชันอื่น หรือที่เรียกว่าฟังก์ชันภายใน สิ่งเหล่านี้มีประโยชน์เมื่อสร้างการปิดและรหัสโมดูลาร์ 

หากต้องการสร้างฟังก์ชันซ้อน เพียงกำหนดฟังก์ชันภายในฟังก์ชันอื่น:

def outer_function(x, y): def inner_function(z): return x + y + z result = inner_function(3) return result # เรียกฟังก์ชันภายนอก พิมพ์(outer_function(1, 2))

ในตัวอย่างข้างต้น inner_function ถูกกำหนดไว้ภายใน outer_function ฟังก์ชันภายในสามารถเข้าถึงตัวแปรของฟังก์ชันภายนอกได้ ทำให้สามารถดำเนินการกับตัวแปรเหล่านั้นได้

ฟังก์ชันแลมบ์ดา

ฟังก์ชัน Lambda หรือที่เรียกว่าฟังก์ชันนิรนาม เป็นวิธีสร้างฟังก์ชันขนาดเล็กแบบใช้ครั้งเดียวใน Python ในโครงการวิทยาศาสตร์ข้อมูล คุณมักจะทำงานกับฟังก์ชัน Lambda เพื่อสร้างโครงสร้างข้อมูลและไปป์ไลน์ที่มีประสิทธิภาพ

หากต้องการสร้างฟังก์ชันแลมบ์ดา คุณสามารถใช้คีย์เวิร์ดแลมบ์ดาตามด้วยรายการอาร์กิวเมนต์ เครื่องหมายทวิภาค และนิพจน์ นิพจน์คือสิ่งที่ฟังก์ชันแลมบ์ดาจะส่งกลับเมื่อมีการเรียกใช้ ต่อไปนี้เป็นตัวอย่างของฟังก์ชันแลมบ์ดาใน Python:

เพิ่ม = แลมบ์ดา a, b: ผลลัพธ์ a + b = เพิ่ม (3, 4) พิมพ์ (ผลลัพธ์) # เอาต์พุต: 7

ในตัวอย่างข้างต้น เราได้สร้างฟังก์ชันแลมบ์ดาที่รับอาร์กิวเมนต์ 2 ตัว ( a และb) และส่งกลับผลรวม เรากำหนดฟังก์ชันแลมบ์ดานี้ให้กับตัวแปรaddชื่อ

แลมบ์ดามีประโยชน์ในสถานการณ์ต่อไปนี้:

• เป็นอาร์กิวเมนต์สำหรับฟังก์ชันที่มีลำดับสูงกว่า เช่น map(), filter() และ sorted()
• เป็นฟังก์ชันหลักเมื่อเรียงลำดับรายการหรือพจนานุกรม

ตัวอย่างต่อไปนี้สาธิตการใช้ตัวกรองฟังก์ชันลำดับที่สูงกว่า () กับแลมบ์ดา:

ตัวเลข = [1, 2, 3, 4, 5, 6, 7, 8, 9] even_numbers = รายการ(ตัวกรอง(แลมบ์ดา x: x % 2 == 0, ตัวเลข)) พิมพ์(even_numbers) # เอาต์พุต: [2, 4, 6, 8]

ในตัวอย่างนี้ เราใช้ฟังก์ชัน lambda เพื่อกำหนดเกณฑ์การกรองสำหรับฟังก์ชัน filter() ฟังก์ชันแลมบ์ดาตรวจสอบว่าตัวเลขเป็นเลขคู่หรือไม่ และฟังก์ชัน filter() จะส่งคืนรายการใหม่ที่มีเฉพาะเลขคู่

หากต้องการดูตัวอย่างว่าฟังก์ชันมีประโยชน์อย่างไรในสถานการณ์ต่างๆ ของวิทยาการข้อมูล โปรดดูวิดีโอด้านล่าง:

การเรียกซ้ำ

การเรียกซ้ำเป็นเทคนิคในการเขียนโปรแกรมที่ฟังก์ชันเรียกตัวเอง นี่เป็นวิธีที่มีประโยชน์ในการแก้ปัญหาที่ซับซ้อนโดยแยกย่อยออกเป็นปัญหาย่อยที่เหมือนกันและมีขนาดเล็กลง

เมื่อสร้าง recursive function คุณต้องคำนึงถึงสองสิ่ง: กรณีพื้นฐานและกรณี recursive 

• กรณีพื้นฐานคือเงื่อนไขที่หยุดการเรียกซ้ำ
• recursive case คือการที่ฟังก์ชันเรียกใช้ตัวเอง กรณีเรียกซ้ำทำหน้าที่เป็นตัววนซ้ำสำหรับฟังก์ชัน

ตัวอย่างต่อไปนี้แสดงฟังก์ชันเรียกซ้ำใน Python:

def แฟกทอเรียล(n): ถ้า n == 1: ส่งคืน 1 ส่งคืน n * แฟกทอเรียล(n - 1) แฟกทอเรียล(5)

ในตัวอย่างนี้ กรณีพื้นฐานคือ when n == 1และฟังก์ชันจะคืน1ค่า กรณีเรียกซ้ำเกิดขึ้นเมื่อ n ไม่เท่ากับ 1 และฟังก์ชันเรียกตัวเองn - 1ด้วย

ข้อผิดพลาดทั่วไปและการแก้ไขปัญหา

หากคุณเป็นโปรแกรมเมอร์มือใหม่ คุณมักจะพบข้อผิดพลาดเมื่อใช้งานฟังก์ชันต่างๆ เช่น ฟังก์ชันเรียกซ้ำและแลมบ์ดา ส่วนต่อไปนี้เน้นข้อผิดพลาดทั่วไปและเคล็ดลับในการแก้ปัญหาเพื่อช่วยให้คุณแก้ไขได้อย่างมีประสิทธิภาพ

1. TypeError: ไม่มีอาร์กิวเมนต์ที่จำเป็น : ข้อผิดพลาดนี้เกิดขึ้นเมื่อคุณไม่ได้ระบุจำนวนอาร์กิวเมนต์ที่ถูกต้องตามที่ฟังก์ชันคาดหวัง

def my_function(fname, lname): พิมพ์(fname, lname) # การโทรที่ถูกต้อง my_function("John", "Doe") # จะทำให้เกิดข้อผิดพลาด my_function("John")

ในการแก้ไขข้อผิดพลาดนี้ ตรวจสอบให้แน่ใจว่าคุณได้ส่งอาร์กิวเมนต์ไปยังฟังก์ชันของคุณในจำนวนที่ถูกต้อง

2. TypeError: ประเภทตัวถูกดำเนินการที่ไม่รองรับ ข้อผิดพลาดนี้อาจเกิดขึ้นเมื่อคุณพยายามใช้ตัวดำเนินการที่มีประเภทที่เข้ากันไม่ได้

def add_number(a, b): return a + b # ผลลัพธ์การโทรที่ถูกต้อง = add_number(5, 3) print(result) # จะทำให้เกิดข้อผิดพลาดเนื่องจากผลลัพธ์ args ไม่ถูกต้อง = add_number("5", 3) print(result)

หากต้องการแก้ไขข้อผิดพลาดนี้ ให้ตรวจสอบว่าฟังก์ชันของคุณจัดการกับประเภทข้อมูลที่ถูกต้อง และพิจารณาใช้การแคสต์ประเภทหากจำเป็น

3. NameError: ไม่ได้กำหนดชื่อ 'function_name' : ข้อผิดพลาดนี้แสดงว่าฟังก์ชันยังไม่ถูกกำหนดก่อนที่จะถูกเรียกใช้ 

# คำสั่งที่ถูกต้อง def ทักทาย(): พิมพ์("สวัสดี ที่นั่น!") ทักทาย() # คำสั่งที่ไม่ถูกต้อง ลาก่อน() def ลาก่อน(): พิมพ์("ลาก่อน!")

ในการแก้ไขข้อผิดพลาดนี้ ตรวจสอบให้แน่ใจว่าฟังก์ชันของคุณถูกกำหนดอย่างถูกต้องและคุณเรียกมันตามคำจำกัดความ

บทสรุป

เพื่อสรุปและช่วยให้คุณเข้าใจตรงกัน ประเด็นต่อไปนี้สรุปลักษณะสำคัญของการเรียกใช้ฟังก์ชันใน Python:

• ในการเรียกใช้ฟังก์ชัน ให้ใช้ชื่อฟังก์ชันตามด้วยวงเล็บ (เช่นfunction_name())
• หากฟังก์ชันรับอาร์กิวเมนต์ ให้ใส่อาร์กิวเมนต์ไว้ในวงเล็บ (เช่นfunction_name(arg1, arg2))
• คุณสามารถสร้างฟังก์ชันของคุณเองโดยใช้คีย์เวิร์ด def กำหนดขอบเขตของฟังก์ชันและอาร์กิวเมนต์ที่จำเป็น
• เมื่อเรียกใช้ฟังก์ชันที่ส่งคืนค่า คุณสามารถกำหนดผลลัพธ์ให้กับตัวแปรเพื่อใช้ในภายหลังได้ (เช่นresult = function_name(args))