2.10. קבוצות#

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

2.10.1. יצירת קבוצה#

השתמשו בסוגריים מסולסלים עבור קבוצה לא ריקה, או ב-set() עבור קבוצה ריקה:

colours = {"red", "green", "blue"}
empty = set()

הסוגריים נראים כמו ליטרל של dict; {} לבדו הוא מילון ריק, לא קבוצה ריקה – אחת התאונות ההיסטוריות של Python. השתמשו ב-set() למקרה הריק.

set() גם בונה קבוצה מכל איטרבל, וזו הדרך הסטנדרטית לסילוק כפילויות מרצף:

nums = [1, 2, 2, 3, 1, 4]
unique = set(nums)
print(unique)

פלט:

{1, 2, 3, 4}

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

2.10.2. קבוצה לעומת מילון#

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

  • dict מאחסן זוגות מפתח-ערך. חיפוש מפתח מחזיר את ערכו.

  • set מאחסן רק את הפריטים. חיפוש פריט אומר לכם אם הוא קיים.

הבחירה בין השניים נוגעת לשאלה האם הערך שלצד כל פריט משמעותי:

  • פנו ל-קבוצה כאשר אין ערך השייך לצד כל פריט – כל שאכפת לכם הוא האם הפריט קיים, או שאתם משלבים קבוצות של פריטים ייחודיים באמצעות איחוד / חיתוך.

  • פנו ל-מילון כאשר כל פריט מזווג עם נתון שהחיפוש אמור לאחזר – מפת הגדרות, מטמון, מונה הממופתח לפי שם.

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

set

dict

מחזיק

פריטים ייחודיים

מפתחות ייחודיים, כל אחד עם ערך

ליטרל מאוכלס

{1, 2, 3}

{"a": 1, "b": 2}

ליטרל ריק

set()

{}

בדיקת חברות

x in s

k in d (מפתחות בלבד)

אחזור ערך

לא רלוונטי

d[k]

הוספת פריט

s.add(x)

d[k] = v

איטרציה

מניבה פריטים

מניבה מפתחות (השתמשו ב-d.items() עבור זוגות)

האסימטריה בין הליטרלים המאוכלסים לריקים היא המלכודת שראוי להדגיש:

  • סוגריים עם פריטים בתוכם – {1, 2, 3} – הם ליטרל קבוצה; סוגריים עם זוגות מפתח-ערך – {"a": 1} – הם ליטרל מילון. המנתח מבחין ביניהם לפי מה שבפנים.

  • סוגריים עם שום דבר בפנים – {} – הם מילון ריק, לא קבוצה ריקה. מילונים הופיעו ראשונים; הליטרל הריק שייך להם. לקבוצה ריקה אין ליטרל סוגריים כלל, ויש לכתוב אותה set().

דפוס נפוץ כאשר רק המפתחות של מילון נקראים אי-פעם הוא לעבור לקבוצה – הדבר הופך את הכוונה לברורה ומקצץ את הערכים הלא בשימוש מהזיכרון.

2.10.3. הוספה והסרה#

  • set.add() – מכניס פריט אחד.

  • set.discard() – מסיר פריט אם הוא קיים, ולא עושה דבר אם אינו קיים.

  • set.remove() – מסיר פריט; גורם ל-KeyError אם הוא חסר.

  • set.clear() – מרוקן את הקבוצה.

s = {1, 2, 3}
s.add(4)
s.discard(99)            # silent: 99 not in s
s.remove(2)
print(s)

פלט:

{1, 3, 4}

2.10.4. חברות#

האופרטור in בודק חברות. בקבוצה הוא בקירוב בזמן קבוע ללא תלות בגודל – וזו הסיבה העיקרית לבחור בקבוצה על פני list כאשר כל שאתם צריכים הוא לשאול ”האם ערך זה נמצא שם“:

if "red" in colours:
    print("colour is allowed")

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

2.10.5. פעולות על קבוצות#

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

  • a | b או a.union(b) – כל מה שנמצא באחת הקבוצות.

  • a & b או a.intersection(b) – רק מה שמופיע בשתיהן.

  • a - b או a.difference(b) – ב-a אך לא ב-b.

  • a ^ b או a.symmetric_difference(b) – באחת אך לא בשתיהן.

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
print(a | b)
print(a & b)
print(a - b)
print(a ^ b)

פלט:

{1, 2, 3, 4, 5, 6}
{3, 4}
{1, 2}
{1, 2, 5, 6}

צורות האופרטור הן לקריאה בלבד; צורות המתודה מקבלות כל איטרבל בצד ימין, לא רק קבוצה נוספת (a.union([5, 6])). בחרו את מה שנקרא טוב יותר בהקשר.

2.10.6. מה יכול להיכנס לקבוצה#

איברי קבוצה חייבים להיות ניתנים לגיבוב (hashable) – אותה מגבלה כמו עבור מפתחות dict. int, float, str, bool, bytes, ו-tuple (כאשר תוכנו עצמו ניתן לגיבוב) כולם עובדים. list ו-dict אינם עובדים; ניסיון להוסיף אחד מהם גורם ל-TypeError.

2.10.7. frozenset#

set רגילה היא ברת-שינוי: כל קריאה ל-add / remove / discard משנה את האובייקט במקום. בריר-שינוי זו פוסלת אותה מלהיות ניתנת לגיבוב, ולכן קבוצה אינה יכולה לשמש כמפתח dict או כאיבר של קבוצה אחרת.

frozenset היא המקבילה הבלתי-משתנה. יש לה אותם חיפושים ואופרטורים (in, |, &, -, ^) כמו ל-set, אך ללא add / remove וללא מתודות המשנות אותה. מכיוון ששום דבר אינו יכול אי-פעם לשנות את תוכנה, הגיבוב של frozenset מוגדר היטב – ולכן היא כן ניתנת לגיבוב:

primary = frozenset({"red", "green", "blue"})
secondary = frozenset({"yellow", "purple", "orange"})

palettes = {
    primary: "RGB",
    secondary: "mixed",
}

print(palettes[primary])

פלט:

RGB

בנו frozenset מכל איטרבל – frozenset() למקרה הריק, frozenset(some_set) כדי לקחת תמונת בזק (snapshot) בלתי-משתנה של קבוצה קיימת:

snapshot = frozenset(s)         # immutable copy of s
s.add("new")                    # snapshot does not change

שתי סיבות נפוצות לפנות אליה:

  • שימוש כמפתח מילון או כאיבר קבוצה. בכל מקום שערך יחיד אינו יכול לתפוס את מה שאתם צריכים, frozenset של ערכים יכולה – ”קבוצת המאפיינים הנתמכים על ידי דרייבר זה“, ”קבוצת הפינים שפרופיל זה משתמש בהם“.

  • נעילת קבוע. frozenset ברמת המודול של שמות מורשים אינה יכולה להשתנות בטעות על ידי קורא; set רגילה כן. העדיפו frozenset עבור כל דבר שאמור להיות לקריאה בלבד לאחר הבנייה.