ลูปและเงื่อนไขใน Python: for, while, range, enumerate, break, if/elif และ match/case

ลูปใน Python ใช้สำหรับทำซ้ำการกระทำ เช่น ไล่ดูรายการที่ต้องซื้อ ประมวลผลทีละบรรทัดของไฟล์ หรือถามผู้ใช้จนกว่าจะกรอกตัวเลขที่ถูกต้อง ภาษามีลูปสองแบบคือ for และ while ส่วนการตัดสินใจภายในลูปทำได้ด้วยเงื่อนไข if/elif/else และคำสั่ง match/case บทความนี้อธิบายเครื่องมือแต่ละตัวพร้อมตัวอย่างที่ใช้งานได้จริง

เงื่อนไข: if, elif, else

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

spent = 4200
limit = 5000

if spent > limit:
    print("เกินงบประมาณแล้ว")
elif spent > limit * 0.8:
    print("เหลืองบประมาณน้อยกว่า 20%")
else:
    print("ทุกอย่างเป็นปกติ")

กิ่ง elif ถูกตรวจจากบนลงล่าง และจะทำงานเฉพาะกิ่งแรกที่ตรงเงื่อนไข ดังนั้นให้วางเงื่อนไขที่เข้มงวดกว่าไว้ด้านบน หากวางการตรวจ spent > limit * 0.8 ไว้ก่อน ข้อความว่าเกินงบประมาณจะไม่มีวันปรากฏ

อะไรถือว่าเป็นจริง

ในเงื่อนไขไม่จำเป็นต้องเขียนการเปรียบเทียบเสมอไป ค่าที่ถือว่าเท็จได้แก่ False None ศูนย์ (0, 0.0) และคอลเลกชันว่าง ได้แก่ "" [] {} ค่าอื่นทั้งหมดเป็นจริง ดังนั้นการตรวจว่า "ลิสต์ไม่ว่าง" เขียนได้สั้น ๆ ดังนี้:

expenses = []
if not expenses:
    print("ยังไม่มีรายจ่าย")

เงื่อนไขรวมกันได้ด้วย and or not และการตรวจช่วงค่าทำได้สะดวกด้วยการเปรียบเทียบต่อกัน เช่น if 0 < amount <= 100_000: สำหรับการเลือกค่าแบบสั้น ๆ มีตัวดำเนินการสามส่วน (ternary): status = "สูง" if spent > limit else "ปกติ"

ลูป for ใน Python: ไวยากรณ์และตัวอย่าง

ลูป for ใน Python ไม่ใช่ตัวนับแบบภาษา C แต่เป็นการวนผ่านสมาชิกทีละตัว มันหยิบแต่ละสมาชิกของอ็อบเจกต์ที่วนซ้ำได้ เช่น ลิสต์ สตริง ดิกชันนารี ไฟล์ หรือช่วง range ลูปแบบ foreach ในภาษาอื่นก็คือ for ธรรมดานี่เอง

expenses = [350, 1200, 89, 4500]
total = 0
for amount in expenses:
    total += amount
print(total)  # 6139

รูปแบบไวยากรณ์คือ for ตัวแปร in คอลเลกชัน: ตามด้วยบล็อกที่เยื้อง ตัวแปรหลังลูปจะยังคงเก็บค่าสุดท้ายไว้ บางครั้งก็มีประโยชน์ แต่ไม่ควรพึ่งพาพฤติกรรมนี้ในโปรแกรมขนาดใหญ่

วนลูปสตริง ลิสต์ และดิกชันนารี

สตริงถูกวนทีละอักขระ ลิสต์ถูกวนทีละสมาชิก ส่วนการวนดิกชันนารีจะได้คีย์เป็นค่าเริ่มต้น หากต้องการทั้งคีย์และค่าพร้อมกันให้ใช้ .items()

by_category = {"อาหาร": 3200, "เดินทาง": 900, "หนัง": 600}

for category, amount in by_category.items():
    print(f"{category}: {amount} บาท")

หากต้องการเฉพาะค่า ใช้ .values() ห้ามเปลี่ยนขนาดดิกชันนารีระหว่างการวน ไม่เช่นนั้นจะได้ RuntimeError: dictionary changed size during iteration หากต้องการลบรายการระหว่างวน ให้วนบนสำเนา: for key in list(d):

ฟังก์ชัน range: ลูปผ่านตัวเลข

เมื่อต้องวนผ่านตัวเลข ให้ใช้ range() มันไม่สร้างลิสต์ในหน่วยความจำ แต่ให้ตัวเลขทีละตัว ดังนั้น range(10**9) จึงทำงานได้ทันที

กฎสำคัญคือขอบเขตด้านขวาไม่รวมอยู่ในช่วง range(1, 10) จะจบที่ 9 ซึ่งเป็นสาเหตุของข้อผิดพลาด "ผิดไปหนึ่ง" ที่พบบ่อย ค่าขั้น (step) ติดลบได้ แต่ห้ามเป็นศูนย์

for i in range(1, 4):
    print(f"วันที่ {i}")
# วันที่ 1
# วันที่ 2
# วันที่ 3

enumerate: ตัวนับในลูป

มือใหม่มักเขียน for i in range(len(items)) เพื่อรู้ลำดับของสมาชิก วิธีนี้ใช้ได้แต่อ่านยาก ฟังก์ชัน enumerate() คืนคู่ "ลำดับ, สมาชิก" และพารามิเตอร์ start กำหนดว่าจะเริ่มนับจากเลขใด

items = ["กาแฟ", "แท็กซี่", "อาหารกลางวัน"]
for n, item in enumerate(items, start=1):
    print(n, item)
# 1 กาแฟ
# 2 แท็กซี่
# 3 อาหารกลางวัน

สำหรับการวนสองลิสต์พร้อมกันใช้ zip() เช่น for name, price in zip(names, prices): ซึ่งจะหยุดเมื่อถึงลิสต์ที่สั้นที่สุด ตั้งแต่ Python 3.10 สามารถส่ง strict=True ได้ หากความยาวไม่เท่ากันจะเกิดข้อผิดพลาดทันที

ลูป while ใน Python

ลูป while ทำซ้ำบล็อกตราบที่เงื่อนไขเป็นจริง ใช้เมื่อไม่รู้จำนวนรอบล่วงหน้า เช่น รอการกรอกค่าที่ถูกต้อง อ่านข้อมูลจนหมด หรือลองขอข้อมูลซ้ำจนสำเร็จ

balance = 10_000
month = 0
while balance > 0:
    balance -= 2_700
    month += 1
print(f"เงินพอใช้ได้ {month} เดือน")  # 4

อันตรายหลักคือการลืมเปลี่ยนค่าตัวแปรที่อยู่ในเงื่อนไข ลูปจะไม่มีวันจบ หากโปรแกรมค้าง ให้กด Ctrl+C Python จะหยุดการทำงานด้วย KeyboardInterrupt

ลูปไม่สิ้นสุดและ do while

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

while True:
    raw = input("จำนวนเงิน: ")
    if raw.isdigit():
        amount = int(raw)
        break
    print("กรุณาพิมพ์จำนวนเต็ม")

ลูป for ที่ไม่สิ้นสุดพบได้น้อย มักเกิดเมื่อวนผ่านตัววนซ้ำที่ไม่มีที่สิ้นสุด เช่น itertools.count()

break และ continue: ออกจากลูปและข้ามรอบ

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

expenses = [350, -10, 1200, 0, 99_999, 89]

for amount in expenses:
    if amount <= 0:
        continue          # ข้ามรอบนี้
    if amount > 50_000:
        print("จำนวนเงินน่าสงสัย หยุดการทำงาน")
        break             # ออกจากลูป
    print(amount)

โค้ดนี้จะพิมพ์ 350 และ 1200 จากนั้นแสดงข้อความแจ้งเตือน และลูปจะไม่ไปถึง 89 ทั้งสองคำสั่งมีผลเฉพาะลูปที่อยู่ใกล้ที่สุดเท่านั้น

else ของลูป

for และ while มีบล็อก else ที่ไม่ค่อยพบในภาษาอื่น บล็อกนี้จะทำงานเมื่อลูปจบเองตามปกติ โดยไม่ถูก break ซึ่งเหมาะกับการค้นหา:

for amount in expenses:
    if amount > 50_000:
        print("พบรายจ่ายจำนวนมาก")
        break
else:
    print("ไม่มีรายจ่ายจำนวนมาก")

ลูปซ้อนกัน

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

for row in range(1, 4):
    for col in range(1, 4):
        print(row * col, end="\t")
    print()

ควรระวังสองเรื่อง ประการแรก ความซับซ้อนเพิ่มขึ้นอย่างรวดเร็ว ลูปซ้อนสองชั้นที่ทำกับข้อมูลชั้นละ 10 000 รายการจะเป็น 100 ล้านการทำงาน ประการที่สอง break ออกจากลูปด้านในเท่านั้น หากต้องการหยุดทั้งสองลูป ให้ย้ายลูปไปไว้ในฟังก์ชันแล้วใช้ return ซึ่งอ่านง่ายกว่าการใช้ตัวแปรธง (flag)

คำสั่ง match/case

ตั้งแต่ Python 3.10 เราสามารถแทนที่โซ่ยาว ๆ ของ if cmd == ... elif ... ด้วยคำสั่ง match (PEP 634) นี่ไม่ใช่แค่ switch มันเปรียบเทียบค่ากับรูปแบบ (pattern) ตามโครงสร้างของข้อมูล และแยกส่วนประกอบออกมาเป็นตัวแปรทันที

def parse(text):
    match text.split():
        case ["add", item, amount]:
            return f"เพิ่ม {item}: {amount}"
        case ["list"] | ["ls"]:
            return "แสดงรายจ่าย"
        case ["quit"]:
            return "ออก"
        case _:
            return "ไม่รู้จักคำสั่งนี้"

print(parse("add กาแฟ 250"))  # เพิ่ม กาแฟ: 250
print(parse("add กาแฟ"))      # ไม่รู้จักคำสั่งนี้

รูปแบบลิสต์ ["add", item, amount] จะตรงกับลิสต์ที่มีสามสมาชิกพอดี และสมาชิกตัวแรกต้องเป็น "add" ดังนั้นคำสั่งที่ไม่มีจำนวนเงินจะตกไปยังกิ่ง _ ที่รับทุกกรณีที่เหลือ เครื่องหมาย | รวมตัวเลือกหลายแบบเข้าด้วยกัน

รูปแบบดิกชันนารี เงื่อนไขเสริม และการตรวจชนิด

รูปแบบดิกชันนารีจะตรวจเฉพาะคีย์ที่ระบุไว้ คีย์อื่นที่เหลือจะถูกละเว้น การเขียน int(a) ตรวจชนิดข้อมูลและเก็บค่าไว้ในตัวแปร ส่วน if ที่ตามหลังรูปแบบเป็นเงื่อนไขเพิ่มเติม (guard):

match event:
    case {"type": "expense", "amount": int(a)} if a > 10_000:
        print("รายจ่ายจำนวนมาก", a)
    case {"type": "expense", "amount": int(a)}:
        print("รายจ่าย", a)

กับดักหลักของ match

ชื่อที่เขียนเปล่า ๆ ใน case คือการจับค่า ไม่ใช่การเปรียบเทียบกับตัวแปร case limit: จะตรงกับทุกค่าและบันทึกค่านั้นลงใน limit หากต้องการเปรียบเทียบกับค่าคงที่ ให้ใช้ชื่อที่มีจุดนำหน้า เช่น case Color.RED: หรือใช้ค่าลิเทอรัล

ไวยากรณ์ match ตั้งแต่ 3.10 แทบไม่เปลี่ยนแปลง ใน Python 3.15 มีการปรับความไม่สมมาตรเล็กน้อย: ก่อนหน้านี้รูปแบบลิเทอรัลรองรับเฉพาะเครื่องหมายลบหน้าตัวเลข ตอนนี้สามารถเขียน case +1: ได้ด้วย โค้ดนี้จะให้ข้อผิดพลาดด้านไวยากรณ์บนเวอร์ชันเก่ากว่า

ข้อผิดพลาดที่พบบ่อยในลูป

• แก้ไขลิสต์ระหว่างการวน การลบสมาชิกใน for ทำให้ข้ามตัวที่อยู่ติดกัน ควรสร้างลิสต์ใหม่: clean = [x for x in items if x > 0]
• ขอบเขตของ range range(1, n) ไม่รวม n
• ลืมเปลี่ยนเงื่อนไขใน while ทำให้เป็นลูปไม่สิ้นสุด
• ต่อสตริงด้วย += ในลูป เมื่อข้อมูลมากจะช้ากว่า "".join(parts)
• ใช้การกำหนดค่าแทนการเปรียบเทียบ if x = 5 เป็นข้อผิดพลาดด้านไวยากรณ์ การเปรียบเทียบเขียนด้วย ==

โจทย์ฝึกเกี่ยวกับลูป

1. คำนวณผลรวมและค่าเฉลี่ยของรายการค่าใช้จ่าย โดยข้ามค่าติดลบ
2. พิมพ์ตารางสูตรคูณ 1–9 ด้วยลูปซ้อนกัน
3. ถามตัวเลขจากผู้ใช้จนกว่าจะกรอกบรรทัดว่าง แล้วแสดงค่าสูงสุด
4. หาตัวเลขตัวแรกที่มากกว่า 1000 ในลิสต์ และแจ้งหากไม่พบ (ด้วย for ... else)
5. แยกวิเคราะห์คำสั่ง add del และ list ด้วย match

สรุป

ลูปใน Python มีสองรูปแบบหลัก คือ for ที่วนผ่านคอลเลกชันหรือ range() และ while ที่ทำงานตราบที่เงื่อนไขยังเป็นจริง break และ continue ควบคุมการไหลของลูป enumerate() และ zip() ช่วยให้ไม่ต้องนับเอง ส่วน if/elif/else และ match/case รับผิดชอบการตัดสินใจ เครื่องมือทั้งหมดนี้ถูกสาธิตผ่านโปรแกรมบันทึกค่าใช้จ่ายในบทเรียนของคอร์ส Python