Python – Function

Python – function

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

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

# ฟังก์ชันที่ไม่มีการส่งข้อมูลเข้าไป และไม่ทำการคืนค่าข้อมูล
def <ชื่อฟังก์ชัน<():
     <คำสั่งของฟังก์ชัน1>
     <คำสั่งของฟังก์ชัน2>
     ...

# ฟังก์ชันที่มีการส่งข้อมูลเข้าไป แต่ไม่ทำการคืนค่าข้อมูล
def <ชื่อฟังก์ชัน<(<ตัวแปร1>, <ตัวแปร2>, ...):
     <คำสั่งของฟังก์ชัน1>
     <คำสั่งของฟังก์ชัน2>
     ...

# ฟังก์ชันที่มีการส่งข้อมูลเข้าไป และมีการคืนค่าข้อมูล
def <ชื่อฟังก์ชัน<(<ตัวแปร1>, <ตัวแปร2>, ...):
     <คำสั่งของฟังก์ชัน1>
     <คำสั่งของฟังก์ชัน2>
     ...
     return <ผลลัพท์ที่ต้องการส่งกลับไปให้ส่วนที่เรียกใช้ฟังก์ชัน>

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

import datetime

# ฟังก์ชันสำหรับทำการปรินท์ค่าข้อมูลวันที่ของวันนี้ ซึ่งเป็นฟังก์ชันที่ไม่มีการส่งข้อมูลเข้าไป และไม่มีการคืนค่า
def print_current_date():

	# กำหนดรูปแบบของข้อความของวันที่ ปี/เดือน/วัน
	date_format = "%Y/%m/%d"

	# ดึงข้อมูลวันที่ของวันที่จากไลบรารี่ datetime
	now = datetime.datetime.now();

	# แปลงข้อมูลวันที่ให้อยู่ในรูปแบบข้อความตามรูปแบบที่กำหนดไว้ข้างต้น
	date_string = now.strftime(date_format)

	print(date_string)

print_current_date()
# โปรแกรมทำการปรินต์ค่า 
# 2019/02/10
การใช้คีย์เวิร์ด return

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

โครงสร้างของการใช้คีย์เวิร์ด return

def <ชื่อฟังก์ชัน>:
     <คำสั่งของฟังก์ชัน>
     ...
     return <ค่าที่ต้องการส่งคืนให้คำสั่งที่เรียกฟังก์ชัน>

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

ตัวอย่างการใช้งาน

import datetime

# ประกาศตัวแปรชนิดดิกชันนารี เพื่อเก็บข้อมูลประเภทของห้องต่างๆ ภายในบ้าน
room_types = {
     'living_room': 'Living room (first floor 4x4 sqrm)',
     'kitchen': 'Kitchen (first floor 4x4 sqrm)',
     'bedroom1': 'Bedroom1 (second floor 4x3 sqrm)',
     'bedroom2': 'Bedroom2 (second floor 4x3 sqrm)',
     'restroom1': 'Restroom1 (first floor 2x2 sqrm)',
     'restroom2': 'Restroom2 (second floor(2.5x2 sqrm)'
}

# ฟังก์ชันสำหรับดึงข้อมูลรายละเอียดของห้องประเภทต่างๆ ภายในบ้าน
def get_room_description(room_type):
     return room_types[room_type]

# ฟังก์ชันสำหรับทำการปรินท์ค่าข้อมูลวันที่ของวันนี้
def print_current_date():
	# กำหนดรูปแบบของข้อความของวันที่ ปี/เดือน/วัน
	date_format = "%Y/%m/%d"
	# ดึงข้อมูลวันที่ของวันที่จากไลบรารี่ datetime
	now = datetime.datetime.now();
	# แปลงข้อมูลวันที่ให้อยู่ในรูปแบบข้อความตามรูปแบบที่กำหนดไว้ข้างต้น
	date_string = now.strftime(date_format)
	print(date_string)

# ฟังก์ชันสำหรับแปลงอุณหภูมิจากหน่วยเป็นองศาเซลเซียสเป็น องศาฟาเรนต์ไฮต์
def convert_temperature_to_fahrenheit(degree_celsius):
     # สมการสำหรับแปลงอุณหภูมิ
     degree_fahrenheit = degree_celsius * (9.0/5.0) + 32 
     return degree_fahrenheit

# --- ส่วนของการเรียกใช้งานฟังก์ชันที่ประกาศเอาไว้ ---
print_current_date()

# ประมวลผลข้อมูลของห้องประเภทแรก
room_description = get_room_description("living_room")
print("ชนิดของห้อง: {}".format(room_description))
degree_fahrenheit = convert_temperature_to_fahrenheit(34)
print("อุณหภูมิที่วัดได้(องศาฟาเรนต์ไฮต์): {}".format(degree_fahrenheit))

# ประมวลผลข้อมูลของห้องประเภทที่ 2
room_description = get_room_description("kitchen")
print("ชนิดของห้อง: {}".format(room_description))
degree_fahrenheit = convert_temperature_to_fahrenheit(35)
print("อุณหภูมิที่วัดได้(องศาฟาเรนต์ไฮต์): {}".format(degree_fahrenheit))

# โปรแกรมทำการปรินต์ค่า
# 2019/02/10

# ชนิดของห้อง: Living room (first floor 4x4 sqrm)
# อุณหภูมิที่วัดได้(องศาฟาเรนต์ไฮต์): 93.2

# ชนิดของห้อง: Kitchen (first floor 4x4 sqrm)
# อุณหภูมิที่วัดได้(องศาฟาเรนต์ไฮต์): 95.0
ขอบเขตของตัวแปรในฟังก์ชัน

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

def test_function():
     # กำหนดให้ตัวแปร x(local scope) ซึ่งเป็นตัวแปรสำหรับฟังก์ชันมีค่าเป็น 10
     x = 10
     print("ตัวแปร x ภายในฟังก์ชันมีค่า: {}".format(x))

# --- ส่วนของการเรียกใช้งานฟังก์ชันที่ประกาศเอาไว้ ---
# กำหนดให้ตัวแปร x(glocal scope) มีค่า 20
x = 20
print("ตัวแปร x ภายนอกฟังก์ชันมีค่า: {}".format(x) )

# เรียนใช้งานฟังก์ชันเพื่อกำหนดค่าให้ตัวแปร x (ซึ่งชื่อตัวแปรเดียวกันกับภายนอกฟังก์ชัน) ให้มีค่าเป็น 10
test_function()

print("ตัวแปร x ภายนอกฟังก์ชันมีค่า: {}".format(x) )

# โปรแกรมทำการปรินต์ค่า
# ตัวแปร x (global scope) ภายนอกฟังก์ชันมีค่า: 20
# ตัวแปร x (local scope) ภายในฟังก์ชันมีค่า: 10
# ตัวแปร x (global scope) ภายนอกฟังก์ชันมีค่า: 20

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

เนื่องจากตัวแปร x ภายในฟังก์ชันกับภายนอกฟังก์ชันนั้นคือ ตัวแปรคนละตัวกันถึงแม้ว่าจะมีชื่อเดียวกัน แต่ตัวแปรทั้งสองก็ทำงานกันคนละ scope กัน(global scope/local scope)

สำหรับการอ่านข้อมูลของตัวแปร: สำหรับตัวแปรที่ถูกประกาศไว้ภายในฟังก์ชันนั้นจะถูกเรียกใช้ได้ภายในฟังก์ชันเท่านั้น(local scope) แต่ตัวแปรที่ถูกประกาศจากภายนอกฟังก์ชัน(global scope) จะสามารถจะเรียกใช้ได้ทั้งจากภายนอกและภายในฟังก์ชัน

สำหรับการเปลี่ยนแปลงข้อมูลของตัวแปร: สำหรับตัวแปรที่ถูกประกาศไว้ภายในฟังก์ชันนั้นจะสามารถอ่านข้อมูลและแก้ไขข้อมูลได้เฉพาะภายในฟังก์ชันเท่านั้น แต่ตัวแปรที่ถูกประกาศจากภายนอกฟังก์ชัน(global scope) สามารถเรียกใช้งานได้จากภายในฟังก์ชันด้วย แต่ไม่สามารถทำการแก้ไขข้อมูลของตัวแปรนั้นภายในฟังก์ชันได้ หากต้องการแก้ไขค่าของตัวแปรนั้น จำเป็นต้องประกาศด้วยคีย์เวิร์ด global ด้วยกำกับตัวแปรนั้นด้วย ซึ่งเราจะมาลงรายละเอียดเกี่ยวกับคีย์เวิร์ด global กันในบทต่อๆไป

ประเภทของฟังก์ชัน
ฟังก์ชันนั้นมีสองประเภท
1. Built-in functions: ฟังก์ชันที่ python เตรียมไว้ให้
2. User-defined functions: ฟังก์ชันที่เราทำการเขียนขึ้นมาใหม่

ที่มาของข้อมูล: https://www.programiz.com/python-programming/function