range() ב-Python: start, stop, step וספירה לאחור

כלי לייצור מספרים

range() עושה דבר אחד בדיוק: היא מייצרת רצף של מספרים שלמים. היא השותפה הקבועה של לולאות for כשצריך לחזור מספר מסוים של פעמים או לעבור על טווח מספרי.

הצורה הפשוטה ביותר מקבלת ארגומנט יחיד, ערך ה-stop:

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

פלט:

0
1
2
3
4

שני פרטים שתופסים מתחילים:

1. הספירה מתחילה ב-0. range(5) נותנת חמישה מספרים, החל מ-0.
2. ערך ה-stop אינו כלול. range(5) עוצרת לפני 5, והיא לא כוללת את 5 עצמו.

הכללים האלה עקביים בכל פעולות ה-slicing, האינדקסים וה-range של Python. ברגע שמפנימים ש"stop אינו כלול", זה מפסיק להכשיל.

שלוש צורות

range() מקבלת ארגומנט אחד, שניים או שלושה:

# ארגומנט אחד: stop. מתחילה ב-0.
for i in range(3):
    print(i)      # 0, 1, 2

# שני ארגומנטים: start, stop.
for i in range(5, 10):
    print(i)      # 5, 6, 7, 8, 9

# שלושה ארגומנטים: start, stop, step.
for i in range(0, 20, 4):
    print(i)      # 0, 4, 8, 12, 16

step הוא גודל כל קפיצה. range(0, 20, 4) מייצרת כל מספר רביעי. זכרו את זה בפעם הבאה שתצטרכו "כל פריט שני" או "כל דגימה עשירית".

ספירה לאחור

ה-step יכול להיות שלילי, וזה מאפשר לספור לאחור:

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

שוב, ה-stop אינו כלול: range(10, 0, -1) עוצרת לפני 0, לא ב-0. כדי לכלול את 0, הגדירו את ה-stop ל--1:

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

range היא עצלה

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

# זה בסדר: שום דבר לא מוקצה בפועל.
r = range(1_000_000_000)
print(r)
print(len(r))

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

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

numbers = list(range(5))
print(numbers)

ברוב המקרים לא צריך את הרשימה. for i in range(...) עובדת ישירות.

דפוסים נפוצים

כמה מתכונים שתשתמשו בהם כל הזמן:

לעשות משהו n פעמים.

for _ in range(3):
    print("knock")

ה-_ הוא מוסכמה שפירושה "לא אכפת לי מהערך הזה". Python לא אוכפת אותה, אבל כל קורא יזהה את הכוונה.

גישה לרצף לפי אינדקס.

העדיפו enumerate() על פני range(len(...)), אבל כשצריך דווקא רק את האינדקס:

items = ["a", "b", "c", "d"]
for i in range(len(items)):
    print(i, items[i])

ועדיין, ברוב המקרים enumerate(items) נקייה יותר.

מעבר על כל איבר שני.

items = ["a", "b", "c", "d", "e", "f"]

for i in range(0, len(items), 2):
    print(items[i])

זה מדפיס a, c, e. עם זאת, ל-slicing פשוט, תחביר ה-slicing ישיר עוד יותר: items[::2].

ליצור רשימה מספרית מהירה.

squares = [i * i for i in range(1, 11)]
print(squares)

זו list comprehension, שנסביר בהמשך, אבל range היא זו שמספקת את המספרים.

מה range() לא

שני קצוות חדים שכדאי להכיר:

1. range מייצרת רק מספרים שלמים. אם אתם צריכים צעדים עשרוניים (כמו מ-0.0 עד 1.0 בקפיצות של 0.1), השתמשו ב-numpy.arange או בלולאה עם מונה משלכם.
2. range לא עובדת עם iterables כלשהם. היא מיועדת במיוחד למספרים שלמים. אם אתם מנסים לעבור עם "range" על רשימה, כנראה שאתם מחפשים את enumerate או פשוט את הרשימה עצמה.

הכול ביחד

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

# הדפסת לוח כפל עד 5x5.
for row in range(1, 6):
    line_parts = []
    for col in range(1, 6):
        line_parts.append(f"{row * col:>3}")
    print(" ".join(line_parts))

שתי לולאות מקוננות שמונעות על ידי range ומייצרות רשת. שימו לב ששתי הלולאות מתחילות ב-1, range(1, 6), כי אנחנו רוצים תוויות מ-1 עד 5.

ממשיכים לאוספים

ראיתם עכשיו תנאים, את שני סוגי הלולאות ואת range. זה מספיק בקרת זרימה כדי לעבוד עם כל אוסף. הפרק הבא: האוספים עצמם, רשימות, tuples, sets ו-dictionaries.