การใช้ฟังก์ชันใน Python: อธิบายการใช้ def อย่างละเอียดสำหรับผู้เริ่มต้น

1. def ใน Python คืออะไร

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

โครงสร้างพื้นฐานของคีย์เวิร์ด def

โครงสร้างพื้นฐานเป็นดังนี้:

def ชื่อฟังก์ชัน(อาร์กิวเมนต์1, อาร์กิวเมนต์2, ...):
    โค้ดดำเนินการ
    return ค่าที่ส่งกลับ

หลัง def ให้ระบุชื่อฟังก์ชัน และใส่อาร์กิวเมนต์ที่ต้องการในวงเล็บ แล้วตามด้วยโคลอน เนื้อหาของฟังก์ชันต้องเขียนด้วยการเยื้องบรรทัด (indent) หากต้องการส่งค่ากลับ ให้ใช้คำสั่ง return

2. โครงสร้างพื้นฐานและวิธีใช้งาน def

วิธีประกาศฟังก์ชันเบื้องต้น

การสร้างฟังก์ชันด้วย def ต้องระบุชื่อฟังก์ชัน รายการอาร์กิวเมนต์ และเนื้อหาโค้ด ตัวอย่างเช่น ฟังก์ชันง่าย ๆ ที่แสดงข้อความ “Hello, World!” มีดังนี้

def say_hello():
    print("Hello, World!")

ฟังก์ชันนี้จะพิมพ์ “Hello, World!” ลงบนคอนโซลเมื่อเรียกใช้ say_hello()

ความสำคัญของการเยื้องบรรทัด (Indentation)

ใน Python การเยื้องบรรทัด (indent) มีความสำคัญมาก โค้ดทั้งหมดภายในฟังก์ชันต้องเยื้องในระดับเดียวกัน การเยื้องใช้เพื่อแบ่งแยกบล็อกของโค้ด หากเยื้องผิดจะเกิดข้อผิดพลาดทันที

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

เรียกใช้ฟังก์ชันโดยใส่วงเล็บต่อท้ายชื่อฟังก์ชัน หากมีอาร์กิวเมนต์ ให้ระบุในวงเล็บด้วย

say_hello()

3. อาร์กิวเมนต์และค่าเริ่มต้นในฟังก์ชัน

อาร์กิวเมนต์ตามลำดับและอาร์กิวเมนต์แบบกำหนดชื่อ

ฟังก์ชันสามารถรับอาร์กิวเมนต์ ซึ่งแบ่งเป็น 2 แบบ คือ อาร์กิวเมนต์ตามลำดับ (positional) ซึ่งจะถูกส่งตามลำดับที่ระบุ กับอาร์กิวเมนต์แบบกำหนดชื่อ (keyword) ซึ่งระบุตามชื่อและสามารถระบุตำแหน่งใดก็ได้

def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

ในตัวอย่างนี้ greeting มีค่าเริ่มต้น ถ้าเรียก greet("Alice") จะแสดง “Hello, Alice!”

อาร์กิวเมนต์จำนวนไม่แน่นอน (Variable-length arguments)

บางครั้งฟังก์ชันอาจต้องรับอาร์กิวเมนต์จำนวนไม่แน่นอน ใน Python สามารถใช้ *args และ **kwargs

def print_args(*args):
    for arg in args:
        print(arg)

print_args(1, 2, 3)

ในตัวอย่างนี้ *args จะรับค่าทั้งหมดเป็น tuple

4. ส่งค่ากลับด้วย return

วิธีใช้ return

ถ้าต้องการให้ฟังก์ชันส่งค่ากลับ ให้ใช้ return หากไม่มี return ฟังก์ชันจะคืนค่า None โดยอัตโนมัติ

def add(a, b):
    return a + b

result = add(3, 4)
print(result)  # 7

ฟังก์ชัน add จะคืนผลบวกของเลขสองตัว ค่านี้สามารถเก็บไว้ในตัวแปร

ส่งค่ากลับหลายค่า

Python สามารถส่งค่ากลับหลายค่าในรูปแบบ tuple ได้ โดยคั่นด้วยคอมม่า

def swap(a, b):
    return b, a

x, y = swap(1, 2)
print(x, y)  # 2 1

5. ขอบเขตของตัวแปร (Scope) และช่วงชีวิต

ตัวแปรภายในฟังก์ชัน (Local) และตัวแปรนอกฟังก์ชัน (Global)

ตัวแปรที่ประกาศภายในฟังก์ชันจะเป็น local ใช้งานได้แค่ในฟังก์ชันนั้น ส่วนตัวแปรที่ประกาศนอกฟังก์ชันจะเป็น global ใช้งานได้ทั้งโปรแกรม

x = "global"

def func():
    x = "local"
    print(x)

func()      # local
print(x)    # global

ในตัวอย่างนี้ ตัวแปร x ที่ประกาศในฟังก์ชันจะไม่ส่งผลต่อตัวแปร x ภายนอก

คีย์เวิร์ด global

หากต้องการเปลี่ยนค่าตัวแปร global ภายในฟังก์ชัน ต้องใช้ global

x = "global"

def change_global():
    global x
    x = "changed"

change_global()
print(x)  # changed

6. ตัวอย่างและการใช้งานในชีวิตจริง

การเพิ่มประสิทธิภาพโปรแกรมด้วยฟังก์ชัน

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

def calculate_area(radius):
    return 3.14 * radius * radius

area1 = calculate_area(5)
area2 = calculate_area(10)

ในตัวอย่างนี้ ฟังก์ชัน calculate_area สามารถนำกลับมาใช้ซ้ำได้ทุกครั้งที่ต้องการคำนวณพื้นที่วงกลม

ตัวอย่างการใช้ฟังก์ชันกับข้อความ

อีกตัวอย่างคือ การจัดรูปแบบข้อความด้วยฟังก์ชัน

def format_text(text, alignment="left"):
    if alignment == "left":
        return text.ljust(20)
    elif alignment == "right":
        return text.rjust(20)
    elif alignment == "center":
        return text.center(20)

print(format_text("Hello", "center"))

ฟังก์ชันนี้จะจัดข้อความให้อยู่ซ้าย ขวา หรือกลางตามต้องการ

7. แนวคิดฟังก์ชันขั้นสูง

ฟังก์ชันซ้อน (Nested Functions)

ใน Python สามารถประกาศฟังก์ชันซ้อนกันได้ ฟังก์ชันภายในจะถูกเรียกใช้งานได้เฉพาะในฟังก์ชันภายนอกเท่านั้น

def outer():
    def inner():
        print("This is the inner function")
    inner()

ฟังก์ชันแบบไม่ระบุชื่อ (Lambda)

ด้วย lambda คุณสามารถสร้างฟังก์ชันแบบไม่มีชื่อ ใช้สำหรับฟังก์ชันง่าย ๆ ที่เรียกใช้ครั้งเดียว

square = lambda x: x * x
print(square(5))  # 25

เดโคเรเตอร์ (Decorator)

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

def decorator(func):
    def wrapper():
        print("Before the function")
        func()
        print("After the function")
    return wrapper

@decorator
def say_hello():
    print("Hello!")

say_hello()

8. สรุป

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

9. คำถามที่พบบ่อย (FAQs)

ความแตกต่างระหว่าง return กับ print คืออะไร?

return ใช้คืนค่าจากฟังก์ชันเพื่อนำไปใช้ต่อ ส่วน print ใช้แสดงผลลัพธ์บนหน้าจอแต่จะไม่คืนค่าให้โค้ดส่วนอื่น เช่น หากต้องการเก็บค่าผลลัพธ์ไว้ในตัวแปร ให้ใช้ return แต่ถ้าแค่ต้องการแสดงค่าก็ใช้ print

def add(a, b):
    return a + b

result = add(3, 4)  # result จะได้ค่า 7
print(result)  # 7

def display_message():
    print("Hello, World!")

display_message()  # จะแสดง Hello, World! แต่ไม่ได้คืนค่า

ข้อดีของฟังก์ชันซ้อน (Nested Function) คืออะไร?

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

ควรใช้ variable-length argument เมื่อไร?

หากไม่แน่ใจจำนวนอาร์กิวเมนต์ที่ต้องการส่งเข้าฟังก์ชัน เช่น ฟังก์ชันคำนวณผลรวมที่รับจำนวนตัวเลขไม่แน่นอน ก็ควรใช้ *args หรือ **kwargs

def add_all(*args):
    return sum(args)

result = add_all(1, 2, 3, 4, 5)  # 15

การเรียกใช้ฟังก์ชันแบบ recursive คืออะไร?

Recursive คือฟังก์ชันที่เรียกตัวเอง ใช้แก้ปัญหาซับซ้อนบางแบบ เช่น หาค่า factorial แต่ควรใช้ด้วยความระวังเพราะอาจเกิด stack overflow ได้ ตัวอย่างเช่น

def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n-1)

result = factorial(5)  # 120