ข้ามไปยังเนื้อหาหลัก
Editor
ThePythonBookby pythoncompiler.io

ลูป while ใน Python: เมื่อลูป for ยังไม่พอ

เริ่มต้น20 นาที5 แบบฝึกหัด65 XP

บทเรียนนี้แปลจากต้นฉบับภาษาอังกฤษRead in EnglishLeer en españolЧитать на русскомLer em portuguêsแจ้งข้อผิดพลาดในการแปล

ก่อนเริ่มเรียน
ลูป for ใน Python: วนซ้ำได้ทุกอย่าง พร้อมตัวอย่าง
0/5 แบบฝึกหัด

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

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

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

ลูป while ใน Python ทำงานอย่างไร

ลูป while จะตรวจเงื่อนไขก่อนเริ่มแต่ละรอบ ถ้าเงื่อนไขเป็น True โค้ดในลูปจะทำงาน จากนั้น Python จะกลับขึ้นไปด้านบนและตรวจเงื่อนไขอีกครั้ง วนแบบนี้ไปเรื่อย ๆ จนกว่าเงื่อนไขจะกลายเป็น False

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

ลูป while ง่าย ๆ ที่นับถึง 5
count = 1
while count <= 5:
print(count)
count += 1
print("Done!")
# Output:
# 1
# 2
# 3
# 4
# 5
# Done!
ผลลัพธ์
1
2
3
4
5
Done!

ลำดับการทำงานเป็นแบบนี้ Python ตรวจ count <= 5 เนื่องจาก count เริ่มที่ 1 เงื่อนไขจึงเป็น True โค้ดในลูปจึงทำงาน คือแสดงค่า count แล้วบวกเพิ่ม 1 จากนั้น Python ตรวจเงื่อนไขอีกครั้ง วนไปเรื่อย ๆ จน count มีค่าเป็น 6 ซึ่งตอนนั้น 6 <= 5 เป็น False และลูปก็หยุด

หัวใจสำคัญคือ ต้องมีบางอย่างในลูปที่ทำให้เงื่อนไขกลายเป็น False ในที่สุด ในตัวอย่างนี้ count += 1 ทำให้ตัวนับเพิ่มขึ้นเรื่อย ๆ จนเกิน 5 ถ้าไม่มีบรรทัดนี้ ลูปจะทำงานไปตลอดกาล

นับและสะสมค่าด้วยลูป while ได้อย่างไร

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

การนับ: ต้องคูณสองกี่ครั้งจึงจะเกิน 1000
# How many doubles of 1 to exceed 1000?
value = 1
doubles = 0
while value <= 1000:
value = value * 2
doubles += 1
print(f"After {doubles} doubles, the value is {value}")
# Output:
# After 10 doubles, the value is 1024
ผลลัพธ์
After 10 doubles, the value is 1024

งานนี้เขียนด้วยลูป for ได้ไม่สะดวก เพราะเราไม่รู้ล่วงหน้าว่าต้องคูณสองกี่ครั้ง ลูป while จะทำงานต่อไปจนกว่าค่าจะเกิน 1000 และเรานับว่าลูปทำงานไปกี่รอบ

การสะสมค่า: บวกไปเรื่อย ๆ จนเกิน 100
# Summing numbers until the total reaches 100
total = 0
number = 1
while total < 100:
total += number
number += 1
# number was incremented one extra time after the last addition
print(f"Sum of 1 to {number - 1} = {total}")
# Output:
# Sum of 1 to 14 = 105
ผลลัพธ์
Sum of 1 to 14 = 105

ลูปนี้บวกตัวเลขที่เรียงต่อกัน (1, 2, 3, ...) ไปเรื่อย ๆ จนผลรวมถึงหรือเกิน 100 หลังจบลูป number จะมากกว่าตัวเลขตัวสุดท้ายที่บวกเข้าไป 1 เพราะบรรทัด number += 1 ทำงานหลังการบวกทุกครั้ง เราจึงแสดงผล number - 1

ลูปไม่รู้จบคืออะไร และ break ทำงานอย่างไร

ลูปไม่รู้จบ (infinite loop) คือลูปที่เงื่อนไขไม่เคยกลายเป็น False บางครั้งนี่คือบั๊ก แต่บางครั้งก็ตั้งใจ คือสร้างลูปไม่รู้จบขึ้นมาเองแล้วใช้ break เพื่อออกจากลูปเมื่อพร้อม

ลูปไม่รู้จบที่ไม่ได้ตั้งใจ (บั๊ก)
# DON'T RUN THIS - it never stops!
count = 1
while count <= 5:
    print(count)
    # Oops, forgot count += 1
ลูปไม่รู้จบที่ตั้งใจ พร้อม break
while True:
    answer = "yes"
    print("Looping...")
    if answer == "yes":
        break
print("Escaped!")

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

เกมทายตัวเลขด้วย while True + break
# Simulating a guessing game (without real input)
secret = 7
guesses = [3, 9, 5, 7] # simulated guesses
attempt = 0
while True:
guess = guesses[attempt]
attempt += 1
print(f"Guess {attempt}: {guess}")
if guess == secret:
print(f"Correct! You got it in {attempt} tries!")
break
elif guess < secret:
print("Too low!")
else:
print("Too high!")
# Output:
# Guess 1: 3
# Too low!
# Guess 2: 9
# Too high!
# Guess 3: 5
# Too low!
# Guess 4: 7
# Correct! You got it in 4 tries!
ผลลัพธ์
Guess 1: 3
Too low!
Guess 2: 9
Too high!
Guess 3: 5
Too low!
Guess 4: 7
Correct! You got it in 4 tries!

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

ตรวจสอบข้อมูลเข้าด้วยลูป while ได้อย่างไร

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

ลูปตรวจสอบข้อมูลเข้า
# Simulating input validation (without real input)
test_inputs = ["abc", "-5", "0", "25"] # simulated user inputs
input_index = 0
age = -1 # start invalid
while age <= 0 or age > 120:
user_input = test_inputs[input_index]
input_index += 1
print(f"Enter your age: {user_input}")
if user_input.isdigit():
age = int(user_input)
else:
print("Please enter a number.")
continue
if age <= 0 or age > 120:
print("Age must be between 1 and 120.")
print(f"Your age: {age}")
# Output:
# Enter your age: abc
# Please enter a number.
# Enter your age: -5
# Age must be between 1 and 120.
# Enter your age: 0
# Age must be between 1 and 120.
# Enter your age: 25
# Your age: 25
ผลลัพธ์
Enter your age: abc
Please enter a number.
Enter your age: -5
Please enter a number.
Enter your age: 0
Age must be between 1 and 120.
Enter your age: 25
Your age: 25

ลูปจะถามไปเรื่อย ๆ จนกว่าจะได้อายุที่ถูกต้อง ข้อมูลที่ไม่ถูกต้องอย่าง "abc" หรือตัวเลขติดลบจะทำให้มีข้อความแจ้งข้อผิดพลาด แล้วลูปก็วนซ้ำ เมื่อได้อายุที่ถูกต้องแล้วเท่านั้น เงื่อนไข age <= 0 or age > 120 จึงจะกลายเป็น False และลูปก็จบ

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

เมื่อไรควรใช้ while และเมื่อไรควรใช้ for

ทั้ง for และ while ใช้ทำซ้ำโค้ดได้ แต่ออกแบบมาสำหรับสถานการณ์ต่างกัน การเลือกให้ถูกจะทำให้โค้ดอ่านง่ายขึ้นและผิดพลาดน้อยลง

ใช้ for เมื่อ...ใช้ while เมื่อ...
คุณวนซ้ำผ่านชุดข้อมูลคุณรอให้เงื่อนไขเปลี่ยน
คุณรู้ว่าต้องวนกี่รอบคุณ ไม่รู้ ว่าต้องวนกี่รอบ
คุณประมวลผลสมาชิกแต่ละตัวในลิสต์คุณทำซ้ำจนกว่าจะเกิดบางอย่างขึ้น
ตัวอย่าง: แสดงชื่อนักเรียนทีละคนตัวอย่าง: ถามซ้ำจนกว่าจะได้ข้อมูลที่ถูกต้อง
for กับ while: เลือกเครื่องมือให้ถูกงาน
# FOR loop: you know the items to process
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
print(f"I like {fruit}")
print()
# WHILE loop: you don't know when to stop
num = 1
while num < 100:
num = num * 3
print(num, end=" ")
print(f"\nFirst power of 3 >= 100: {num}")
# Output:
# I like apple
# I like banana
# I like cherry
#
# 3 9 27 81 243
# First power of 3 >= 100: 243
ผลลัพธ์
I like apple
I like banana
I like cherry

3 9 27 81 243 
First power of 3 >= 100: 243

ลูป for เหมาะกับลิสต์ผลไม้ เพราะเรารู้แน่ชัดว่ากำลังวนซ้ำผ่านอะไร ส่วนลูป while เหมาะกับการหาเลขยกกำลังของ 3 เพราะเราไม่รู้ล่วงหน้าว่าต้องคูณกี่ครั้งจึงจะเกิน 100

ลูป while (ซับซ้อนโดยไม่จำเป็น)
names = ["Alice", "Bob", "Charlie"]
i = 0
while i < len(names):
    print(names[i])
    i += 1
ลูป for (สะอาดและเรียบง่าย)
names = ["Alice", "Bob", "Charlie"]
for name in names:
    print(name)

แบบฝึกหัด

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

อย่าลืมว่าลูป while ต้องมีบางอย่างที่เปลี่ยนไปภายในลูป ถ้าลูปของคุณทำงานไม่หยุด ให้ตรวจดูว่าคุณอัปเดตตัวแปรที่อยู่ในเงื่อนไขแล้วหรือยัง

แบบฝึกหัดที่ 1: นับถอยหลัง
เขียนโค้ด

ใช้ลูป while แสดงการนับถอยหลังจาก 5 ถึง 1 แล้วตามด้วย "Blastoff!" ในบรรทัดสุดท้าย

ผลลัพธ์ที่ต้องได้:

5
4
3
2
1
Blastoff!
# Create a countdown from 5 to 1, then print "Blastoff!"
แบบฝึกหัดที่ 2: หาเลขยกกำลังของ 2
เขียนโค้ด

เริ่มจาก 1 แล้วคูณสองไปเรื่อย ๆ จนกว่าจะเกิน 500 แสดงทุกค่าระหว่างทาง (รวมถึงค่าแรกที่เกิน 500) แล้วแสดงผลลัพธ์สุดท้าย

ผลลัพธ์ที่ต้องได้:

1
2
4
8
16
32
64
128
256
512
First power of 2 over 500: 512

คำใบ้: ใช้ลูป while True และมี break หลังค่าเกิน 500

value = 1
# Keep doubling and printing until value exceeds 500
แบบฝึกหัดที่ 3: ทายผลลัพธ์
ทายผลลัพธ์

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

จากนั้นรันโค้ดเพื่อตรวจคำตอบ

x = 10
while x > 1:
x = x // 2
print(x)
print("done")
แบบฝึกหัดที่ 4: แก้บั๊ก: นับจำนวนหลัก
แก้บั๊ก

โค้ดนี้ควรนับว่าตัวเลขมีกี่หลัก โดยหารด้วย 10 ซ้ำไปเรื่อย ๆ แต่มีบั๊ก ทำให้ได้คำตอบผิดสำหรับเลข 9999 แก้โค้ดให้แสดงผล:

9999 has 4 digits

ห้ามเปลี่ยนตัวเลขหรือคำสั่ง print บรรทัดสุดท้าย

number = 9999
original = number
digits = 0
while number >= 10:
number = number // 10
digits += 1
print(f"{original} has {digits} digits")
แบบฝึกหัดที่ 5: ลำดับคอลลาตซ์
เขียนโค้ด

ข้อความคาดการณ์ของคอลลาตซ์ (Collatz conjecture) เป็นโจทย์คณิตศาสตร์ที่มีชื่อเสียง เริ่มจากจำนวนเต็มบวกใดก็ได้ ถ้าเป็นเลขคู่ให้หารด้วย 2 ถ้าเป็นเลขคี่ให้คูณด้วย 3 แล้วบวก 1 ทำซ้ำจนกว่าจะได้ 1

เริ่มจาก n = 6 แสดงทุกค่าในลำดับ (รวม 6 และ 1) แล้วแสดงว่าใช้ไปกี่ขั้น

ผลลัพธ์ที่ต้องได้:

6
3
10
5
16
8
4
2
1
Steps: 8
n = 6
steps = 0
# Print n, then apply Collatz rules until n reaches 1
# Count each transformation as a step

สรุป: ลูป while ใน Python

ทุกอย่างที่คุณได้เรียนเกี่ยวกับลูป while:

รูปแบบทำอะไรตัวอย่าง
while condition:วนจนกว่าเงื่อนไขจะเป็น Falsewhile count > 0:
while True: + breakวนไม่รู้จบ ออกเองด้วยคำสั่งลูปของเกม เมนู
ลูปนับนับขึ้นหรือนับลงจนถึงเป้าหมายwhile count <= 10:
ลูปสะสมค่าสะสมผลรวมหรือผลลัพธ์while total < 100:
ลูปตรวจสอบทำซ้ำจนกว่าข้อมูลเข้าจะถูกต้องwhile age <= 0:

กฎสำคัญที่ควรจำ:

  • เงื่อนไขของ while ถูกตรวจ ก่อน เริ่มแต่ละรอบ
  • ต้องมีบางอย่างในลูปที่ทำให้เงื่อนไขกลายเป็น False ในที่สุด
  • break ออกจากลูปทันที
  • ใช้ for เมื่อรู้ว่าจะวนซ้ำผ่านอะไร
  • ใช้ while เมื่อต้องทำซ้ำจนกว่าเงื่อนไขจะเปลี่ยน
  • ตรวจซ้ำเสมอว่าลูป while ของคุณจบได้จริง

    • เรียนอะไรต่อ

    คุณได้เห็นการใช้ break เพื่อออกจากลูปก่อนกำหนดแล้ว แต่ยังมีคำสั่งควบคุมลูปอีกสองตัว คือ continue (ข้ามส่วนที่เหลือของรอบนี้) และ pass (ไม่ทำอะไรเลย) ในบทเรียนถัดไป break, continue และ pass ใน Python คุณจะได้ใช้ทั้งสามคำสั่งอย่างคล่องแคล่ว และรู้ว่าเมื่อไรควรใช้คำสั่งไหน

    บทเรียนที่เกี่ยวข้อง

    โครงสร้างควบคุม·เริ่มต้น
    ลูป for ใน Python: วนซ้ำได้ทุกอย่าง พร้อมตัวอย่าง
    25 นาที7 แบบฝึกหัด
    โครงสร้างควบคุม·เริ่มต้น
    break, continue, pass ใน Python: ควบคุมการทำงานของลูป
    20 นาที5 แบบฝึกหัด
    โครงสร้างควบคุม·เริ่มต้น
    if-else ใน Python: เงื่อนไข elif, if ซ้อนกัน และ ternary
    25 นาที6 แบบฝึกหัด
    โครงสร้างควบคุม·เริ่มต้น
    อ่าน error ใน Python ให้เป็น และแก้บั๊กที่พบบ่อย
    20 นาที6 แบบฝึกหัด
    พื้นฐาน Python·เริ่มต้น
    เขียนโค้ด Python ให้สะอาด: คอมเมนต์ docstring และ PEP 8
    15 นาที4 แบบฝึกหัด
    พื้นฐาน Python·เริ่มต้น
    บูลีน การเปรียบเทียบ และตัวดำเนินการตรรกะใน Python
    25 นาที6 แบบฝึกหัด

    บทเรียนนี้มีประโยชน์หรือไม่

    เสนอแนะการปรับปรุง