לולאות for ב-Python: מעבר על רשימות, מחרוזות, ranges ומילונים

לולאת for של Python היא "for each"

אם השתמשתם בשפה בסגנון C, לולאת for של Python תיראה לכם שונה. אין דפוס מונה של for (i = 0; i < n; i++). ה-for של Python היא לולאת for each לכל דבר: נותנים לה אוסף והיא מגישה את הפריטים אחד אחרי השני.

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

for color in colors:
    print(color)

זה מדפיס שלוש שורות. Python קוראת את הרשימה, שולפת כל איבר בתורו וקושרת אותו ל-color בזמן שהגוף רץ. כשלא נשאר כלום, הלולאה מסתיימת.

שימו לב לצורה: for <name> in <iterable>: ואחריה גוף מוזח. הזחה, נקודתיים, גוף; אותו מבנה כמו if.

מה נחשב iterable

כמעט כל דבר שמחזיק רצף של ערכים. רשימות, tuples, מחרוזות, ranges, dicts, sets, קבצים ורוב האובייקטים המותאמים אישית שתבנו.

# מחרוזת היא רצף של תווים.
for ch in "python":
    print(ch)

# tuple עובד כאן בדיוק כמו רשימה.
for n in (10, 20, 30):
    print(n)

# אפשר לעבור על set, אבל אין לו סדר: אל תסמכו על הסדר.
for item in {"a", "b", "c"}:
    print(item)

# dict עובר על המפתחות שלו כברירת מחדל.
settings = {"theme": "dark", "font": "mono"}
for key in settings:
    print(key, "->", settings[key])

האחידות היא החלק הנחמד: תחביר אחד, צורות נתונים רבות.

ספירה עם range()

כשכן רוצים מונה, "תעשו את זה עשר פעמים" או "עברו על האינדקסים 0 עד 9", השתמשו ב-range():

for i in range(5):
    print(i)

זה מדפיס 0, 1, 2, 3, 4. range(stop) סופרת מ-0 ועד stop, לא כולל. range(start, stop) מאפשרת לקבוע ערך התחלה, ו-range(start, stop, step) מאפשרת לשלוט בגודל הצעד:

for i in range(2, 11, 2):
    print(i)     # 2, 4, 6, 8, 10

for i in range(10, 0, -1):
    print(i)     # 10, 9, 8, ..., 1

יש עמוד ייעודי על range בהמשך, כי שווה להבין אותה קצת יותר לעומק. בינתיים, range(n) נותנת n איטרציות שממוספרות מ-0 עד n-1.

enumerate ב-Python: לולאה עם אינדקס

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

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

for index, color in enumerate(colors):
    print(index, color)

enumerate() מחזירה זוגות (index, value). שני המשתנים אחרי for מפרקים את הזוג לשני שמות: index ו-color. הרבה יותר נקי מ:

# אל תעשו את זה: enumerate עדיפה.
for i in range(len(colors)):
    print(i, colors[i])

אם רוצים להתחיל לספור מ-1 במקום מ-0, העבירו start=1:

for position, runner in enumerate(["Ada", "Boris", "Ciara"], start=1):
    print(f"#{position}: {runner}")

zip ב-Python: מעבר על שני רצפים יחד

כשיש שתי רשימות באותו אורך ורוצים לצמד ביניהן:

names = ["Ada", "Boris", "Ciara"]
cities = ["London", "Paris", "Lisbon"]

for name, city in zip(names, cities):
    print(f"{name} lives in {city}.")

zip נעצרת ברצף הקצר ביותר. אם רוצים שהיא תמשיך ותמלא ב-None, השתמשו ב-itertools.zip_longest.

מעבר על dict

מילונים נותנים לכם לבחור על מה לעבור בלולאה:

prices = {"apple": 0.50, "bread": 2.00, "milk": 1.20}

# מפתחות (ברירת המחדל)
for key in prices:
    print(key)

# ערכים
for value in prices.values():
    print(value)

# שניהם
for key, value in prices.items():
    print(f"{key}: ${value:.2f}")

רוב הזמן תרצו את .items(): מקבלים את המפתח ואת הערך יחד בשורה אחת קריאה.

break ו-continue

לפעמים רוצים לצאת מוקדם או לדלג על איטרציה.

break יוצאת מהלולאה מיד:

numbers = [5, 3, 9, 7, 2, 8]

for n in numbers:
    if n > 6:
        print(f"Found a big one: {n}")
        break

ברגע שנמצא מספר גדול מ-6, הלולאה נעצרת. מתעלמים משאר הפריטים.

continue מדלגת על שאר האיטרציה הנוכחית ועוברת לבאה:

for n in range(10):
    if n % 2 == 0:
        continue
    print(n)   # מדפיס רק את המספרים האי-זוגיים

מותר להשתמש בשתיהן, אם כי continue יכולה להקשות על מעקב אחרי הלולאה אם יש יותר מאחת. הרבה פעמים if/else פשוט נקרא טוב יותר.

פסקת else בלולאה

ל-Python יש פיצ'ר שאין ברוב השפות: פסקת else בלולאות. היא רצה כשהלולאה מסתיימת בלי להגיע ל-break.

numbers = [3, 5, 7, 9]

for n in numbers:
    if n % 2 == 0:
        print("Found an even number")
        break
else:
    print("All numbers were odd")

שימושי, אבל מבלבל בהתחלה. אל תרגישו חובה להשתמש בזה: דגל בוליאני מחוץ ללולאה הוא הרבה פעמים ברור יותר לקוראים חדשים.

שינוי רשימה בזמן המעבר עליה

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

scores = [45, 72, 33, 90, 58, 61]
passing = []

for score in scores:
    if score >= 60:
        passing.append(score)

print(passing)

או, כשתרגישו בנוח, list comprehension עושה את אותו הדבר בשורה אחת. נכסה את זה בפרק על אוספים.

דוגמה קטנה מקצה לקצה

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

temperatures = [68, 74, 81, 65, 92, 77, 59]
hot_day_numbers = []

for day_number, temp in enumerate(temperatures, start=1):
    if temp >= 80:
        hot_day_numbers.append(day_number)

if hot_day_numbers:
    print(f"Hot on days: {hot_day_numbers}")
else:
    print("No hot days this week.")

הבא בתור: לולאות while

for היא הבחירה הנכונה כשיודעים על מה עוברים. while היא הבחירה הנכונה כשחוזרים בלולאה עד שתנאי כלשהו משתנה, וזה מה שמגיע עכשיו.