Python – Function argument

Posted on by booboo
og:image

Python – Function argument

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

1. การสร้างฟังก์ชันแบบจำเป็นต้องระบุข้อมูลให้ครบตามจำนวนข้อมูลที่ฟังก์ชันต้องการและเรียงลำดับตามที่ประกาศเสมอ

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

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

# ฟังก์ชันคำนวณพื้นที่ของสี่เหลี่ยมจัตุรัสโดยรับข้อมูล: ความยาวของด้าน(d)
def calculate_square_area(d):
     square_area = d * d
     return square_area

# ฟังก์ชันคำนวณพื้นที่ของสามเหลี่ยมโดยรับข้อมูล: ความยาวฐาน(b) และความสูง(h)
def calculate_triangle_area(b, h):
     triangle_area = (1.0/2.0) * b * h
     return triangle_area

# ฟังก์ชันคำนวณพื้นที่ของวงกลมโดยรับข้อมูล: รัศมีของวงกลม(r)
def calculate_circle_area(d):
     circle_area = math.pi * r * r
     return circle_area

# ฟังก์ชันคำนวณพื้นที่ของสี่เหลี่ยมคางหมูโดยรับข้อมูล: ด้านยาวส่วนบน(a), ด้านยาวส่วนล่าง(b), ความสูง(h)
def calculate_trapezoid_area(a, b, h):
     trapezoid_area = (1.0/2.0) * (a + b) * h
     return trapezoid_area


# เรียกฟังก์ชันเพื่อทำการคำนวณพื้นที่สี่เหลี่ยมจัตุรัสที่มีความยาวแต่ละด้าน 5 หน่วย
d = 5 # กำหนดความยาวด้าน
square_area = calculate_square_area(d)
print("พื้นที่สี่เหลี่ยมจัตุรัสที่ด้านยาว {} หน่วย มีพื้นที่: {:0.2f} ตารางหน่วย".format(d, square_area))
# โปรแกรมจะทำการปรินต์ค่า
# พื้นที่สี่เหลี่ยมจัตุรัสที่ด้านยาว 5 หน่วย มีพื้นที่: 25.00 ตารางหน่วย


# เรียกฟังก์ชันเพื่อทำการคำนวณพื้นที่ของสามเหลี่ยมที่มีด้านฐาน 5 หน่วย ความสูง 3 หน่วย
b = 5 # กำหนดความยาวฐาน
h = 3 # กำหนดความสูง
traingle_area = calculate_triangle_area(b, h)
print("พื้นที่สามเหลี่ยมที่มีด้านฐาน {} หน่วย และความสูง {} หน่วย จะมีพื้นที่: {:0.2f} ตารางหน่วย".format(b, h, traingle_area))
# โปรแกรมจะทำการปรินต์ค่า
# พื้นที่สามเหลี่ยมที่มีด้านฐาน 5 หน่วย และความสูง 3 หน่วย จะมีพื้นที่: 7.50 ตารางหน่วย


# เรียกฟังก์ชันเพื่อทำการคำนวณพื้นที่ของวงกลมที่มีรัศมี 3 หน่วย
r = 3 # กำหนดรัศมี
circle_area = calculate_circle_area(r)
print("พื้นที่วงกลมที่มีรัศมี {} หน่วย จะมีพื้นที่: {:0.2f} ตารางหน่วย".format(r, circle_area))
# โปรแกรมจะทำการปรินต์ค่า
# พื้นที่วงกลม 3 หน่วย จะมีพื้นที่: 28.27 ตารางหน่วย


# เรียกฟังก์ชันเพื่อทำการคำนวณพื้นที่ของสี่เหลี่ยมคางหมูที่มีด้านยาวส่วนบน 3 หน่วย, ด้านยาวส่วนล่าง 5 หน่วย และ ความสูง 4 หน่วย 
a = 3 # กำหนดด้านยาวส่วนบน
b = 5 # กำหนดด้านยาวส่วนล่าง
h = 4 # กำหนดความสูง
trapezoid_area = calculate_trapezoid_area(a, b, h)
print("พื้นที่สี่เหลี่ยมคางหมูที่มีด้านยาวส่วนบน {} หน่วย, ด้านยาวส่วนล่าง {} หน่วย และความสูง {} หน่วย จะมีพื้นที่: {:0.2f} ตารางหน่วย".format(a, b, h, trapezoid_area))
# โปรแกรมจะทำการปรินต์ค่า
# พื้นที่สี่เหลี่ยมคางหมูที่มีด้านยาวส่วนบน 3 หน่วย, ด้านยาวส่วนล่าง 5 หน่วย และความสูง 4 หน่วย จะมีพื้นที่: 16.00 ตารางหน่วย

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

พื้นที่สี่เหลี่ยมจัตุรัส = ด้าน x ด้าน
พื้นที่วงกลม = Π x r2
พื้นที่สามเหลี่ยม = 1/2 x (ฐาน x สูง)
พื้นที่สี่เหลี่ยมคางหมู = 1/2 x ((ด้านบน + ด้านล่าง) x สูง)
ซึ่งในตัวอย่างจะทำการกำหนดข้อมูลและเรียกใช้ฟังก์ชันที่ทำการสร้างเอาไว้เพื่อใช้ในการคำนวณพื้นที่ดังกล่าวตามข้อมูลที่ระบุและได้ผลลัพท์ตามรูป



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

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

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

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

    # ฟังก์ชันคำนวณพื้นที่ของสามเหลี่ยมโดยรับข้อมูล: ความยาวฐาน(b) และความสูง(h) และมีการกำหนดข้อมูลตั้งต้นให้ฐานยาว 5 หน่วย และสูง 3 หน่วย
def calculate_triangle_area(b=5, h=3):
     triangle_area = (1.0/2.0) * b * h
     return triangle_area

# เรียกฟังก์ชันเพื่อคำนวณพื้นที่ของสามเหลี่ยมโดยไม่ระบุข้อมูลใดๆ ให้ฟังก์ชัน เพื่อให้ใช้ค่าตั้งต้นที่เรากำหนดเอาไว้ทั้งความยาวฐานและความสูง
triangle_area1 = calculate_triangle_area()
print("พื้นที่สามเหลี่ยมที่มีด้านฐาน 5 หน่วย และความสูง 3 หน่วย จะมีพื้นที่: {:0.2f} ตารางหน่วย".format( triangle_area1))
# โปรแกรมจะทำการปรินต์ค่า
# พื้นที่สามเหลี่ยมที่มีด้านฐาน 5 หน่วย และความสูง 3 หน่วย จะมีพื้นที่: 7.50 ตารางหน่วย


# เรียกฟังก์ชันเพื่อคำนวณพื้นที่ของสามเหลี่ยมโดยระบุเพียงความยาวฐาน และให้ฟังก์ชันใช้ค่าความสูงจากค่าตั้งต้นที่เรากำหนดเอาไว้
b = 10
triangle_area2 = calculate_triangle_area(b)
print("พื้นที่สามเหลี่ยมที่มีด้านฐาน 10 หน่วย และความสูง 3 หน่วย จะมีพื้นที่: {:0.2f} ตารางหน่วย".format(triangle_area2))
# โปรแกรมจะทำการปรินต์ค่า
# พื้นที่สามเหลี่ยมที่มีด้านฐาน 10 หน่วย และความสูง 3 หน่วย จะมีพื้นที่: 15.00 ตารางหน่วย


# เรียกฟังก์ชันเพื่อคำนวณพื้นที่ของสามเหลี่ยมโดยระบุทั้งความยาวฐานและความสูง โดยไม่ให้ฟังก์ชันใช้ค่าตั้งต้นที่เรากำหนดเอาไว้
b = 10
h = 5
triangle_area3 = calculate_triangle_area(b, h)
print("พื้นที่สามเหลี่ยมที่มีด้านฐาน {} หน่วย และความสูง {} หน่วย จะมีพื้นที่: {:0.2f} ตารางหน่วย".format(b, h, triangle_area3))
# โปรแกรมจะทำการปรินต์ค่า
# พื้นที่สามเหลี่ยมที่มีด้านฐาน 10 หน่วย และความสูง 5 หน่วย จะมีพื้นที่: 25.00 ตารางหน่วย

    การประกาศฟังก์ชันดังตัวอย่างข้างต้น เป็นการสร้างฟังก์ชันเพื่อคำนวณพื้นที่ของสามเหลี่ยมโดยมีการกำหนดค่าตั้งต้นให้กับฐานและความสูงมีค่าเป็น 5 และ 3 ตามลำดับ หากเราเรียกใช้งานฟังก์ชันและไม่ทำการกำหนดค่าให้ตัวแปรเหล่านั้น ฟังก์ชันก็จะเรียกใช้ค่าตั้งต้นที่ได้กำหนดไว้ โปรแกรมจะทำการใช้ค่าตั้งต้นที่เรากำหนดไว้ตอนเขียนฟังก์ชันมาใช้ประมวลแทน

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

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

    # ฟังก์ชันคำนวณพื้นที่ของสี่เหลี่ยมคางหมูโดยรับข้อมูล: ด้านยาวส่วนบน(a), ด้านยาวส่วนล่าง(b), ความสูง(h)
def calculate_trapezoid_area(upper_width=3, lower_width=5, height=4):
     trapezoid_area = (1.0/2.0) * (upper_width + lower_width) * height     
     return trapezoid_area

a = 6 # กำหนดด้านยาวส่วนบน
b = 10 # กำหนดด้านยาวส่วนล่าง
h = 4 # กำหนดความสูง

# เรียกฟังก์ชันเพื่อทำการคำนวณพื้นที่ของสี่เหลี่ยมคางหมู โดยทำการส่งข้อมูลเข้าไปในฟังก์ชันแบบอ้างอิงตามลำดับข้อมูลการประกาศตัวแปร
trapezoid_area = calculate_trapezoid_area(a, b, h)
print("พื้นที่สี่เหลี่ยมคางหมูที่มีด้านยาวส่วนบน {} หน่วย, ด้านยาวส่วนล่าง {} หน่วย และความสูง {} หน่วย จะมีพื้นที่: {:0.2f} ตารางหน่วย".format(a, b, h, trapezoid_area))
# โปรแกรมจะทำการปรินต์ค่า
# พื้นที่สี่เหลี่ยมคางหมูที่มีด้านยาวส่วนบน 6 หน่วย, ด้านยาวส่วนล่าง 10 หน่วย และความสูง 4 หน่วย จะมีพื้นที่: 32.00 ตารางหน่วย


# เรียกฟังก์ชันเพื่อทำการคำนวณพื้นที่ของสี่เหลี่ยมคางหมู โดยทำการส่งข้อมูลเข้าไปในฟังก์ชันแบบให้ข้อมูลที่ส่งเข้าไปอ้างอิงตามชื่อตัวแปรที่กำกับ (สามารถสลับลำดับของข้อมูลที่ส่งเข้าไปให้ฟังก์ชันได้)
trapezoid_area = calculate_trapezoid_area(lower_width=b, height=h, upper_width=a)
print("พื้นที่สี่เหลี่ยมคางหมูที่มีด้านยาวส่วนบน {} หน่วย, ด้านยาวส่วนล่าง {} หน่วย และความสูง {} หน่วย จะมีพื้นที่: {} ตารางหน่วย".format(a, b, h, trapezoid_area))
# โปรแกรมจะทำการปรินต์ค่า
# พื้นที่สี่เหลี่ยมคางหมูที่มีด้านยาวส่วนบน 6 หน่วย, ด้านยาวส่วนล่าง 10 หน่วย และความสูง 4 หน่วย จะมีพื้นที่: 32.00 ตารางหน่วย


# เรียกฟังก์ชันเพื่อทำการคำนวณพื้นที่ของสี่เหลี่ยมคางหมู โดยข้อมูลตัวแรกอ้างอิงตามลำดับของข้อมูล และสองตัวสุดท้าย อ้างอิงตามชื่อของตัวแปรที่กำกับข้อมูล (เมื่อเริ่มมีการอ้างอิงโดยการกำกับด้วยชื่อตัวแปรที่ข้อมูลใด ข้อมูลทางด้านขวาทั้งหมดก็ต้องอ้างอิงด้วยชื่อเช่นกัน)
trapezoid_area = calculate_trapezoid_area(a, height=h, lower_width=b)
print("พื้นที่สี่เหลี่ยมคางหมูที่มีด้านยาวส่วนบน {} หน่วย, ด้านยาวส่วนล่าง {} หน่วย และความสูง {} หน่วย จะมีพื้นที่: {:0.2f} ตารางหน่วย".format(a, b, h, trapezoid_area))
# โปรแกรมจะทำการปรินต์ค่า
# พื้นที่สี่เหลี่ยมคางหมูที่มีด้านยาวส่วนบน 6 หน่วย, ด้านยาวส่วนล่าง 10 หน่วย และความสูง 4 หน่วย จะมีพื้นที่: 32.00 ตารางหน่วย

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

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

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

    # ทำการคูณตัวเลขทั้งหมดที่ส่งเข้ามาในฟังก์ชัน
def multiplication(*values):
     result = 1
     for value in values:
          result = result*value
     return result

output = multiplication(5, 6, 4, 2)
print(output)
# โปรแกรมทำการปรินต์ค่า 240

โปรแกรมวาดรูปประกอบ Draw.io