ฟังก์ชัน

ผลการเรียนรู้ที่คาดหวัง

เมื่อจบหัวข้อนี้ ผู้เรียนควรจะ

√ CLO3: สร้างฟังก์ชันและเรียกใช้งานได้

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

√ CLO5: เขียนโปรแกรมเพื่อแก้ปัญหาทางด้านคณิตศาสตร์ สถิติ และปัญหาในชีวิตประจำวัน

เขียนโปรแกรมเพื่อแก้ปัญหาโจทย์ โดยสร้างฟังก์ชัน และเรียกใช้

√ CLO6: ทดสอบโปรแกรม ค้นหาจุดบกพร่อง และแก้ไขให้โปรแกรมทำงานถูกต้อง

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

ฟังก์ชัน

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

ในภาษาโปรแกรมมีฟังก์ชันอยู่ มี 2 รูปแบบ ได้แก่

built-in function เป็นฟังก์ชันที่มีอยู่แล้วในภาษานั้นๆ สามารถเรียกใช้งานได้เลย เช่น print() และ input() เป็น standard library function ที่มีอยู่แล้วในภาษาไพธอน
user-defined function เป็นฟังก์ชันที่ผู้ใช้สร้างขึ้น เพื่อใช้งานตามที่ต้องการ

การประกาศฟังก์ชัน

เมื่อเราต้องการสร้าง user-defined function เพื่อใช้งาน ควรกำหนดหน้าที่การทำงานให้ชัดเจนและสอดคล้องกับชื่อฟังก์ชัน

การประกาศฟังก์ชันทำได้โดยใช้คำสั่ง def และต้องประกาศก่อนส่วนที่จะเรียกใช้

คำสั่ง def

เป็นคำสั่งที่ใช้ประกาศฟังก์ชัน ประกอบด้วยส่วนหัว (head) และส่วนคำสั่ง (body)

ส่วนหัว ประกอบด้วยคำสั่ง def ชื่อฟังก์ชัน และพารามิเตอร์ (สิ่งที่ต้องส่งให้ฟังก์ชันเมื่อเรียกใช้)
ส่วนคำสั่ง ประกอบด้วย คำสั่งที่ต้องการให้ทำงาน และค่าที่ต้องการส่งกลับคืน (ถ้ามี)

รูปแบบคำสั่ง

def function_name ([parameter1, ... , parameterN]) :

statements(s) # body of function

[return expression]

โดย

function_name คือ ชื่อของฟังก์ชัน มีหลักเกณฑ์เหมือนกับการตั้งชื่อตัวแปร
parameter คือ ค่าที่รับเข้ามา ถ้ามีหลายตัว คั่นด้วยเครื่องหมาย " , " (ไม่มีก็ได้)
statements คือ ชุดคำสั่งที่ทำงานเมื่อเรียกใช้ ต้องเขียนย่อหน้าเข้าไป
return คือ คำสั่งที่ใช้ส่งค่ากลับคืนไปให้ส่วนของโปรแกรมที่เรียกใช้ (ไม่มีก็ได้)

ตัวอย่างการประกาศฟังก์ชัน

image source: https://www.scientecheasy.com/2022/11/functions-in-python.html/

รูปแบบของฟังก์ชัน

แบ่งได้เป็น 4 รูปแบบ ตามลักษณะของพารามิเตอร์และการคืนค่า ดังนี้

ไม่มีพารามิเตอร์ ไม่มีการคืนค่า
มีพารามิเตอร์ ไม่มีการคืนค่า
ไม่มีพารามิเตอร์ มีการคืนค่า
มีพารามิเตอร์ มีการคืนค่า

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

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

รูปแบบคำสั่ง

function_name ([parameter1, ... , parameterN])

ตัวอย่าง ฟังก์ชันแบบไม่มีพารามิเตอร์ ไม่มีการคืนค่า

def greet():

print('Hello World!')

# call the function

greet()

print('Outside function')

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

ตัวอย่าง ฟังก์ชันแบบมีพารามิเตอร์ ไม่มีการคืนค่า

def greeting(name):

print('Hello,', name)

print('Welcome to Programming in Python')

print()

# call the function

greeting('Ann')

greeting('Doraemon')

Output

Hello World!

Outside function

ลำดับการทำงาน

image source: https://www.programiz.com/python-programming/function/

Output

Hello, Ann

Welcome to Programming in Python

Hello, Doraemon

Welcome to Programming in Python

การส่งผ่านพารามิเตอร์

หากต้องการส่งค่าเพื่อให้ฟังก์ชันนำไปใช้งาน ควรกำหนดเป็นพารามิเตอร์ไว้ที่ส่วนหัวของฟังก์ชัน เรียกว่า formal parameter

Formal parameter มี 2 ประเภท

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

หากต้องการเรียกใช้งานฟังก์ชันที่มีพารามิเตอร์ จะต้องมีการส่งผ่านค่าให้กับฟังก์ชัน เรียกค่าที่ส่งให้ฟังก์ชันว่า actual parameter หรือ argument

การส่งผ่านค่าพารามิเตอร์มี 2 วิธี

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

ฟังก์ชันแบบมีพารามิเตอร์ประเภท required parameter

# function with two arguments

def add_numbers(num1, num2):

sum = num1 + num2

print(num1, '+', num2, '=', sum)

# function call with two values passed by position

add_numbers(5, 4)

add_numbers(10, 30)

add_numbers('a', 'b')

# function call with two values passed by keyword

add_numbers(num1 = 10, num2 = 20)

add_numbers(num2 = 20, num1 = 10)

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

Output

5 + 4 = 9

10 + 30 = 40

10 + 20 = 30

ลำดับการทำงาน

image source: https://www.programiz.com/python-programming/function/

ฟังก์ชันแบบมีพารามิเตอร์ประเภท default parameter

# function with two arguments

def multiply(first, second=2):

result = first * second

print("result =", result)

# function call with one values

multiply(5)

multiply('Hello')

# function call with two values

multiply(5, 3)

multiply('Hello', 4)

Output

result = 10

result = HelloHello

result = 15

result = HelloHelloHelloHello

จากตัวอย่างเป็น first เป็น required parameter และ second เป็น default parameter เมื่อเรียกใช้งาน หากระบุเพียง 1 argument จะเป็นการส่งค่าให้กับ first และจะกำหนดค่า 2 ให้กับ second อัตโนมัติ แต่หากไม่ต้องการให้ second มีค่าเป็น 2 ต้องส่ง argument 2 ค่า

การคืนค่าจากฟังก์ชัน

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

หากไม่มีคำสั่ง return คืนค่าใด ระบบจะคืนค่า None (ถือเป็นชนิดข้อมูลพิเศษ ไม่ใช่ค่าสตริง 'None')
หากต้องการคืนเพียงค่าเดียว ให้เขียนคำสั่ง return ตามด้วยค่าที่ต้องการ เช่น return x**2, return average
หากต้องการคืนค่ามากกว่า 1 ค่า ให้คืนค่าเป็นชนิดข้อมูล tuple คือ ระบุค่าภายในเครื่องหมาย () เช่น return (result1, result2)
คำสั่ง return สามารถใช้ได้หลายที่ในฟังก์ชัน

การนำค่าที่คืนจากฟังก์ชันไปใช้งาน ทำได้หลายรูปแบบ เช่น

กำหนดค่าให้กับตัวแปร เช่น avg = average(3, 4, 5)
แสดงผลค่าที่คืนกลับมาโดยใช้คำสั่ง print() เช่น print(exponent(5))
นำค่าไปใช้นิพจน์ เช่น cone_volume = cylinder_volume(r, h) / 3

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

ฟังก์ชันแบบมีพารามิเตอร์ มีการคืนค่า

# function definition

def find_square(num):

result = num * num

return result

# function call

find_square(5)

square = find_square(3)

print('Square =', square)

จากตัวอย่างการเรียกใช้ฟังก์ชัน find_square(5) ในครั้งแรก ฟังก์ชันจะทำงาน แต่จะไม่แสดงผลการทำงาน เพราะไม่มีการกำหนดค่าให้กับตัวแปร หรือไม่มีคำสั่ง print() ครอบคำสั่งเรียกใช้ไว้เพื่อแสดงค่าที่คืนกลับมา

Output

Square = 9

ลำดับการทำงาน

image source: https://www.programiz.com/python-programming/function/

ฟังก์ชันแบบมีพารามิเตอร์ มีการคืนค่า

# function with two arguments and return one value

def cylinder_volume(radius, height):

return 3.14159 * height * radius ** 2

# main program

r, h = 2, 5

# function call, see nothing

cylinder_volume(r, h)

# function call return value to variable

volume = cylinder_volume(r, h)

print("cylinder volume = %.2f" % volume)

# function call inside print() and expression

r, h = 3, 7

print("cylinder volume = %.2f" % cylinder_volume(r, h))

cone_volume = cylinder_volume(r, h) / 3

print("cone volume = %.1f" % cone_volume)

Output

cylinder volume = 62.83

cylinder volume = 197.92

cone volume = 66.0

Cone and Cylinder Volume

image source: https://byjus.com/maths/volume-of-cone/

ฟังก์ชันแบบไม่มีพารามิเตอร์ มีการคืนค่า

# function with no arguments and return two value

def sum_positive():

sum_n = 0; count = 0

while True:

n = int(input())

if n == 0:

break

if n > 0:

sum_n += n

count += 1

return (sum_n, count)

# main program

sum_pos, n = sum_positive()

if n != 0:

print('average = %.2f' % sum_pos/n)

else:

print('no positive input')

Output

-5

-7

average = 2.50

Output

-5

-4

-2

-1

no positive input

ขอบเขตของตัวแปร

ขอบเขตของตัวแปร หมายถึง พื้นที่ที่สามารถอ้างถึงชื่อตัวแปร หรือเข้าถึงค่าของตัวแปรนั้นได้

ขอบเขตของตัวแปรขึ้นอยู่กับตำแหน่งที่ประกาศไว้ครั้งแรกในโปรแกรม

ตัวแปรในภาษาไพธอนแบ่งตามประเภทของขอบเขตได้ 3 ชนิด

Local variable
Global variable

Local variable

เป็นตัวแปรที่ประกาศไว้ภายในฟังก์ชัน จะใช้งานได้เฉพาะภายในฟังก์ชันที่ประกาศไว้เท่านั้น ไม่สามารถเรียกใช้นอกฟังก์ชัน หรือเรียกใช้งานในฟังก์ชันอื่นได้
ข้อสังเกตเกี่ยวกับตัวแปร local

ตั้งชื่อซ้ำกับตัวแปรในฟังก์ชันอื่นได้ และถือว่าเป็นคนละตัวแปรกัน
formal parameter เป็นเสมือนตัวแปรที่ใช้ภายในฟังก์ชันด้วยเช่นกัน
- ในกรณีที่เป็นชนิดข้อมูลพื้นฐาน (int, float, string, boolean) เมื่อส่งค่า argument เป็นตัวแปร จะถือว่าเป็นคนละตัวกัน
- ในกรณีที่เป็นชนิดข้อมูลแบบมีโครงสร้าง (list, dict, set) จะถือว่าตัวแปรในฟังก์ชันและตัวแปรที่ส่งผ่านค่ามาเป็นตัวเดียวกัน เมื่อเปลี่ยนแปลงค่าตัวแปรในฟังก์ชัน ตัวแปรที่ส่งค่ามาจะเปลี่ยนแปลงค่าด้วยเช่นกัน

ตัวอย่าง การประกาศตัวแปรแบบ local

def greet():

# local variable

message = 'Hello'

print('Local', message)

greet()

# try to access message variable outside greet() function

print(message)

output

Local Hello

NameError: name 'message' is not defined

จากตัวอย่าง ตัวแปร message เป็น local variable สามารถเรียกใช้ภายในฟังก์ชันได้

แต่เมื่อเรียกใช้งานนอกฟังก์ชันจะเกิด error เนื่องจากอยู่นอกขอบเขตการมองเห็น

Global variable

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

ตัวอย่าง การประกาศตัวแปรแบบ global

# declare global variable

def greet():

print('Local', message)

message = 'Hello'

greet()

print('Global', message)

output

Local Hello

Global Hello

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

* ทดลองย้ายคำสั่งกำหนดค่า message ไปไว้คำสั่งสุดท้าย

global keyword

ตัวแปร count ประกาศอยู่นอกฟังก์ชัน เป็นตัวแปรแบบ global ทำให้ทุกฟังก์ชันสามารถมองเห็นได้

แต่สังเกตว่าในฟังก์ชัน increment2 มีการประกาศตัวแปรโดยการกำหนดค่าให้ตัวแปร count อีกครั้ง ทำให้ count ภายในฟังก์ชันเป็นตัวแปร local ซึ่งถือว่าเป็นคนละตัวกับ count นอกฟังก์ชัน และเกิด error เมื่อรันคำสั่ง count = count + 1 เพราะถ้าอ้างถึงค่า count โดยไม่มีการกำหนดค่าเริ่มต้นไว้ภายในฟังก์ชันก่อนหน้าคำสั่งนี้

ถ้าเราต้องการอ้างถึงหรือเปลี่ยนแปลงค่าของตัวแปร global ภายในฟังก์ชัน ต้องใช้ keyword global นำหน้าตัวแปร เพื่อระบุว่าตัวแปรนั้น เป็นตัวแปรเดียวกับตัวแปร global ที่ประกาศไว้นอกฟังก์ชัน

ตัวอย่าง การประกาศตัวแปรแบบ global

# global variable

count = 0

def increment1():

print(count)

increment1()

# Output: 0

# global variable

count = 0

def increment2():

count = count + 1

print(count)

increment2()

# Output: UnboundLocalError: local variable 'count' referenced before assignment

ตัวอย่าง การประกาศตัวแปรโดยใช้ global keyword

# global variable

count = 0

def increment3():

# use global keyword

global count

count = count + 1

print(count)

increment3()

# Output: 1

จากตัวอย่าง เมื่อใช้ keyword global ประกาศตัวแปร count ภายในฟังก์ชัน ทำให้ตัวแปร count ในฟังก์ชันนี้ เป็นตัวแปรเดียวกับตัวแปร count ที่เป็นตัวแปร global

ดังนั้นเมื่อเพิ่มค่าตัวแปร count จึงไม่เกิด error เพราะมีการกำหนดค่าเริ่มต้นไว้เป็น 0 แล้วนอกฟังก์ชัน

ลองเขียนโปรแกรมต่อไปนี้

ตัวอย่างโจทย์ระดับง่าย

เขียนฟังก์ชันและเรียกใช้ฟังก์ชัน

count1_10 โดยให้พิมพ์เลข 1 ถึง 10 ภายในบรรทัดเดียว
count1_N โดยให้พิมพ์เลข 1 ถึง n โดยกำหนดให้ n เป็นพารามิเตอร์
su_string คืนค่าชื่อมหาวิทยาลัยศิลปากรเป็นภาษาอังกฤษ
trapezoid_area คำนวณพื้นที่สี่เหลี่ยมคางหมู โดยให้ความยาวสองด้านและความสูงเป็นพารามิเตอร์ ดูสูตรคำนวณพื้นที่จากรูปและตัวอย่างทดสอบจาก url ใต้รูป

image source: https://www.liviusprep.com/area-of-trapezoid

ตัวอย่างโจทย์ระดับกลาง

ชื่อฟังก์ชัน sum_n
พารามิเตอร์ จำนวนเต็ม n
การทำงาน คำนวณหาผลรวมตั้งแต่เลข 1 ถึง n
คืนค่า ผลการคำนวณ

# main program

n = int(input('n = '))

result = sum_n(n)

print('sum of 1 to %d = %d' % (n, result))

hint โค้ดแบบยังไม่เขียนเป็นฟังก์ชัน

n = int(input('n = '))

sum = 0

for i in range(1, n+1):

sum = sum + i

print(sum)

ชื่อฟังก์ชัน sum_5
พารามิเตอร์ ไม่มี
การทำงาน หาผลรวมและค่าเฉลี่ยของเลขที่ผู้ใช้ใส่เข้ามา 5 จำนวน
คืนค่า ผลรวมและค่าเฉลี่ย

# function definition

def sum_5():

return

# main program

total, avg = sum_5()

print('sum = %d' % total)

print('average = %.2f' % avg)

hint โค้ดแบบยังไม่เขียนเป็นฟังก์ชัน

sum_n = 0

for i in range(5):

n = int(input())

sum_n = sum_n + n

print('sum =', sum_n)

print('average = %.2f' % (sum_n/5))

output

20
1
34
8
15
sum = 78
average = 15.60

โจทย์ สร้างฟังก์ชันเพื่อคำนวณค่าส่งอาหาร โดยใน main program รับค่าอาหารและระยะทางจากผู้ใช้ และแสดงผลลัพธ์เป็นค่าส่ง และยอดรวม (ค่าส่ง+ค่าอาหาร)

ชื่อฟังก์ชัน sudelivery
พารามิเตอร์ .....
การทำงาน ค่าส่งเริ่มต้น 10 บาท สำหรับ 1-5 กิโลเมตรแรก และกิโลเมตรถัดไปกิโลเมตรละ 10 บาท โดยระยะทางถ้าเศษ 0.5 ขึ้นไปให้ปัดค่าขึ้น
คืนค่า ......

การปัดเลขทศนิยมเป็นจำนวนเต็มบวก ใช้การบวกค่าระยะทางด้วย 0.5 แล้วปัดเป็นจำนวนเต็ม

# function definition

def sudelivery(...):

...

return ...

# main program

food = float(input())

distance = float(input())

cost = sudelivery(distance)

print('shipping cost = %.1f' % cost)

print('total cost = %.1f' % (cost + food))

Output

160.0
8.5
shipping cost = 50.0

total cost = 210.0

Output

800.0
9.6
shipping cost = 60.0

total cost = 860.0

Output

100.0
0.4
shipping cost = 10.0

total cost = 110.0

โจทย์ สร้างฟังก์ชันเพื่อนับจำนวนสระ (aeiou) และพยัญชนะทั้งหมด โดยใน main program รับ string จากผู้ใช้ และแสดงผลลัพธ์

ออกแบบและสร้างฟังก์ชันเอง แล้วทดลองเรียกใช้เพื่อทดสอบความถูกต้อง

ชื่อฟังก์ชัน
พารามิเตอร์
การทำงาน
คืนค่า

hint โค้ดแบบยังไม่เขียนเป็นฟังก์ชัน

nvows, ncons = 0, 0

str = input()

for ch in str:

if ch in "aeiou":

nvows += 1

else:

ncons += 1

print(nvows)

print(ncons)

โจทย์ สร้างฟังก์ชันเพื่อพิมพ์สูตรคูณแม่ n โดยใน main program รับค่า n จากผู้ใช้ และแสดงผลลัพธ์

ออกแบบและสร้างฟังก์ชันเอง แล้วทดลองเรียกใช้เพื่อทดสอบความถูกต้อง

ชื่อฟังก์ชัน
พารามิเตอร์
การทำงาน
คืนค่า

hint โค้ดแบบยังไม่เขียนเป็นฟังก์ชัน

n = int(input("n = "))

for i in range(1,13):

print("%d x %2d = %3d" % (n, i, n*i))

Output

n = 5

5 x 1 = 5

5 x 2 = 10

5 x 3 = 15

5 x 4 = 20

5 x 5 = 25

5 x 6 = 30

5 x 7 = 35

5 x 8 = 40

5 x 9 = 45

5 x 10 = 50

5 x 11 = 55

5 x 12 = 60

โจทย์ สร้างฟังก์ชันเพื่อคำนวณว่าเป็นปี leap year หรือไม่ โดยให้คำตอบว่าเป็นจริงหรือเท็จ (ดูคำสั่งการทำงานจากตัวอย่าง nested_if2.py ในหัวข้อคำสั่งเงื่อนไข) โดยใน main program รับปีจากผู้ใช้ และแสดงผลลัพธ์

ออกแบบและสร้างฟังก์ชันเอง แล้วทดลองเรียกใช้เพื่อทดสอบความถูกต้อง

ชื่อฟังก์ชัน
พารามิเตอร์
การทำงาน
คืนค่า

Output

year = 2000

Leap year

year = 1900

Not leap year

year = 2003

Not leap year

year = 2008

Leap year

Page updated

Report abuse