สนุกคิด สนุกโค้ด ด้วยภาษาไพทอน

2. การแสดงผลข้อมูล (Displaying Output)

ในการเขียนโปรแกรม เราจำเป็นต้องแสดงผลลัพธ์ ไม่ว่าจะเป็นข้อความ, ค่าในตัวแปร, หรือผลจากการคำนวณ ให้ผู้ใช้ได้เห็น คำสั่งพื้นฐานและสำคัญที่สุดใน Python สำหรับงานนี้คือ print()

เราสามารถใส่ข้อมูลที่เราต้องการแสดงไว้ในวงเล็บ () ของคำสั่ง print ได้หลายรูปแบบ มาดูกันครับ

วิธีที่ 1: การแสดงข้อความตรงๆ

วิธีที่ง่ายที่สุดคือการใส่ข้อความที่ต้องการแสดงไว้ในเครื่องหมายคำพูด " " หรือ ' '

print("สวัสดีชาวโลก! ยินดีต้อนรับสู่โลกของ Python")
print('การเรียนเขียนโปรแกรมเป็นเรื่องสนุก!')

วิธีที่ 2: การใช้เครื่องหมายจุลภาค (,) เพื่อแสดงผลหลายค่า

เราสามารถแสดงผลข้อมูลหลายชิ้นพร้อมกันได้โดยใช้เครื่องหมาย , (comma) คั่น Python จะเว้นวรรคให้ระหว่างข้อมูลแต่ละชิ้นโดยอัตโนมัติ

player_name = "Cyber Knight"
level = 25
print("ผู้เล่น:", player_name, "มีเลเวล:", level)
# ผลลัพธ์: ผู้เล่น: Cyber Knight มีเลเวล: 25

วิธีที่ 3: การต่อข้อความ (String Concatenation) ด้วยเครื่องหมาย +

เราสามารถนำข้อความมาต่อกันเป็นสายยาวๆ ได้ด้วยเครื่องหมาย + แต่มีข้อควรระวังคือ วิธีนี้ใช้ได้กับข้อมูลประเภท String เท่านั้น หากต้องการต่อกับตัวเลข ต้องแปลงตัวเลขเป็น String ก่อนด้วยคำสั่ง str()

item_name = "ดาบแห่งแสง"
damage = 150
# แปลงตัวเลข 150 ให้เป็นข้อความ "150" ก่อนนำมาต่อ
description = "ไอเทม: " + item_name + " สร้างความเสียหาย " + str(damage) + " หน่วย"
print(description)

# ผลลัพธ์: ไอเทม: ดาบแห่งแสง สร้างความเสียหาย 150 หน่วย

วิธีที่ 4: การใช้ f-string (วิธีที่แนะนำและทันสมัยที่สุด)

f-string คือรูปแบบการจัดข้อความที่ง่ายและทรงพลังที่สุด เพียงแค่วางตัวอักษร f ไว้หน้าเครื่องหมายคำพูด แล้วใส่ชื่อตัวแปรหรือนิพจน์ทางคณิตศาสตร์ไว้ในวงเล็บปีกกา { } ได้เลย ทำให้เราสามารถแสดงผลตัวแปรหลายๆ ตัวผสมกับข้อความได้อย่างเป็นธรรมชาติ

การจัดรูปแบบการแสดงผล (Formatting)

จุดเด่นของ f-string คือเราสามารถ "จัดรูปแบบ" การแสดงผลได้ทันที เช่น การกำหนดจำนวนทศนิยมสำหรับตัวเลข float ซึ่งมีประโยชน์มากในการแสดงราคาสินค้า หรือคะแนนเฉลี่ย เราจะใช้เครื่องหมาย : (colon) ตามด้วยรูปแบบที่ต้องการ เช่น :.2f หมายถึง "แสดงผลเป็นเลขทศนิยม (float) 2 ตำแหน่ง"

name = "ลิซ่า"
score = 1250
age = 17
gpa = 3.8759 # เกรดเฉลี่ยมีทศนิยมหลายตำแหน่ง
# 1. แสดงค่าจากตัวแปรหลายตัวใน print() เดียว
print(f"ผู้เล่น {name} มีคะแนน {score} คะแนน")

# 2. สามารถคำนวณในวงเล็บปีกกาได้เลย
print(f"ปีหน้า {name} จะมีอายุ {age + 1} ปี")

# 3. การจัดรูปแบบทศนิยมให้เหลือ 2 ตำแหน่ง
# สังเกตการใช้ :.2f เพื่อบังคับให้แสดงผลทศนิยม 2 ตำแหน่ง (มีการปัดเศษให้อัตโนมัติ)
print(f"เกรดเฉลี่ยของเธอคือ {gpa:.2f}")

# 4. รวมทุกอย่างไว้ใน print() เดียวกัน
print(f"สรุป: ผู้เล่น {name} อายุ {age} ปี มีคะแนน {score} และเกรดเฉลี่ย {gpa:.2f}")

# --- ผลลัพธ์ ---
# ผู้เล่น ลิซ่า มีคะแนน 1250 คะแนน
# ปีหน้า ลิซ่า จะมีอายุ 18 ปี
# เกรดเฉลี่ยของเธอคือ 3.88
# สรุป: ผู้เล่น ลิซ่า อายุ 17 ปี มีคะแนน 1250 และเกรดเฉลี่ย 3.88

โบนัส: การใช้อักขระพิเศษ (Escape Characters)

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

• \n : ใช้สำหรับขึ้นบรรทัดใหม่ (New Line)
• \t : ใช้สำหรับเว้นวรรคเป็นระยะเท่ากับ 1 แท็บ (Tab)

print("--- รายงานผลการเรียน ---\nชื่อ: เด็กชายสมศักดิ์\n\tวิชา: วิทยาศาสตร์\n\tเกรด: A")

โจทย์ฝึกทักษะ: สร้างโปรไฟล์ตัวละครในเกม

สมมติว่าเรากำลังสร้างเกม RPG และต้องการแสดงหน้าต่างสถานะของตัวละคร ให้นักเรียนใช้ความรู้เรื่อง print() และ f-string เพื่อสร้างข้อความแสดงผลตามที่กำหนด

character_name = "Shadow Striker"
character_class = "Assassin"
level = 15
gold = 580.50

ทดลองเขียนโค้ดของคุณที่นี่

3. การรับค่าจากผู้ใช้ (User Input)

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

กฎทองของการรับค่า: ทุกอย่างคือข้อความ (String)

สิ่งสำคัญที่สุดที่ต้องจำคือ: ข้อมูลทุกอย่างที่รับมาจากคำสั่ง input() จะมีประเภทเป็นข้อความ (String) เสมอ! แม้ว่าผู้ใช้จะพิมพ์ตัวเลขเข้ามาก็ตาม เช่น ถ้าผู้ใช้พิมพ์ `15` โปรแกรมจะมองว่าเป็นข้อความ `"15"` ไม่ใช่ตัวเลข `15`

ดังนั้น หากเราต้องการนำค่าที่รับมาไปคำนวณทางคณิตศาสตร์ เราจึงจำเป็นต้อง "แปลงประเภทข้อมูล" (Type Casting) ด้วยคำสั่ง int() สำหรับจำนวนเต็ม หรือ float() สำหรับทศนิยม

ตัวอย่างที่ 1: การรับชื่อ (String)

กรณีนี้ง่ายที่สุด เพราะข้อมูลที่ได้เป็น String อยู่แล้ว เราสามารถนำไปใช้ได้เลย

player_name = input("กรุณาใส่ชื่อของคุณ: ")
print(f"ยินดีต้อนรับ, ท่าน {player_name}!")

ตัวอย่างที่ 2: การรับอายุ (Integer)

เราต้องรับค่ามาเป็น String ก่อน แล้วจึงแปลงเป็น Integer ด้วย int() เพื่อนำไปคำนวณต่อ

# แบบทีละขั้นตอน (เหมาะสำหรับผู้เริ่มต้น)
age_str = input("คุณอายุเท่าไหร่: ") # รับค่ามาเป็น String เช่น "16"
age_int = int(age_str) # แปลง "16" ให้เป็นตัวเลข 16
print(f"สุดยอด! อีก 10 ปีข้างหน้า คุณจะอายุ {age_int + 10} ปี")

# แบบรวบรัด (นิยมใช้)
your_age = int(input("ใส่อายุของคุณอีกครั้ง: "))
print(f"คุณเกิดปี ค.ศ. ประมาณ {2567 - your_age}")

ตัวอย่างที่ 3: การรับส่วนสูง (Float)

เหมือนกับการรับ Integer แต่เราใช้ float() เพื่อแปลงเป็นตัวเลขทศนิยม

height_m = float(input("คุณสูงกี่เมตร (เช่น 1.75): "))
print(f"ถ้าคุณสูงขึ้นอีก 5 ซม. คุณจะสูง {height_m + 0.05} เมตร")

โจทย์ท้าทาย: สร้างบัตรนักเรียนดิจิทัล

มาลองสร้างโปรแกรมเล็กๆ ที่ใช้รับข้อมูลส่วนตัวของนักเรียน แล้วนำมาแสดงผลเป็น "บัตรนักเรียนดิจิทัล" ที่สวยงามกันเถอะ!

ทดลองเขียนโค้ดของคุณที่นี่

4. โจทย์ปัญหาเพื่อฝึกฝนทักษะ

ถึงเวลาที่เราจะนำความรู้ทั้งหมดที่เรียนมา ทั้งเรื่องตัวแปร, การรับค่า (input), การแปลงประเภทข้อมูล, การคำนวณ และการแสดงผล (print) มาใช้แก้ปัญหาจริงกันแล้ว! ลองพยายามแก้โจทย์แต่ละข้อด้วยตัวเองดูนะครับ

5. การตัดสินใจด้วยเงื่อนไข (if-elif-else)

ในชีวิตจริง เราต้องตัดสินใจอยู่ตลอดเวลา เช่น "ถ้าฝนตก, จะพกร่มไปด้วย" หรือ "ถ้าหิว, จะไปหาอะไรกิน" ในโลกของการเขียนโปรแกรมก็เช่นกัน เราต้องสอนให้โปรแกรม "ตัดสินใจ" ตามสถานการณ์ต่างๆ ได้ ซึ่งเครื่องมือที่เราใช้คือ โครงสร้างเงื่อนไข (Conditional Statements) ครับ

Python มีโครงสร้างเงื่อนไขหลักๆ อยู่ 3 รูปแบบ คือ if, if-else, และ if-elif-else

รูปแบบที่ 1: if (เงื่อนไขเดียว)

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

สถานการณ์: เราจะสามารถเปิดหีบสมบัติได้ ก็ต่อเมื่อเรามีกุญแจ

has_key = True # ลองเปลี่ยนเป็น False แล้วรันดู
if has_key == True:
    print("คุณใช้กุญแจและเปิดหีบสมบัติ!")
    print("คุณได้รับดาบในตำนาน!")

# สังเกต: ถ้า has_key เป็น False โปรแกรมจะข้ามคำสั่ง print ทั้งสองไปเลย

รูปแบบที่ 2: if-else (สองทางเลือก)

ใช้เมื่อเรามีทางเลือก 2 ทาง คือ "ถ้าเงื่อนไขเป็นจริง ให้ทำอย่างหนึ่ง, แต่ถ้าไม่จริง (เป็นเท็จ) ให้ไปทำอีกอย่างหนึ่ง"

สถานการณ์: ตรวจสอบผลสอบ ถ้าคะแนนมากกว่าหรือเท่ากับ 50 ถือว่า "สอบผ่าน" นอกนั้น "สอบตก"

score = int(input("Enter your score: "))
if score >= 50:
    print("ยินดีด้วย! คุณสอบผ่าน (Congratulations! You passed.)")
else:
    print("เสียใจด้วย คุณสอบตก (Sorry, you failed.)")

print("--- สิ้นสุดการประมวลผล ---")

รูปแบบที่ 3: if-elif-else (หลายทางเลือก)

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

สถานการณ์: โปรแกรมตัดเกรดจากคะแนนสอบ

score = int(input("กรอกคะแนน (0-100): "))
if score >= 80:
    grade = "A"
elif score >= 70: # elif ย่อมาจาก "else if"
    grade = "B"
elif score >= 60:
    grade = "C"
elif score >= 50:
    grade = "D"
else: # ถ้าไม่มีเงื่อนไขไหนข้างบนเป็นจริงเลย
    grade = "F"

print(f"คุณได้เกรด: {grade}")

รูปแบบที่ 4: if ซ้อน if (Nested if)

เราสามารถมีเงื่อนไขซ้อนอยู่ข้างในเงื่อนไขได้ ใช้สำหรับสถานการณ์ที่ซับซ้อนขึ้น

สถานการณ์: การเข้าร่วมกิจกรรมพิเศษ ต้องมีเลเวล 20 ขึ้นไป และต้องมีไอเทม "ตั๋วกิจกรรม" ด้วย

level = 25
has_ticket = False
if level >= 20:
    print("เงื่อนไขเลเวลผ่าน! กำลังตรวจสอบตั๋ว...")
    if has_ticket == True:
        print("คุณมีตั๋ว! ยินดีต้อนรับสู่กิจกรรมพิเศษ!")
    else:
        print("น่าเสียดาย คุณยังไม่มีตั๋วกิจกรรม")
else:
    print("เลเวลของคุณยังไม่ถึง 20 ไม่สามารถเข้าร่วมได้")

โจทย์ท้าทาย: โปรแกรมคำนวณค่าน้ำประปาอัตราก้าวหน้า

ลองใช้ความรู้เรื่อง if-elif-else มาแก้ปัญหาในชีวิตจริงกันดูครับ

6. การทำงานซ้ำด้วย Loop

ลองนึกภาพว่าคุณต้องเขียนโปรแกรมเพื่อแสดงข้อความ "Hello" 100 ครั้ง การจะเขียนคำสั่ง print("Hello") 100 บรรทัดคงเป็นเรื่องที่น่าเบื่อและไม่ฉลาดนัก Loop คือเครื่องมือทรงพลังที่ช่วยให้เราสั่งโปรแกรมให้ทำงานบางอย่างซ้ำๆ ตามจำนวนรอบหรือเงื่อนไขที่เรากำหนดได้

ใน Python มี Loop หลักๆ 2 ประเภทคือ while และ for ซึ่งมีวิธีการใช้งานที่แตกต่างกัน

1. While Loop: วนซ้ำจนกว่าเงื่อนไขจะไม่เป็นจริง

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

การใช้งานพื้นฐาน

เราจะสร้างตัวนับ แล้ววนลูปไปเรื่อยๆ จนกว่าตัวนับจะถึงค่าที่กำหนด

count = 1 # 1. ตั้งค่าเริ่มต้นให้ตัวแปร
while count <= 5: # 2. ตรวจสอบเงื่อนไข
    print(f"รอบที่ {count}")
    count = count + 1 # 3. อัปเดตค่าตัวแปร (สำคัญมาก! ไม่งั้นจะกลายเป็นลูปไม่รู้จบ)
print("จบการทำงานของ while loop")

While Loop ไม่รู้จบ และการใช้ break

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

สถานการณ์: โปรแกรมบวกเลขสะสม ผู้ใช้จะป้อนตัวเลขเข้ามาเรื่อยๆ และโปรแกรมจะนำไปบวกสะสมไว้ จนกว่าผู้ใช้จะป้อนเลข 0 เพื่อบอกว่าพอแล้ว

total = 0
print("โปรแกรมบวกเลขสะสม (ป้อน 0 เพื่อจบการทำงาน)")
while True: # เริ่มลูปไม่รู้จบ
    num_str = input("ป้อนตัวเลข: ")
    num = int(num_str)
    if num == 0:
        print("คุณป้อน 0, กำลังออกจากโปรแกรม...")
        break  # ออกจาก while loop ทันที!
    total = total + num
    print(f"ยอดรวมตอนนี้คือ: {total}")
print(f"ยอดรวมสุดท้ายคือ {total}")

2. For Loop: วนซ้ำตามสมาชิกในกลุ่มข้อมูล

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

ทำความรู้จักกับ List

ก่อนจะใช้ `for` loop ให้เต็มประสิทธิภาพ เราต้องรู้จักกับ List ก่อน ลองนึกภาพว่า List คือกล่องยาวๆ ที่มีช่องเก็บของได้หลายช่อง เราสามารถเก็บข้อมูลอะไรก็ได้ (ตัวเลข, ข้อความ) ไว้ใน List โดยใช้เครื่องหมาย [ ] ครอบและใช้ , คั่นข้อมูลแต่ละตัว

# List ของข้อความ (String)
player_classes = ["Knight", "Mage", "Archer", "Thief"]
# List ของตัวเลข (Integer)
scores = [88, 92, 75, 100, 64]

การวนลูปใน List (For-each Loop)

นี่คือรูปแบบการใช้ `for` loop ที่พบบ่อยและทรงพลังที่สุด เราสามารถสั่งให้โปรแกรมหยิบของออกมาจาก List ทีละชิ้น แล้วนำมาใช้งานได้เลย

player_classes = ["Knight", "Mage", "Archer", "Thief"]
# "สำหรับแต่ละ class ใน player_classes ให้ทำ..."
for p_class in player_classes:
    print(f"- {p_class} is a valid class.")

# ผลลัพธ์:
# - Knight is a valid class.
# - Mage is a valid class.
# - Archer is a valid class.
# - Thief is a valid class.

การใช้ for loop คู่กับ range()

แล้วถ้าเราแค่อยากจะวนลูปตามจำนวนรอบที่กำหนดล่ะ? เราสามารถใช้ฟังก์ชัน range() เพื่อสร้างชุดของตัวเลขขึ้นมาให้ `for` loop วิ่งตามได้

• range(stop): สร้างตัวเลขตั้งแต่ 0 ไปจนถึง *ก่อน* ที่จะถึงค่า stop
• range(start, stop): สร้างตัวเลขตั้งแต่ค่า start ไปจนถึง *ก่อน* ที่จะถึงค่า stop
• range(start, stop, step): สร้างตัวเลขตั้งแต่ค่า start ไปจนถึง *ก่อน* ที่จะถึงค่า stop โดยจะเพิ่มขึ้นทีละ step

# วนลูป 5 รอบ (i จะเป็น 0, 1, 2, 3, 4)
print("--- วนลูป 5 รอบ ---")
for i in range(5):
    print(f"รอบที่ {i}")
# วนลูปตั้งแต่ 1 ถึง 5
print("\n--- วนลูปตั้งแต่ 1 ถึง 5 ---")
for i in range(1, 6):
    print(i, end=" ") # ผลลัพธ์: 1 2 3 4 5

# วนย้อนกลับ
print("\n--- นับถอยหลัง 5 ถึง 1 ---")
for i in range(5, 0, -1):
    print(i, end=" ") # ผลลัพธ์: 5 4 3 2 1

โจทย์ฝึกทักษะ: โปรแกรมแสดงสูตรคูณ

มาลองใช้ for loop และ range() เพื่อสร้างโปรแกรมที่มีประโยชน์กันดีกว่า

ทดลองเขียนโค้ดของคุณที่นี่

7. โจทย์ปัญหาประยุกต์ (Applied Problems)

ยินดีด้วยครับ! ตอนนี้คุณได้เรียนรู้เครื่องมือพื้นฐานที่จำเป็นครบแล้ว ทั้งการรับค่า, การแสดงผล, การคำนวณ, การสร้างเงื่อนไข และการทำงานซ้ำ ถึงเวลาที่จะนำเครื่องมือทั้งหมดนี้มาประกอบกันเพื่อสร้างโปรแกรมที่ซับซ้อนและแก้ปัญหาในสถานการณ์จริงกันแล้ว

8. ฟังก์ชัน (Function)

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

1. ฟังก์ชันคืออะไร? มีประโยชน์อย่างไร?

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

2. ฟังก์ชันที่มีอยู่แล้ว (Built-in & Module Functions)

Python ใจดีมีฟังก์ชันที่สร้างไว้ให้เราใช้ได้ทันทีมากมาย บางฟังก์ชันก็พร้อมใช้เลย (เช่น print(), int(), len()) แต่บางฟังก์ชันที่เฉพาะทางมากขึ้นจะถูกเก็บไว้ใน "กล่องเครื่องมือพิเศษ" ที่เรียกว่า โมดูล (Module) ซึ่งเราต้องสั่ง import เข้ามาก่อนใช้งาน

ตัวอย่างจากโมดูล math

เป็นโมดูลที่รวบรวมฟังก์ชันทางคณิตศาสตร์ขั้นสูง

import math # สั่งนำเข้ากล่องเครื่องมือ math
# math.sqrt() - ถอดรากที่สอง
num1 = 81
print(f"รากที่สองของ {num1} คือ {math.sqrt(num1)}") # ผลลัพธ์: 9.0

# math.ceil() - ปัดเศษขึ้นเสมอ
num2 = 4.1
print(f"ปัดเศษขึ้นของ {num2} คือ {math.ceil(num2)}") # ผลลัพธ์: 5

# math.pi - ค่าพาย
radius = 7
area = math.pi * (radius ** 2)
print(f"พื้นที่วงกลมรัศมี {radius} คือ {area:.2f}") # ผลลัพธ์: 153.94

ตัวอย่างจากโมดูล random

เป็นโมดูลที่ใช้สำหรับการสุ่ม ซึ่งจำเป็นมากในการสร้างเกม

import random # สั่งนำเข้ากล่องเครื่องมือ random
# random.randint(a, b) - สุ่มตัวเลขจำนวนเต็มจาก a ถึง b (รวม a และ b ด้วย)
dice_roll = random.randint(1, 6)
print(f"ทอยลูกเต๋าได้เลข: {dice_roll}") # ผลลัพธ์: (ตัวเลขสุ่มระหว่าง 1-6)

# random.choice(list) - สุ่มเลือกสมาชิก 1 ตัวจาก List
loot = ["ดาบ", "โล่", "ยาเพิ่มเลือด", "แผนที่"]
found_item = random.choice(loot)
print(f"คุณเปิดหีบสมบัติเจอ: {found_item}") # ผลลัพธ์: (สุ่มไอเทม 1 ชิ้นจาก List)

3. การสร้างฟังก์ชันของเราเอง (User-Defined Functions)

ถึงส่วนที่สนุกที่สุดแล้ว! คือการสร้าง "เครื่องจักร" ของเราเอง

3.1 การสร้างฟังก์ชันอย่างง่าย (ไม่มีการรับ-ส่งค่า)

เป็นฟังก์ชันที่ทำหน้าที่ตามที่สั่งเท่านั้น ไม่ต้องการข้อมูลเข้าและไม่มีการส่งผลลัพธ์กลับมา เหมาะสำหรับการแสดงผลข้อความซ้ำๆ

# 1. การ "นิยาม" ฟังก์ชัน
def show_menu():
    print("--- Welcome to My Game ---")
    print("1. Start Game")
    print("2. Settings")
    print("3. Exit")
# 2. การ "เรียกใช้" ฟังก์ชัน
print("โปรแกรมเริ่มทำงาน...")
show_menu() # เรียกใช้ครั้งที่ 1
print("--------------------------")
# ... โค้ดอื่นๆ ...
show_menu() # เรียกใช้ครั้งที่ 2

3.2 การสร้างฟังก์ชันที่มีการรับ-ส่งค่า (Parameters & Return)

นี่คือรูปแบบที่ใช้งานบ่อยที่สุด

• พารามิเตอร์ (Parameter): คือ "ข้อมูลนำเข้า" ที่ฟังก์ชันต้องการเพื่อใช้ในการทำงาน เราจะกำหนดไว้ในวงเล็บ () ตอนที่สร้างฟังก์ชัน
• การคืนค่า (Return): คือ "ผลลัพธ์" ที่ฟังก์ชันจะส่งกลับออกมาให้โปรแกรมหลักหลังทำงานเสร็จ เราใช้คำสั่ง return

import math
# นิยามฟังก์ชันที่รับ "radius" เป็นพารามิเตอร์
def calculate_circle_area(radius):
    area = math.pi * (radius ** 2)
    return area # คืนค่า "area" ที่คำนวณได้ออกไป

# --- โปรแกรมหลัก ---
# เรียกใช้ฟังก์ชันโดยส่งค่า 10 เข้าไป
my_area = calculate_circle_area(10)
# ตอนนี้ตัวแปร my_area จะเก็บผลลัพธ์ที่ฟังก์ชัน return กลับมา

print(f"พื้นที่ของวงกลมรัศมี 10 คือ {my_area:.2f}")

# เราสามารถเรียกใช้ซ้ำกับค่าอื่นได้
small_area = calculate_circle_area(3)
print(f"พื้นที่ของวงกลมรัศมี 3 คือ {small_area:.2f}")

โจทย์ประยุกต์: โปรแกรมผู้ช่วยคำนวณเรขาคณิต

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

ทดลองเขียนโค้ดของคุณที่นี่