【คัดลอกและวางเพื่อรัน】คอร์สสอนสร้างฟังก์ชัน Python ฉบับสมบูรณ์: จากพื้นฐาน def สู่การประยุกต์ใช้

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

เวลาสร้างเว็บไซต์หรือพัฒนาแอปพลิเคชัน คุณเคยเจอปัญหาแบบนี้ไหมครับ "เอ๊ะ, โค้ดส่วนนี้เพิ่งเขียนไปเมื่อกี้นี่นา..." ปัญหา "การเขียนโค้ดซ้ำซ้อน" แบบนี้สามารถแก้ไขได้อย่างหมดจดด้วยสิ่งที่เราจะมาแนะนำกันในวันนี้ นั่นคือ "ฟังก์ชัน (function)" ของ Python ครับ

ในบทความนี้ เราจะอธิบายตั้งแต่วิธีการสร้างฟังก์ชัน Python ขั้นพื้นฐานไปจนถึงเทคนิคการประยุกต์ใช้ที่สะดวกสบาย พร้อมตัวอย่างโค้ดมากมายที่แม้แต่ผู้เริ่มต้นเขียนโปรแกรมก็สามารถเรียนรู้ตามได้อย่างสบายใจ คีย์เวิร์ดสำคัญคือ "คัดลอกและวางเพื่อรัน" ทิ้งทฤษฎียากๆ ไว้ก่อน แล้วมาสัมผัสความสนุกที่ได้เห็นโค้ดของตัวเอง "ทำงานได้จริง" กันดีกว่าครับ!

ว่าแต่ "ฟังก์ชัน" ของ Python คืออะไรกันนะ?

วิธีที่ง่ายที่สุดในการจินตนาการถึงฟังก์ชัน อาจจะเป็น "ตู้ขายของอัตโนมัติ" ครับ

• ใส่เงินเข้าไป (อาร์กิวเมนต์) แล้วกดปุ่ม (เรียกใช้ฟังก์ชัน) จากนั้น...
• เครื่องดื่มก็จะออกมา (ค่าที่ส่งกลับ)

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

ใน Python เราจะสร้างฟังก์ชันเหล่านี้โดยใช้คำสั่งที่เรียกว่า def (คำสั่ง def) เรามาดูวิธีสร้างแบบเจาะลึกกันเลยดีกว่า!

【พื้นฐาน】วิธีสร้างและใช้งานฟังก์ชัน Python

มาเริ่มจากพื้นฐานกันก่อนเลยครับ เราจะสร้างฟังก์ชันที่ง่ายที่สุดที่ไม่มีทั้งอาร์กิวเมนต์และค่าที่ส่งกลับ

1. ไวยากรณ์พื้นฐาน: การกำหนดฟังก์ชันด้วย def

ในการสร้างฟังก์ชัน เราจะเริ่มต้นด้วยการเขียนในรูปแบบ def ชื่อฟังก์ชัน(): และในบรรทัดถัดไปให้ทำการย่อหน้า (indentation) แล้วเขียนโค้ดที่ต้องการให้ทำงาน ในที่นี้เราจะสร้างฟังก์ชันง่ายๆ ชื่อว่า say_hello ที่ทำหน้าที่แค่แสดงผลคำว่า "สวัสดี!"

# 1. การกำหนดฟังก์ชัน
def say_hello():
  print("สวัสดี!")

# 2. การเรียกใช้ฟังก์ชัน
say_hello()

ผลลัพธ์การทำงาน:

สวัสดี!

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

2. ลองใช้อาร์กิวเมนต์ (Argument) กันเถอะ

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

ในที่นี้ เราจะสร้างฟังก์ชันชื่อ greet ที่ทำหน้าที่ทักทายตามชื่อที่ได้รับมา การใส่ชื่อตัวแปร (ในกรณีนี้คือ name) ไว้ในวงเล็บ เช่น def greet(name): จะทำให้มันกลายเป็นอาร์กิวเมนต์

# กำหนดฟังก์ชันที่รับอาร์กิวเมนต์
def greet(name):
  print(f"สวัสดีครับ, คุณ{name}!")

# ส่งค่าที่ต้องการเป็นอาร์กิวเมนต์เมื่อเรียกใช้ฟังก์ชัน
greet("สมชาย")
greet("สมศรี")

ผลลัพธ์การทำงาน:

สวัสดีครับ, คุณสมชาย!
สวัสดีครับ, คุณสมศรี!

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

3. รับผลลัพธ์ด้วยค่าที่ส่งกลับ (Return Value)

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

เรามาสร้างฟังก์ชัน add ที่รับตัวเลข 2 ตัวแล้วส่งค่าผลบวกกลับไปกันครับ

# ฟังก์ชันที่รับอาร์กิวเมนต์ 2 ตัวและส่งค่าผลบวกกลับไป
def add(a, b):
  total = a + b
  return total # ใช้คำสั่ง return เพื่อส่งค่าผลลัพธ์กลับไป

# เรียกใช้ฟังก์ชันและเก็บค่าที่ส่งกลับไว้ในตัวแปร result
result = add(5, 3)

print(f"ผลลัพธ์ของ 5 + 3 คือ {result}")

ผลลัพธ์การทำงาน:

ผลลัพธ์ของ 5 + 3 คือ 8

เมื่อ add(5, 3) ทำงาน, total = 8 จะถูกคำนวณภายในฟังก์ชัน และค่า 8 นั้นจะถูกส่งกลับโดยคำสั่ง return ไปยังส่วนที่เรียกใช้ฟังก์ชัน จากนั้นค่า 8 ที่ส่งกลับมาก็จะถูกเก็บไว้ในตัวแปร result

การใช้ return แทนที่จะใช้ print() เพื่อแสดงผลโดยตรง ทำให้เราสามารถนำผลลัพธ์ที่ได้ไปใช้ในการประมวลผลอื่นๆ ต่อไปได้ ซึ่งสะดวกอย่างยิ่ง

【ประยุกต์】การใช้งานฟังก์ชันที่สะดวกยิ่งขึ้น

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

1. อาร์กิวเมนต์เริ่มต้น (Default Arguments): ไม่มีอาร์กิวเมนต์ก็ไม่เป็นไร!

บางครั้งในการเรียกใช้ฟังก์ชัน เราอาจต้องการละเว้นการส่งอาร์กิวเมนต์บางตัว ในสถานการณ์เช่นนี้ "อาร์กิวเมนต์เริ่มต้น" จะมีประโยชน์มากครับ เราสามารถกำหนดค่าเริ่มต้นไว้ล่วงหน้าในรูปแบบ def ชื่อฟังก์ชัน(ชื่ออาร์กิวเมนต์="ค่าเริ่มต้น"):

# กำหนดค่าเริ่มต้น "th" ให้อาร์กิวเมนต์ตัวที่สอง lang
def greet_language(name, lang="th"):
  if lang == "ja":
    message = f"{name}さん、こんにちは！" # สวัสดีครับ/ค่ะ, คุณ{name}! ในภาษาญี่ปุ่น
  elif lang == "en":
    message = f"Hello, {name}!"
  elif lang == "th":
    message = f"สวัสดีครับ/ค่ะ, คุณ{name}!"
  else:
    message = "ไม่ได้ระบุภาษา"
  
  return message

# ละเว้นอาร์กิวเมนต์ตัวที่สอง (จะใช้ค่าเริ่มต้น "th" แทน)
print(greet_language("มานะ"))

# ระบุอาร์กิวเมนต์ตัวที่สอง
print(greet_language("John", lang="en"))

ผลลัพธ์การทำงาน:

สวัสดีครับ/ค่ะ, คุณมานะ!
Hello, John!

เมื่อเรียกใช้ greet_language("มานะ") โดยละเว้นอาร์กิวเมนต์, จะมีการใช้ค่า lang="th" โดยอัตโนมัติ ทำให้แสดงผลคำทักทายเป็นภาษาไทย สะดวกมากเลยใช่ไหมครับ

2. อาร์กิวเมนต์คีย์เวิร์ด (Keyword Arguments): ไม่ต้องกังวลเรื่องลำดับ

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

def create_user_profile(name, age, country):
  return f"ชื่อ: {name}, อายุ: {age} ปี, ประเทศ: {country}"

# ระบุอาร์กิวเมนต์ตามลำดับ
profile1 = create_user_profile("สมศักดิ์", 30, "ไทย")
print(profile1)

# ใช้อาร์กิวเมนต์คีย์เวิร์ดเพื่อสลับลำดับ
profile2 = create_user_profile(country="อเมริกา", name="Emily", age=25)
print(profile2)

ผลลัพธ์การทำงาน:

ชื่อ: สมศักดิ์, อายุ: 30 ปี, ประเทศ: ไทย
ชื่อ: Emily, อายุ: 25 ปี, ประเทศ: อเมริกา

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

【มุมทดลอง】ฟังก์ชัน Python ที่ทำงานบนเบราว์เซอร์

สุดท้ายนี้ สำหรับนักสร้างเว็บทุกคน เรามาลองรัน Python ด้วยไฟล์ HTML เพียงไฟล์เดียวกันดูครับ! คัดลอกโค้ดทั้งหมดด้านล่างนี้ แล้วบันทึกเป็นไฟล์ชื่อ index.html จากนั้นลองเปิดด้วยเบราว์เซอร์ของคุณดู คุณจะได้เว็บแอปพลิเคชันง่ายๆ ที่สามารถสร้างคำทักทายจากข้อความที่คุณป้อนเข้าไป

นี่คือการใช้เทคโนโลยีที่เรียกว่า PyScript เพื่อรันโค้ด Python โดยตรงภายในไฟล์ HTML ไม่ต้องตั้งค่าอะไรให้ยุ่งยาก มาลองสัมผัสประสบการณ์ "คัดลอกและวางเพื่อรัน" กันได้เลยครับ!

<!DOCTYPE html>
<html lang="th">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>ทดลองใช้ฟังก์ชัน Python บนเบราว์เซอร์!</title>
  <!-- การโหลด PyScript -->
  <link rel="stylesheet" href="https://pyscript.net/releases/2024.1.1/core.css">
  <script type="module" src="https://pyscript.net/releases/2024.1.1/core.js"></script>
  <style>
    body { font-family: sans-serif; padding: 2em; line-height: 1.6; }
    input { padding: 8px; font-size: 1em; }
    button { padding: 8px 16px; font-size: 1em; cursor: pointer; }
    #output { margin-top: 1em; font-weight: bold; font-size: 1.2em; color: #2c3e50; }
  </style>
</head>
<body>

  <h1>เครื่องสร้างคำทักทาย</h1>
  <p>กรุณาใส่ชื่อของคุณแล้วกดปุ่ม</p>

  <input id="user-name" type="text" placeholder="ใส่ชื่อ...">
  <button py-click="generate_greeting">สร้างคำทักทาย</button>
  
  <div id="output"></div>

  <py-script>
    from pyscript import document

    # ★กำหนดฟังก์ชัน Python ที่นี่★
    def create_greeting_message(name):
      # ถ้าไม่มีชื่อ ให้ส่งคำทักทายเริ่มต้นกลับไป
      if not name:
        return "กรุณาใส่ชื่อของคุณ!"
      # ถ้ามีชื่อ ให้ส่งคำทักทายที่ใช้ชื่อนั้นกลับไป
      return f"ยินดีต้อนรับสู่โลกของเว็บ, คุณ{name}!"

    # ฟังก์ชันที่จะทำงานเมื่อปุ่มถูกคลิก
    def generate_greeting(event):
      # ดึงข้อมูลที่ผู้ใช้ป้อนจาก element input
      input_element = document.querySelector("#user-name")
      user_name = input_element.value
      
      # สร้างข้อความทักทายโดยใช้ฟังก์ชันที่กำหนดไว้ข้างบน
      message = create_greeting_message(user_name)
      
      # เขียนข้อความผลลัพธ์ลงใน element div เพื่อแสดงผล
      output_div = document.querySelector("#output")
      output_div.innerText = message
  </py-script>

</body>
</html>

ข้อควรระวังในการใช้ฟังก์ชัน

ฟังก์ชันมีประโยชน์อย่างมาก แต่ก็มีข้อควรระวังบางประการเพื่อให้ใช้งานได้อย่างถูกต้อง

1. การย่อหน้าสำคัญที่สุด!
   ใน Python การย่อหน้า (indentation) มีความหมายถึงบล็อกของโค้ด การประมวลผลที่ตามหลัง def จะต้องย่อหน้าด้วยจำนวนช่องว่างที่เท่ากันเสมอ (โดยทั่วไปคือ 4 ช่องว่าง) หากการย่อหน้าผิดพลาด จะทำให้เกิดข้อผิดพลาด (error)
2. ตั้งชื่อฟังก์ชันให้เข้าใจง่าย
   ควรตั้งชื่อฟังก์ชันให้สามารถเข้าใจได้ทันทีว่าฟังก์ชันนั้น "ทำอะไร" ตัวอย่างเช่น ชื่อที่มีคำกริยาอยู่ด้วยอย่าง add หรือ create_user_profile เป็นชื่อที่นิยมใช้กันทั่วไป ตัวอย่างที่ไม่ดีคือชื่ออย่าง function1 หรือ proc ที่ไม่สื่อถึงหน้าที่ของมัน
3. ทำความเข้าใจเรื่องขอบเขตของตัวแปร (Scope)
   ตัวแปรที่กำหนดขึ้นภายในฟังก์ชัน (ตัวแปรท้องถิ่น หรือ local variable) จะไม่สามารถใช้งานจากภายนอกฟังก์ชันนั้นได้ นี่เป็นกลไกสำคัญที่ช่วยป้องกันไม่ให้ฟังก์ชันส่งผลกระทบต่อโค้ดภายนอกโดยไม่ตั้งใจ

เรามาดูตัวอย่างของขอบเขตตัวแปรกันครับ

def my_function():
  # local_variable เป็นตัวแปรท้องถิ่นที่ใช้ได้เฉพาะภายใน my_function เท่านั้น
  local_variable = "นี่คือตัวแปรภายในฟังก์ชัน"
  print(local_variable)

# การเรียกใช้ฟังก์ชัน
my_function()

# การพยายามเข้าถึง local_variable จากภายนอกฟังก์ชันจะทำให้เกิดข้อผิดพลาด
# print(local_variable) # NameError: name 'local_variable' is not defined

ผลลัพธ์การทำงาน:

นี่คือตัวแปรภายในฟังก์ชัน

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

สรุป: ใช้ฟังก์ชันให้คล่อง แล้วก้าวสู่การเขียนโปรแกรมอีกระดับ!

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

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

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

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

หลังจากที่เข้าใจเรื่องฟังก์ชันแล้ว สนใจเรียนรู้วิธีจัดการข้อมูลแบบกลุ่มต่อไหมครับ? ในบทความถัดไปจะอธิบายอย่างละเอียดเกี่ยวกับ "ลิสต์ (list)" และ "ดิกชันนารี (dictionary)" ซึ่งเป็นโครงสร้างข้อมูลที่ใช้บ่อยที่สุดใน Python

ขั้นตอนต่อไป: เรียนรู้โครงสร้างข้อมูลของ Python เช่น List และ Dictionary