ปลดล็อกพลังแห่ง
Modularity

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

เริ่มเรียนรู้เลย ทดลองเขียนโค้ด

ทำไมต้องใช้ Function?

การเขียนทุกอย่างในก้อนเดียว = หายนะ (Debug ยากมาก)

No Function

เขียน Code ยาวเหยียด ซ้ำซ้อน แก้ไขจุดหนึ่งกระทบไปหมด เหมือนสายไฟที่พันกันยุ่งเหยิง

With Function

แบ่งงานใหญ่เป็นงานย่อย (Sub-problems) เรียกใช้งานซ้ำได้ (Reusability) แก้ไขง่าย (Maintainability)

The Function Machine

Input ingredients
Process
Output (Return) cake

ฟังก์ชันเหมือนเครื่องจักร รับวัตถุดิบ -> ประมวลผล -> ส่งคืนผลลัพธ์

ส่วนประกอบของฟังก์ชัน

example.py
def solve_problem(param1, param2): # 1. Header
# 2. Body (Logic goes here)
result = param1 + param2
return result # 3. Output
# เรียกใช้งาน
ans = solve_problem(5, 10)
print(ans)

1. Header (หัวฟังก์ชัน)

เริ่มด้วย def ตามด้วยชื่อฟังก์ชัน และ Parameters (ตัวแปรรับค่า) ในวงเล็บ อย่าลืมเครื่องหมาย :

2. Body (เนื้อหา)

ส่วนของการคำนวณหรือตรรกะ ต้องมีการ Indentation (ย่อหน้า) เข้าไปเสมอ

3. Return (การส่งค่ากลับ)

สำคัญ! ใช้ return เพื่อส่งผลลัพธ์กลับไปให้ผู้เรียก
* ห้ามใช้ print ภายในฟังก์ชันคำนวณ (ยกเว้นโจทย์สั่ง)

Scope & Life Cycle

ตัวแปรก็มีอายุขัยและพื้นที่ของมัน เข้าใจเรื่องนี้เพื่อหลีกเลี่ยง Bug ยอดฮิต!

Global Scope

ตัวแปรที่ประกาศข้างนอก ทุกคนเห็น ทุกคนใช้ได้ (แต่ระวังพัง!)

Local Scope (Inside Function)

ตัวแปรในนี้ เกิดและตายในนี้
โลกภายนอกมองไม่เห็น!

x = 10 (Local)
Global_Var = 99

Shadowing

การตั้งชื่อตัวแปรใน Local ซ้ำกับ Global จะทำให้ Python มองเห็นแต่ตัว Local (บังตัว Global มิดเลย)

Best Practice

พยายามส่งค่าผ่าน Parameter เสมอ หลีกเลี่ยงการใช้ Global variable ถ้าไม่จำเป็น เพื่อลดความสับสน

def practice_makes_perfect():

Function Laboratory

ลองใช้งานฟังก์ชันจริงจากโจทย์ Level 1-3

เครื่องแปลงอุณหภูมิ (c_to_f)

สูตร: (C * 9/5) + 32

-100 100
32.00

Recursion: ฟังก์ชันเรียกตัวเอง

Recursion คือการแก้ปัญหาใหญ่ด้วยการแบ่งเป็นปัญหาย่อยที่หน้าตาเหมือนเดิม
ต้องประกอบด้วย 2 ส่วนสำคัญ:

  • 1. Base Case (จุดหยุด)

    เงื่อนไขที่จะทำให้ฟังก์ชันจบการทำงาน ถ้าลืม = Error (Stack Overflow)

  • 2. Recursive Case (เรียกซ้ำ)

    การเรียกตัวเองด้วยโจทย์ที่เล็กลงเรื่อยๆ จนกว่าจะถึง Base Case

ตัวอย่าง Factorial (n!)

def factorial(n):
  if n == 0: return 1 // Base Case
  else: return n * factorial(n-1) // Recursive

Visualizing Factorial(5)

Click "Start" to visualize
Challenge Level

Tower of Hanoi

เกมคลาสสิกที่ใช้หลักการ Recursion แก้ปัญหา
กติกา: ย้ายจานทั้งหมดจากเสาซ้ายไปเสาขวา โดยห้ามวางจานใหญ่ทับจานเล็ก

Moves: 0
Start
Temp
End

แนวคิด Recursion:

move(n, start, end, temp):
1. ย้าย n-1 ใบ ไปเสา temp
2. ย้ายใบใหญ่สุด ไปเสา end
3. ย้าย n-1 ใบ จาก temp ไป end