רשימות ב-Python (Lists): יצירה, אינדקסים, append, מיון ומעבר בלולאה

רשימות הן רצפים מסודרים שניתנים לשינוי

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

יוצרים אחת עם סוגריים מרובעים:

fruits = ["apple", "banana", "cherry"]
numbers = [1, 2, 3, 4]
mixed = [1, "two", 3.0, True]
empty = []

print(fruits)
print(numbers)
print(mixed)
print(empty)

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

אינדקסים

לכל פריט יש מיקום, שמתחיל ב-0. ניגשים אליו עם סוגריים מרובעים:

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

print(fruits[0])    # 'apple'
print(fruits[1])    # 'banana'
print(fruits[-1])   # 'cherry': אינדקסים שליליים סופרים מהסוף
print(fruits[-2])   # 'banana'

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

Slicing

slicing נותן לכם טווח של פריטים. התחביר הוא list[start:stop:step], בדיוק כמו במחרוזות:

nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print(nums[2:5])      # [2, 3, 4]
print(nums[:3])       # [0, 1, 2]: מההתחלה
print(nums[7:])       # [7, 8, 9]: עד הסוף
print(nums[::2])      # [0, 2, 4, 6, 8]: כל פריט שני
print(nums[::-1])     # עותק הפוך

שני דברים שכדאי לקבע:

• slicing תמיד מחזיר רשימה חדשה. שינוי של ה-slice לא משפיע על המקור.
• אינדקס הסיום אינו כלול: nums[2:5] נותן את האינדקסים 2, 3 ו-4, לא את 5.

איך מוסיפים פריטים עם append, extend ו-insert

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

items = ["a", "b", "c"]

items.append("d")       # מוסיפה פריט אחד לסוף
items.insert(0, "z")    # מכניסה פריט אחד באינדקס מסוים
items.extend(["e", "f"])  # מוסיפה כל פריט מ-iterable אחר

print(items)

• append(x) מוסיפה את x כאיבר יחיד, גם אם x הוא רשימה. items.append([1, 2]) מוסיפה את הרשימה עצמה כרשומה אחת.
• extend(iterable) מוסיפה כל פריט מתוך ה-iterable. items.extend([1, 2]) מוסיפה שתי רשומות.
• insert(i, x) מכניסה באינדקס מסוים ומזיזה כל מה שנמצא ב-i ואחריו מקום אחד קדימה.

+= עם רשימה בצד השני עובד כמו extend:

items = ["a", "b"]
items += ["c", "d"]
print(items)

ולהסרה:

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

items.remove("b")       # מסירה את ההופעה הראשונה של "b"
print(items)

last = items.pop()      # מסירה ומחזירה את הפריט האחרון
print(last, items)

second = items.pop(0)   # מסירה ומחזירה את הפריט באינדקס 0
print(second, items)

אם תנסו לבצע remove() למשהו שלא נמצא ברשימה, Python זורקת ValueError. אם אתם צריכים "הסר אם קיים", בדקו קודם עם in או השתמשו ב-try.

אפשר גם למחוק לפי אינדקס עם del:

items = [10, 20, 30, 40, 50]
del items[1]
print(items)

אורך, שייכות וספירה

nums = [4, 8, 15, 16, 23, 42, 16]

print(len(nums))         # 7
print(16 in nums)        # True
print(nums.count(16))    # 2
print(nums.index(23))    # 4: האינדקס של ה-23 הראשון

in היא הדרך הקריאה לבדוק אם רשימה מכילה ערך. אם תשאלו את השאלה הזו פעמים רבות על רשימה גדולה, השתמשו ב-set במקום: בדיקת שייכות ב-set היא O(1), וברשימה היא O(n).

מיון

שתי דרכים, והבחירה ביניהן חשובה:

nums = [5, 2, 9, 1, 7]

# במקום: משנה את הרשימה ומחזירה None.
nums.sort()
print(nums)    # [1, 2, 5, 7, 9]

# מחזירה רשימה ממוינת חדשה ומשאירה את המקורית כמו שהיא.
original = [5, 2, 9, 1, 7]
sorted_nums = sorted(original)
print(sorted_nums, original)

שתיהן מקבלות reverse=True לסדר יורד:

nums = [5, 2, 9, 1, 7]
nums.sort(reverse=True)
print(nums)    # [9, 7, 5, 2, 1]

ופונקציית key לסדר מותאם:

words = ["banana", "apple", "kiwi", "strawberry"]
words.sort(key=len)
print(words)    # ['kiwi', 'apple', 'banana', 'strawberry']

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

היפוך סדר

שלוש אפשרויות, לפי מה שצריך:

items = [1, 2, 3, 4]

# במקום: משנה את הרשימה ומחזירה None.
items.reverse()
print(items)

# Slicing: מחזיר רשימה הפוכה חדשה.
original = [1, 2, 3, 4]
copy = original[::-1]
print(copy, original)

# reversed(): מחזירה iterator עצל.
for n in reversed([1, 2, 3, 4]):
    print(n)

השתמשו בהיפוך במקום כשלא צריך את המקור. השתמשו ב-slicing כשרוצים עותק חדש. השתמשו ב-reversed() כשצריך רק לעבור בסדר הפוך בלי ליצור רשימה חדשה.

מלכודת ההפניה המשותפת

רשימות הן ניתנות לשינוי (mutable), ומשתנים הם הפניות. זה אומר ששני משתנים יכולים להצביע על אותה רשימה:

a = [1, 2, 3]
b = a
b.append(4)

print(a)    # [1, 2, 3, 4]: גם a השתנתה!

b = a לא העתיקה את הרשימה, היא הפכה את b לשם שני של אותה רשימה. אם אתם רוצים עותק, בקשו אחד:

a = [1, 2, 3]
b = a.copy()   # או list(a), או a[:]
b.append(4)

print(a, b)    # [1, 2, 3]  [1, 2, 3, 4]

זה נושך כל מתכנת Python לפחות פעם אחת. זכרו: = בין שתי רשימות לא מעתיק.

מעבר בלולאה ובנייה

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

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

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

print(passing)

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

scores = [45, 72, 33, 90, 58, 61]
passing = [s for s in scores if s >= 60]
print(passing)

נסביר comprehensions לעומק בעוד שני עמודים.

דף עזר מהיר

מתודות שכדאי להכיר, במבט אחד:

• append(x): הוספה לסוף
• extend(iter): הוספת כל פריט מ-iterable
• insert(i, x): הכנסה באינדקס i
• pop() / pop(i): הסרה והחזרה
• remove(x): הסרת ההופעה הראשונה של x
• sort() / sort(key=...) / sort(reverse=True)
• reverse()
• index(x): המיקום של ה-x הראשון
• count(x): מספר ההופעות של x
• copy(): עותק רדוד

הצעד הבא

רשימות הן סוס העבודה. בהמשך נכיר את ה-tuples, בני הדודים שאינם ניתנים לשינוי, ונראה מתי עדיף לבחור ב-tuple.