Tuples ב-Python: רצפים שאינם ניתנים לשינוי, פריסה ו-Named Tuples

tuple הוא רשימה שאי אפשר לשנות

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

כותבים tuples בסוגריים עגולים (ולפעמים בלעדיהם):

point = (3, 4)
rgb = (255, 128, 0)
name_age = ("Rosa", 30)

print(point, rgb, name_age)

tuple עם פריט אחד צריך פסיק בסוף, אחרת Python מתייחסת לסוגריים כקיבוץ:

not_a_tuple = (42)     # סתם המספר 42 בסוגריים
a_tuple = (42,)        # tuple עם איבר אחד

print(type(not_a_tuple))
print(type(a_tuple))

ול-tuples ריקים, השתמשו ב-():

empty = ()
print(type(empty), len(empty))

חוסר שינוי, בפועל

נסו לשנות tuple ו-Python תעצור אתכם:

point = (3, 4)
# point[0] = 10     # זה היה זורק TypeError.
# point.append(5)   # אותו דבר: ל-tuples אין מתודת append.
print(point)

אפשר לקרוא מ-tuple בחופשיות: אינדקסים, slicing, מעבר בלולאה, in. פשוט אי אפשר לשנות אותו. אם צריך tuple אחר, יוצרים חדש.

למה שתרצו משהו שאי אפשר לשנות?

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

1. בטיחות. tuple שמעבירים לפונקציה לא יכול להשתנות מאחורי הגב שלכם.
2. Hashability. tuples של ערכים שאינם ניתנים לשינוי יכולים לשמש כמפתחות ב-dictionary או כאיברים ב-set, ורשימות לא.
3. כוונה. tuple אומר "זו רשומה בצורה קבועה". point = (3, 4) מעביר "שתי קואורדינטות" בצורה ברורה יותר מ-point = [3, 4].

tuples מצטיינים בדברים כמו:

• קואורדינטות: (x, y), (lat, lon)
• צבעי RGB: (255, 128, 0)
• רשומות: (name, email, signup_date)
• החזרת כמה ערכים מפונקציה

פריסה (Unpacking)

tuples ותחביר הפריסה נועדו זה לזה:

point = (3, 4)
x, y = point
print(x, y)

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

זה נמצא בכל מקום ב-Python אידיומטית:

# החלפה בין שני משתנים.
a, b = 1, 2
a, b = b, a
print(a, b)

# פריסת הערך המוחזר מפונקציה.
def minmax(values):
    return min(values), max(values)

low, high = minmax([5, 3, 9, 1, 7])
print(low, high)

# פריסה בתוך לולאה.
points = [(0, 0), (1, 1), (2, 4), (3, 9)]
for x, y in points:
    print(f"x={x}, y={y}")

אפשר להשתמש ב-* כדי לאסוף את "כל השאר":

first, *middle, last = [10, 20, 30, 40, 50]
print(first, middle, last)

שימושי כשחשובים לכם רק האיבר הראשון והאחרון.

tuples כמפתחות ב-Dictionary

מכיוון ש-tuples הם hashable (כל עוד התוכן שלהם hashable), אפשר להשתמש בהם כמפתחות ב-dict. רשימות לא יכולות לעשות את זה:

cache = {}
cache[(3, 4)] = "point A"
cache[(10, 20)] = "point B"

print(cache[(3, 4)])

הדפוס הזה, מפתח שמורכב מכמה ערכים, שימושי באופן מפתיע. חשבו על "הניקוד של משתמש X ביום Y" או "המסלול הטוב ביותר מ-A ל-B".

tuples להחזרת כמה ערכים

פונקציה שצריכה להחזיר יותר מדבר אחד מחזירה בדרך כלל tuple:

def divmod_custom(a, b):
    return a // b, a % b

quotient, remainder = divmod_custom(17, 5)
print(quotient, remainder)

הפונקציה המובנית divmod() של Python עושה בדיוק את זה. השמת הפריסה בקוד הקורא הופכת את זה לקריא וטבעי.

Named Tuples, כשמיקום לא מספיק

ברגע שה-tuples שלכם גדלים מעבר לשניים או שלושה פריטים, לזכור איזה מיקום אומר מה נהיה מייגע. collections.namedtuple פותר את זה:

from collections import namedtuple

Point = namedtuple("Point", ["x", "y"])

p = Point(3, 4)
print(p.x, p.y)
print(p)

עכשיו לפריטים של ה-tuple יש שמות. הוא עדיין אינו ניתן לשינוי, ועדיין tuple (כך שפריסה ואינדקסים עובדים), אבל דרך הגישה ידידותית הרבה יותר. לכל דבר מורכב יותר יש dataclasses, ונכיר אותן בהמשך בפרק על מחלקות.

tuple מול רשימה: מדריך החלטה מהיר

• צורה קבועה, לכל מיקום יש משמעות: tuple.
• אוסף שעשוי לגדול או לקטון: רשימה.
• החזרת כמה ערכים מפונקציה: tuple.
• צריך מפתח ל-dict או איבר ל-set: tuple (רשימה לא תעבוד).
• אתם מתכוונים לשנות אותו: רשימה (tuple לא ייתן לכם).

ממשיכים הלאה

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