לולאת while ב-Python: תחביר, while True ואיך נמנעים מלולאה אינסופית

לולאה שמשגיחה על תנאי

בעוד ש-for עוברת על רצף ידוע, while ממשיכה לרוץ כל עוד תנאי מסוים מתקיים. פונים אליה כשלא יודעים מראש כמה איטרציות יידרשו: לנסות שוב עד שמשהו עובד, לקרוא קלט עד שהמשתמש אומר די, או לבדוק שירות שוב ושוב עד שהוא מגיב.

המבנה פשוט:

count = 0

while count < 5:
    print(count)
    count += 1

הקוד מדפיס את המספרים 0 עד 4. Python בודקת את התנאי בתחילת כל איטרציה. אם הוא מתקיים, גוף הלולאה רץ. ואז היא בודקת שוב. כשהתנאי הופך ל-false, הלולאה מסתיימת.

שימו לב ש-count += 1 חשובה. בלעדיה התנאי היה נשאר נכון לנצח, וזו לולאה אינסופית. זו המלכודת העיקרית של while, והסיבה העיקרית להעדיף for כשאפשר.

מתי while היא הכלי הנכון

כמה מקרי שימוש קלאסיים:

לנסות שוב עד להצלחה.

import random

attempts = 0
success = False

while not success:
    attempts += 1
    # נניח שזו קריאת רשת לא יציבה.
    if random.random() > 0.7:
        success = True

print(f"Succeeded after {attempts} attempts.")

לקרוא קלט עד שהמשתמש יוצא.

responses = []

while True:
    answer = input("Type something (or 'quit'): ").strip()
    if answer == "quit":
        break
    responses.append(answer)

print("You said:", responses)

לעבד תור.

tasks = ["send-email", "generate-report", "archive-logs"]

while tasks:
    task = tasks.pop(0)
    print(f"Running: {task}")

print("Queue empty.")

המכנה המשותף: אתם מחכים לשינוי מצב, ולא עוברים על פריטים.

while True זה בסדר

תראו את התבנית הזו הרבה:

count = 0

while True:
    count += 1
    if count > 3:
        break
    print(count)

print("Done.")

זה Python אידיומטי כשתנאי היציאה ה"אמיתי" נמצא בתוך גוף הלולאה, ולא משהו נקי שאפשר לבדוק בראשה. זה קריא יותר מלהמציא דגל should_continue שמעדכנים במקום אחד ובודקים במקום אחר.

הכלל היחיד: ודאו ש_יש_ break (או return, או חריגה שנזרקת) שהקוד יגיע אליו בסופו של דבר. while True: בלי שום דרך החוצה היא הדרך הקלאסית לתקוע תוכנית.

איך נמנעים מלולאה אינסופית

לולאות אינסופיות קורות כשהתנאי נשאר נכון לנצח. החשודים הרגילים:

• שכחתם לעדכן את המשתנה. while count < 5: צריכה משהו בתוך הגוף שמשנה את count.
• עדכנתם את המשתנה הלא נכון. while i < 10: ואז j += 1 בפנים. קל לפספס את זה כשיש בקוד יותר מכמה משתנים.
• השוואת מספרים עשרוניים. while x != 1.0: עלולה לרוץ לנצח אם x רק מתקרב ל-1.0 ולא מגיע אליו בדיוק. השתמשו ב-<= או ב-abs(x - 1.0) < tolerance במקום.

אם נתקעתם בלולאה אינסופית בטרמינל, לחצו Ctrl+C. זה שולח אות פסיקה, ו-Python עוצרת את מה שהיא עושה.

break, continue ו-else

while תומכת באותם שלושה כלי "זרימה" כמו for:

• break יוצאת מהלולאה מיד.
• continue מדלגת לאיטרציה הבאה (כך שהתנאי נבדק שוב).
• else רצה אם הלולאה הסתיימה בלי break.

n = 17

i = 2
while i * i <= n:
    if n % i == 0:
        print(f"{n} is divisible by {i}")
        break
    i += 1
else:
    print(f"{n} is prime")

זו בדיקת ראשוניות פשוטה. אם ה-break הפנימי מופעל, המספר פריק. אם הלולאה מסתיימת באופן טבעי (התנאי הופך ל-false), ה-else רצה וקובעת שהמספר ראשוני.

while מול for: במה לבחור?

מבחן מחשבתי מהיר:

• יש לכם אוסף לעבור עליו? → for.
• צריך לחזור מספר קבוע של פעמים? → for i in range(n):.
• אתם רצים בלולאה עד שתנאי כלשהו משתנה? → while.

בקוד Python של מתחילים תגלו ש-for מכסה 90% מהלולאות. while מופיעה כשעושים דברים כמו בדיקה חוזרת של שירות, ניסיונות חוזרים או בניית REPL פשוט. אם אתם משתמשים ב-while כדי לעבור על רשימה עם אינדקס, זה סימן שכדאי לעבור ל-for יחד עם enumerate.

תוכנית while מעשית

משחק ניחוש מספרים הוא דוגמה קלאסית, כי מספר האיטרציות תלוי באופן שבו המשתמש משחק:

import random

secret = random.randint(1, 50)
attempts = 0

while True:
    guess_text = input("Guess a number between 1 and 50: ").strip()
    guess = int(guess_text)
    attempts += 1

    if guess < secret:
        print("Higher.")
    elif guess > secret:
        print("Lower.")
    else:
        print(f"Got it in {attempts} attempts!")
        break

אי אפשר לדעת מראש כמה ניסיונות זה ייקח: זה תלוי בניחושים של המשתמש. זו בדיוק הסיבה ש-while קיימת.

מה הלאה

ראיתם עכשיו את שני סוגי הלולאות ש-Python מציעה. בהמשך: range() לעומק. היא מופיעה כמעט בכל לולאת for שסופרת, והדקויות הקטנות שלה שוות הבנה לפני שנעבור לאוספים.