ข้ามไปยังเนื้อหาหลัก
Editor
ThePythonBookby pythoncompiler.io

ฟังก์ชันใน Python: นิยาม เรียกใช้ และคืนค่า

เริ่มต้น25 นาที6 แบบฝึกหัด80 XP

บทเรียนนี้แปลจากต้นฉบับภาษาอังกฤษRead in EnglishLeer en españolЧитать на русскомLer em portuguêsแจ้งข้อผิดพลาดในการแปล

ก่อนเริ่มเรียน
if-else ใน Python: เงื่อนไข elif, if ซ้อนกัน และ ternaryลูป for ใน Python: วนซ้ำได้ทุกอย่าง พร้อมตัวอย่าง
0/6 แบบฝึกหัด

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

ฟังก์ชันใน Python ทำงานเหมือนสูตรอาหารเลย คุณเขียนขั้นตอนไว้ครั้งเดียว ตั้งชื่อให้ แล้ว เรียก (call) ชื่อนั้นทุกครั้งที่ต้องการให้ขั้นตอนเหล่านั้นทำงานอีกครั้ง เขียนครั้งเดียว ใช้ได้ทุกที่

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

วิธีนิยามฟังก์ชันแรกของคุณ

การสร้างฟังก์ชันใน Python ใช้คีย์เวิร์ด def ตามด้วยชื่อ วงเล็บ และเครื่องหมายทวิภาค (colon) ทุกอย่างที่เยื้องอยู่ข้างใต้เป็นส่วนหนึ่งของฟังก์ชันนั้น

การนิยามฟังก์ชัน
def greet():
print('Hello there!')
print('Welcome to Python.')
ผลลัพธ์
(ไม่มีผลลัพธ์)

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

ถ้าต้องการให้ฟังก์ชันทำงานจริง ให้ เรียก ฟังก์ชันโดยเขียนชื่อตามด้วยวงเล็บ:

การเรียกฟังก์ชัน
def greet():
print('Hello there!')
print('Welcome to Python.')
greet()
ผลลัพธ์
Hello there!
Welcome to Python.

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

คุณเรียกฟังก์ชันกี่ครั้งก็ได้ตามต้องการ การเรียกแต่ละครั้งจะรันโค้ดทั้งหมดในฟังก์ชันจากบนลงล่าง

เรียกฟังก์ชันหลายครั้ง
def greet():
print('Hello there!')
greet()
greet()
greet()
ผลลัพธ์
Hello there!
Hello there!
Hello there!

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

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

ใน Python เราส่งข้อมูลเข้าไปในฟังก์ชันผ่าน พารามิเตอร์ (parameter) พารามิเตอร์คือชื่อตัวแปรที่เขียนไว้ในวงเล็บของการนิยามฟังก์ชัน เมื่อเรียกฟังก์ชัน ค่าจริงที่ส่งเข้าไปเรียกว่า อาร์กิวเมนต์ (argument)

ฟังก์ชันที่มีพารามิเตอร์หนึ่งตัว
def greet(name):
print('Hello, ' + name + '!')
greet('Alice')
greet('Bob')
ผลลัพธ์
Hello, Alice!
Hello, Bob!

ในที่นี้ name คือ พารามิเตอร์ ซึ่งเป็นตัวยึดตำแหน่ง เมื่อเราเรียก greet('Alice') สตริง 'Alice' คือ อาร์กิวเมนต์ ซึ่งเป็นค่าจริงที่มาเติมลงในตัวยึดตำแหน่งนั้น

การคืนค่าทำงานอย่างไร

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

ลองคิดแบบนี้: print() เหมือนการตะโกนบอกคำตอบออกมาดัง ๆ ส่วน return เหมือนการเขียนคำตอบลงกระดาษแล้วยื่นให้คนที่ถาม

การคืนค่า
def add(a, b):
return a + b
result = add(3, 5)
print(result)
ผลลัพธ์
8

คำสั่ง return ทำสองอย่าง: ส่งค่ากลับไปยังจุดที่เรียกฟังก์ชัน และออกจากฟังก์ชันทันที โค้ดใด ๆ หลัง return ในฟังก์ชันเดียวกันจะไม่ถูกรัน

โค้ดหลัง return จะไม่ถูกรัน
def add(a, b):
return a + b
print('This line never runs!')
print(add(3, 5))
ผลลัพธ์
8
การแสดงผล (ผลข้างเคียง)
def add(a, b):
    print(a + b)

# Can't reuse the result
add(3, 5)
การคืนค่า (ส่งค่ากลับมา)
def add(a, b):
    return a + b

# Can store, reuse, combine
result = add(3, 5)
print(result * 2)

การใช้พารามิเตอร์หลายตัว

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

ฟังก์ชันที่มีพารามิเตอร์สามตัว
def introduce(name, age, city):
print(name + ' is ' + str(age) + ' years old and lives in ' + city + '.')
introduce('Alice', 25, 'New York')
introduce('Bob', 30, 'London')
ผลลัพธ์
Alice is 25 years old and lives in New York.
Bob is 30 years old and lives in London.

ลำดับมีความสำคัญ ถ้าสลับอาร์กิวเมนต์ จะได้ผลลัพธ์ที่ไม่มีความหมายหรือเกิดข้อผิดพลาด introduce(25, 'Alice', 'London') จะพยายามใช้ 25 เป็นชื่อ

ค่าเริ่มต้นของพารามิเตอร์คืออะไร

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

ค่าเริ่มต้นของพารามิเตอร์
def greet(name, greeting='Hello'):
print(greeting + ', ' + name + '!')
greet('Alice')
greet('Bob', 'Hey')
ผลลัพธ์
Hello, Alice!
Hey, Bob!

เมื่อเรียก greet('Alice') พารามิเตอร์ greeting จะใช้ค่าเริ่มต้น 'Hello' แต่เมื่อเรียก greet('Bob', 'Hey') เราจะแทนที่ค่าเริ่มต้นด้วย 'Hey'

ฟังก์ชันเรียกใช้ฟังก์ชันอื่นได้หรือไม่

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

ฟังก์ชันเรียกใช้ฟังก์ชัน
def square(n):
return n * n
def sum_of_squares(a, b):
return square(a) + square(b)
result = sum_of_squares(3, 4)
print(result)
ผลลัพธ์
25

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

การใช้ฟังก์ชันตัวช่วย
def is_even(n):
return n % 2 == 0
def describe_number(n):
if is_even(n):
return str(n) + ' is even'
else:
return str(n) + ' is odd'
print(describe_number(7))
print(describe_number(10))
ผลลัพธ์
7 is odd
10 is even

แบบฝึกหัด

ทักทายด้วย Hello
เขียนโค้ด

เขียนฟังก์ชันชื่อ say_hello ที่รับพารามิเตอร์ name และ แสดงผล Hello, <name>! (มีเครื่องหมายอัศเจรีย์ด้วย) ตัวอย่างเช่น say_hello('World') ควรแสดง Hello, World!

# Define your function here
# Test it
say_hello('World')
say_hello('Python')
ทายผลลัพธ์
ทายผลลัพธ์

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

def double(x):
    return x * 2

result = double(7)
print(result)
print(double(3))
def double(x):
return x * 2
result = double(7)
print(result)
print(double(3))
พื้นที่ของสี่เหลี่ยมผืนผ้า
เขียนโค้ด

เขียนฟังก์ชันชื่อ area ที่รับ width และ height เป็นพารามิเตอร์ แล้ว คืนค่า ผลคูณของทั้งสอง (พื้นที่ของสี่เหลี่ยมผืนผ้า) ไม่ต้องแสดงผล ให้คืนค่าอย่างเดียว

# Define your function here
# Test it
print(area(5, 3))
print(area(10, 7))
แก้ฟังก์ชันที่ผิด
แก้บั๊ก

ฟังก์ชันนี้ควรคืนค่าตัวเลขที่มากกว่าจากตัวเลขสองตัว แต่เมื่อรันกลับแสดงตัวเลขออกมาแล้วตามด้วย None แก้ให้ bigger(3, 7) คืนค่า 7 และ bigger(10, 5) คืนค่า 10

def bigger(a, b):
if a > b:
print(a)
print(b)
print(bigger(3, 7))
print(bigger(10, 5))
ตัวแปลงอุณหภูมิ
เขียนโค้ด

เขียนฟังก์ชันชื่อ celsius_to_fahrenheit ที่รับอุณหภูมิเป็นองศาเซลเซียส แล้ว คืนค่า อุณหภูมิที่แปลงเป็นองศาฟาเรนไฮต์ สูตรคือ F = C * 9/5 + 32 ให้คืนค่าผลลัพธ์เป็นทศนิยม (float) ซึ่งสูตรนี้ให้ผลเป็นทศนิยมอยู่แล้ว

# Define your function here
# Test it
print(celsius_to_fahrenheit(0))
print(celsius_to_fahrenheit(100))
print(celsius_to_fahrenheit(37))
สร้างตัวคำนวณเกรด
เขียนโค้ด

เขียนฟังก์ชันชื่อ get_grade ที่รับคะแนน score เป็นตัวเลข (0-100) แล้ว คืนค่า เกรดตัวอักษรเป็นสตริง:

  • 90 ขึ้นไป: 'A'
  • 80-89: 'B'
  • 70-79: 'C'
  • 60-69: 'D'
  • ต่ำกว่า 60: 'F'
    • # Define your function here
    # Test it
    print(get_grade(95))
    print(get_grade(83))
    print(get_grade(72))
    print(get_grade(65))
    print(get_grade(45))

    บทเรียนที่เกี่ยวข้อง

    ฟังก์ชัน·ปานกลาง
    อาร์กิวเมนต์ฟังก์ชันใน Python: *args, **kwargs และค่าเริ่มต้น
    25 นาที7 แบบฝึกหัด
    ฟังก์ชัน·ปานกลาง
    ฟังก์ชัน Lambda ใน Python: ควรใช้เมื่อไร และเมื่อไรไม่ควรใช้
    20 นาที5 แบบฝึกหัด
    ฟังก์ชัน·ปานกลาง
    สโคปของตัวแปร โคลเชอร์ และกฎ LEGB ใน Python
    25 นาที5 แบบฝึกหัด
    ฟังก์ชัน·ปานกลาง
    Recursion ใน Python: หลักการทำงาน เมื่อไรควรใช้ และตัวอย่าง
    25 นาที6 แบบฝึกหัด
    โครงสร้างควบคุม·เริ่มต้น
    if-else ใน Python: เงื่อนไข elif, if ซ้อนกัน และ ternary
    25 นาที6 แบบฝึกหัด
    โครงสร้างควบคุม·เริ่มต้น
    ลูป for ใน Python: วนซ้ำได้ทุกอย่าง พร้อมตัวอย่าง
    25 นาที7 แบบฝึกหัด

    บทเรียนนี้มีประโยชน์หรือไม่

    เสนอแนะการปรับปรุง