2.7. רשימות

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

2.7.1. יצירת רשימות

סוגריים מרובעים יוצרים ליטרל של רשימה:

empty   = []
nums    = [1, 2, 3]
mixed   = [1, "two", 3.0, True, None]    # any types
nested  = [[1, 2], [3, 4], [5, 6]]       # lists of lists

ה-constructor list בונה רשימה מכל איטרבל:

>>> list("abc")
['a', 'b', 'c']
>>> list(range(5))
[0, 1, 2, 3, 4]

2.7.2. אורך, אינדוקס וחיתוך

len() מחזירה את מספר הפריטים. אינדוקס וחיתוך פועלים באותו אופן כמו במחרוזות – המיקומים מתחילים מ-0, אינדקסים שליליים נספרים מהסוף, וחיתוך מחוץ לטווח התקין נחתך בשקט במקום לגרום לחריגה:

>>> nums = [10, 20, 30, 40, 50]
>>> len(nums)
5
>>> nums[0]
10
>>> nums[-1]
50
>>> nums[1:4]
[20, 30, 40]

אינדקסים חיוביים נספרים מההתחלה; אינדקסים שליליים נספרים מהסוף.

תחביר החיתוך הוא קיצור עבור אובייקט slice ש-Python בונה מאחורי הקלעים. nums[1:4] זהה ל-nums[slice(1, 4)]. נדיר שתבנו אובייקט כזה ביד, אך slice() שימושית לעיתים לאחסון חיתוך כערך לשימוש חוזר:

head = slice(0, 3)
print(nums[head])             # [10, 20, 30]
print(letters[head])          # first three letters, same slice

2.7.3. שינוי רשימה

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

>>> nums = [10, 20, 30]
>>> nums[0] = 99
>>> nums
[99, 20, 30]
>>> nums[1:3] = [200, 300, 400]    # slice can change the length
>>> nums
[99, 200, 300, 400]

מתודות הרשימה הנפוצות ביותר:

• list.append() – מוסיף פריט יחיד לסוף.

• list.extend() – מצרף כל פריט מאיטרבל.

• list.insert() – מכניס במיקום נתון.

• list.remove() – מוחק את המופע הראשון של ערך.

• list.pop() – מסיר ומחזיר פריט (האחרון כברירת מחדל).

• list.clear() – מסיר כל פריט.

• list.sort() – ממיין במקום. העבירו reverse=True לסדר יורד.

• list.reverse() – הופך את הסדר במקום.

>>> nums = []
>>> nums.append(1)
>>> nums.extend([2, 3])
>>> nums.insert(0, 99)
>>> nums
[99, 1, 2, 3]
>>> nums.pop()
3
>>> nums.sort()
>>> nums
[1, 2, 99]

מתודות אלה משנות את הרשימה במקום ומחזירות None. כתיבה של

nums = nums.sort()    # nums is now None -- common bug

כמעט אף פעם אינה מה שאתם רוצים; ה-nums המקורי אמנם מוין, אך ההשמה לאחר מכן דורסת את השם בערך המוחזר. או שתקראו ל-nums.sort() בשורה נפרדת, או שתשתמשו ב-sorted() המובנית כדי לקבל רשימה ממוינת חדשה מבלי לשנות את המקור.

2.7.4. אופרטורים

• + משרשר שתי רשימות לרשימה חדשה.

• * משכפל רשימה.

• in בודק חברות.

>>> [1, 2] + [3, 4]
[1, 2, 3, 4]
>>> [0] * 5
[0, 0, 0, 0, 0]
>>> 3 in [1, 2, 3]
True

2.7.5. איטרציה על רשימה

לולאת for עוברת על הפריטים לפי הסדר:

for n in [10, 20, 30]:
    print(n)

2.7.6. כינוי ושינוי

רשימה היא ערך יחיד בזיכרון; כמה שמות יכולים להצביע על אותה רשימה. שינוי דרך שם אחד נראה דרך כל שם אחר המצביע על אותה רשימה.

a ו-b שניהם מצביעים על אותה רשימה. שינוי דרך אחד מהשמות משנה את מה שכל שם אחר רואה.

>>> a = [1, 2, 3]
>>> b = a
>>> a.append(4)
>>> b
[1, 2, 3, 4]                # same object, change is visible

כדי ליצור עותק עצמאי, חתכו את הרשימה כולה או קראו ל-constructor list:

>>> c = a[:]                # or list(a)
>>> a.append(5)
>>> c
[1, 2, 3, 4]                # c is unaffected

פעולה זו מעתיקה רק את הרשימה ברמה העליונה; רשימות מקוננות עדיין משותפות בין המקור לעותק.