ข้ามไปยังเนื้อหาหลัก

ฟังก์ชันใน Python: วิธีเรียกใช้และเขียนฟังก์ชัน

ค้นพบวิธีเขียนฟังก์ชัน Python ที่นำกลับมาใช้ซ้ำและมีประสิทธิภาพ เชี่ยวชาญพารามิเตอร์ คำสั่ง return และหัวข้อขั้นสูงอย่างฟังก์ชันแลมบ์ดา จัดโค้ดให้เป็นระเบียบยิ่งขึ้นด้วย main() และแนวปฏิบัติที่ดีอื่น ๆ
· 14 นาที อ่าน

สำรวจด้วย AI

แบนเนอร์ทักษะ Python เพื่อสร้างอาชีพกับ DataCamp

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

บทช่วยสอนนี้ใช้ไวยากรณ์ Python 3 ตัวอย่างทั้งหมดทำงานบน Python 3.10+ และได้รับการอัปเดตให้สะท้อนแนวปฏิบัติสมัยใหม่แล้ว (f-strings, type hints, พารามิเตอร์แบบ positional-only และ keyword-only) เวอร์ชันเสถียรปัจจุบันคือ Python 3.14

หากต้องการรันโค้ดตัวอย่างทั้งหมดในบทช่วยสอนนี้ได้อย่างง่ายดาย สามารถสร้างสมุดงาน DataLab ได้ฟรี ที่ติดตั้ง Python ไว้ล่วงหน้าและมีโค้ดตัวอย่างทั้งหมด สำหรับการฝึกเขียนฟังก์ชัน Python เพิ่มเติม ลองดูแบบฝึกหัดเชิงปฏิบัติของ DataCamp นี้ หรือเรียนคอร์ส Python Data Science Toolbox!

ฟังก์ชันใน Python

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

ใน Python มีฟังก์ชันอยู่สามประเภท:

  • ฟังก์ชันที่มีมาให้แล้ว (Built-in) เช่น help() เพื่อขอความช่วยเหลือ, min() เพื่อหาค่าต่ำสุด, print() เพื่อพิมพ์วัตถุไปยังเทอร์มินัล เป็นต้น สามารถดูภาพรวมของฟังก์ชันเหล่านี้เพิ่มเติมได้ ที่นี่

  • ฟังก์ชันที่ผู้ใช้กำหนดเอง (User-Defined Functions: UDFs) คือฟังก์ชันที่ผู้ใช้สร้างขึ้นเพื่อช่วยงานของตน และ

  • ฟังก์ชันนิรนาม ซึ่งเรียกอีกอย่างว่าฟังก์ชันแลมบ์ดา เพราะไม่ได้ประกาศด้วยคีย์เวิร์ดมาตรฐาน def

ฟังก์ชัน vs เมธอด

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

พิจารณาตัวอย่างนี้ ที่กำหนดฟังก์ชัน plus() ก่อน จากนั้นกำหนดคลาส Summation พร้อมเมธอด sum():

# Define a function `plus()`
def plus(a,b):
  return a + b
  
# Create a `Summation` class
class Summation(object):
  def sum(self, a, b):
    self.contents = a + b
    return self.contents 

หากต้องการเรียกใช้เมธอด sum() ที่เป็นส่วนหนึ่งของคลาส Summation จะต้องนิยามอินสแตนซ์หรืออ็อบเจ็กต์ของคลาสนั้นก่อน มาสร้างอ็อบเจ็กต์ดังกล่าวกัน:

# Instantiate `Summation` class to call `sum()`
sumInstance = Summation()
sumInstance.sum(1,2)

จำไว้ว่าการสร้างอินสแตนซ์นี้ไม่จำเป็นเมื่อจะเรียกใช้ฟังก์ชัน plus() สามารถรัน plus(1,2) ในส่วนโค้ด DataCamp Light ได้โดยไม่มีปัญหา!

พารามิเตอร์ vs อาร์กิวเมนต์

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

พิจารณาตัวอย่างต่อไปนี้และย้อนกลับไปดูส่วน DataCamp Light ด้านบน: คุณส่งอาร์กิวเมนต์สองตัวไปยังเมธอด sum() ของคลาส Summation แม้ว่าก่อนหน้านี้จะกำหนดพารามิเตอร์ไว้สามตัว ได้แก่ self, a และ b

self หายไปไหน?

อาร์กิวเมนต์ตัวแรกของเมธอดในคลาสทุกตัวจะเป็นการอ้างอิงไปยังอินสแตนซ์ปัจจุบันของคลาส ซึ่งในที่นี้คือ Summation ตามธรรมเนียมจะเรียกอาร์กิวเมนต์นี้ว่า self

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

วิธีนิยามฟังก์ชัน: ฟังก์ชันที่ผู้ใช้กำหนดเอง (UDFs)

สี่ขั้นตอนในการนิยามฟังก์ชันใน Python มีดังนี้:

  1. ใช้คีย์เวิร์ด def เพื่อประกาศฟังก์ชัน แล้วตามด้วยชื่อฟังก์ชัน

  2. เพิ่มพารามิเตอร์ให้กับฟังก์ชัน: ควรอยู่ในวงเล็บของฟังก์ชัน ลงท้ายบรรทัดด้วยโคลอน

  3. เพิ่มคำสั่งที่ฟังก์ชันควรดำเนินการ

  4. จบฟังก์ชันด้วยคำสั่ง return หากฟังก์ชันต้องการส่งผลลัพธ์ออกมา หากไม่มีคำสั่ง return ฟังก์ชันจะคืนค่าเป็นอ็อบเจ็กต์ None

def hello():
  print("Hello World") 
  return 

แน่นอนว่าเมื่อทำไป ฟังก์ชันจะซับซ้อนขึ้น: สามารถเพิ่ม for loop การควบคุมโฟลว์ ฯลฯ เพื่อให้ละเอียดขึ้นได้:

def hello():
    name = input("Enter your name: ")
    if name:
        print(f"Hello {name}")
    else:
        print("Hello World")

hello()

ในฟังก์ชันข้างต้น จะให้ผู้ใช้กรอกชื่อ หากไม่มีการกรอกชื่อ ฟังก์ชันจะพิมพ์ “Hello World” มิฉะนั้น ผู้ใช้จะได้รับคำทักทายแบบระบุชื่อ

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

คำสั่ง return

สังเกตว่าเนื่องจากพิมพ์บางอย่างใน UDF hello() อยู่แล้ว จึงไม่จำเป็นต้องคืนค่า จะไม่เห็นความแตกต่างระหว่างฟังก์ชันด้านบนกับฟังก์ชันนี้:

def hello_noreturn():
  print("Hello World") 

อย่างไรก็ตาม หากต้องการทำงานต่อกับผลลัพธ์ของฟังก์ชันและลองทำโอเปอเรชันกับมัน จะต้องใช้คำสั่ง return เพื่อคืนค่าจริง เช่น สตริง จำนวนเต็ม เป็นต้น พิจารณาสถานการณ์ต่อไปนี้ ซึ่ง hello() คืนค่าสตริง "hello" ในขณะที่ฟังก์ชัน hello_noreturn() คืนค่า None:

def hello():
  print("Hello World") 
  return("hello")

def hello_noreturn():
  print("Hello World")
  
# Multiply the output of `hello()` with 2 
hello() * 2

# (Try to) multiply the output of `hello_noreturn()` with 2 
hello_noreturn() * 2

ฟังก์ชันที่สองจะเกิดข้อผิดพลาดเพราะไม่สามารถทำโอเปอเรชันใด ๆ กับ None ได้ จะได้รับ TypeError ระบุว่าไม่สามารถทำการคูณระหว่าง NoneType (None ที่เป็นผลจาก hello_noreturn()) กับ int (2)