מה זה איטרציה (Iteration)?

תוכנית ששולחת אימייל תזכורת ל-10,000 משתמשים לא מכילה 10,000 עותקים של קוד השליחה. היא מכילה את הקוד פעם אחת, בתוך לולאה, והלולאה מריצה אותו פעם אחת לכל משתמש. כל הרצה היא איטרציה אחת, והלולאה כולה היא הדרך שבה התוכנית עוברת באיטרציה על המשתמשים שלה.

איך איטרציה עובדת, שלב אחרי שלב

כל לולאה עוברת את אותו מחזור:

1. בדיקה. בודקים את התנאי של הלולאה, שהוא ערך בוליאני: האם יש עוד פריט, או האם המונה עדיין מתחת לגבול?
2. הרצה. אם התשובה היא אמת, מריצים את גוף הלולאה פעם אחת.
3. עדכון. עוברים לפריט הבא או משנים את המונה.
4. חזרה. חוזרים לשלב 1. כשהבדיקה נותנת שקר, התוכנית ממשיכה עם הקוד שאחרי הלולאה.

כאן הגוף רץ חמש פעמים, וכל איטרציה מוסיפה את המספר הבא לסכום מצטבר:

total = 0

for n in range(1, 6):
    total = total + n
    print("iteration", n, "total is now", total)

print("Done:", total)

iteration 1 total is now 1
iteration 2 total is now 3
iteration 3 total is now 6
iteration 4 total is now 10
iteration 5 total is now 15
Done: 15

המשתנה total נמצא מחוץ ללולאה, ולכן הוא שומר על הערך שלו מאיטרציה לאיטרציה. הדפוס הזה, משתנה שמאותחל לפני הלולאה ומתעדכן בתוכה, נקרא צובר (accumulator), והוא מופיע כמעט בכל לולאה שמחשבת משהו.

לולאות ספירה ולולאות תנאי

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

איטרציה לא מוגדרת חוזרת עד שמשהו קורה, ומספר המעברים לא ידוע מראש. לולאת while מתאימה למקרה הזה:

balance = 100
years = 0

while balance < 200:
    balance = balance * 1.10
    years = years + 1

print(years, "years, balance", round(balance, 2))

8 years, balance 214.36

כסף שגדל ב-10% בשנה צריך 8 שנים כדי להכפיל את עצמו. התוכנית גילתה את זה באיטרציה, לא בפתרון משוואה. המדריכים ללולאות for וללולאות while מכסים את שתיהן ב-Python.

מעבר על אוסף

רוב הלולאות עוברות על אוסף: האיברים של מערך, התווים של מחרוזת, השורות של קובץ. לולאת for של Python נותנת לכם כל איבר ישירות, ו-enumerate() מוסיפה את המיקום שלו:

fruits = ["apple", "banana", "cherry"]

for index, fruit in enumerate(fruits):
    print(index, fruit)

0 apple
1 banana
2 cherry

מאחורי הקלעים, for מבקשת מהאוסף iterator בעזרת iter(), ואז קוראת ל-next() עליו פעם אחת בכל איטרציה. אפשר לבצע את אותן קריאות בעצמכם:

colors = ["red", "green", "blue"]

it = iter(colors)
print(next(it))
print(next(it))
print(next(it))
print(next(it, "no more items"))

red
green
blue
no more items

בלי ערך ברירת המחדל, ה-next() הרביעי זורק StopIteration. החריגה הזו היא האות שלולאת for משתמשת בו כדי לדעת שהאוסף נגמר.

שפות אחרות כותבות את אותו רעיון בצורה אחרת. C סופרת עם אינדקס, ואילו ל-Java ול-JavaScript יש גם לולאה שנותנת לכם כל איבר:

for (int i = 0; i < 3; i++) {
    printf("%s\n", colors[i]);
}

for (String color : colors) {
    System.out.println(color);
}

for (const color of colors) {
    console.log(color);
}

איטרציה מול רקורסיה

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

שורת הזיכרון חשובה בפועל. Python מאפשרת כברירת מחדל בערך 1,000 קריאות מקוננות, כך שסכום רקורסיבי של 5,000 מספרים נכשל במקום שבו ללולאה אין שום בעיה:

def sum_loop(n):
    total = 0
    for k in range(1, n + 1):
        total = total + k
    return total

def sum_recursive(n):
    if n == 0:
        return 0
    return n + sum_recursive(n - 1)

print(sum_loop(100), sum_recursive(100))
print(sum_loop(5000))

try:
    print(sum_recursive(5000))
except RecursionError:
    print("sum_recursive(5000) failed: RecursionError")

5050 5050
12502500
sum_recursive(5000) failed: RecursionError

ההדמיה של רקורסיה מראה את מחסנית הקריאות גדלה וקטנה צעד אחרי צעד.

טעויות נפוצות

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

טעות של אחד (off by one). range(1, 5) נותן 1, 2, 3 ו-4, לא 5, כי ערך הסוף לא נכלל. לולאה שרצה פעם אחת יותר מדי או פחות מדי עדיין רצה בלי שגיאה ונותנת תשובה שגויה, וזו שגיאה לוגית.

שינוי רשימה תוך כדי מעבר עליה. הסרת פריטים מהרשימה שעוברים עליה גורמת ללולאה לדלג על איברים:

numbers = [1, 2, 2, 3]

for n in numbers:
    if n == 2:
        numbers.remove(n)

print(numbers)

[1, 2, 3]

אחד מה-2 שרד, כי הסרת ה-2 הראשון הזיזה את השני למיקום שהלולאה כבר עברה. בנו רשימה חדשה במקום זאת: numbers = [n for n in numbers if n != 2].

לאן ממשיכים מכאן

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