Sets ב-Python: פריטים ייחודיים, איחוד, חיתוך והפרש

set הוא שק לא מסודר של פריטים ייחודיים

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

1. אתם רוצים פריטים ייחודיים, נקודה.
2. אתם רוצים לבדוק שייכות מהר.

כותבים אחד עם סוגריים מסולסלים:

colors = {"red", "green", "blue"}
print(colors)

with_dupes = {"red", "green", "red", "blue", "green"}
print(with_dupes)   # {"red", "green", "blue"}

ה-"red" וה-"green" הכפולים ב-set השני פשוט נעלמים. זו לא שגיאה, זו כל המטרה.

יצירת sets

שתי הדרכים שתשתמשו בהן בפועל:

# ליטרל עם סוגריים מסולסלים.
primes = {2, 3, 5, 7, 11}

# מכל iterable.
letters = set("banana")
print(letters)

numbers = set([1, 2, 2, 3, 3, 3])
print(numbers)

# set ריק: חייבים להשתמש ב-set(), לא ב-{}
empty = set()
print(empty, type(empty))

הנקודה האחרונה תופסת את כולם פעם אחת: {} יוצר dictionary ריק, לא set ריק. הדו-משמעות התחבירית הייתה צריכה ליפול על אחד מהם, וה-dicts ניצחו.

הוספה והסרה

tags = {"python", "docs"}

tags.add("beginner")
print(tags)

tags.update(["seo", "tutorial", "python"])  # מוסיפה כמה, מתעלמת מכפילויות
print(tags)

tags.remove("seo")       # זורקת KeyError אם הפריט לא קיים
tags.discard("missing")  # כמו remove, אבל שקטה אם הפריט לא קיים
print(tags)

popped = tags.pop()      # מסירה ומחזירה פריט שרירותי
print("popped:", popped, "remaining:", tags)

remove מול discard היא ההבחנה החשובה: remove מתעקשת שהפריט יהיה קיים, ול-discard לא אכפת. בחרו לפי השאלה אם היעדר הפריט צריך להיות שגיאה.

בדיקת שייכות מהירה

כאן sets באמת מצדיקים את מקומם. x in some_set רץ בזמן קבוע, לא משנה כמה גדול ה-set. x in some_list צריך לעבור על הרשימה, וזה נהיה איטי כשהרשימה גדולה.

# דמיינו שברשימה הזו יש 1,000,000 פריטים.
known_users = set(range(1_000_000))

# כל בדיקה כמעט מיידית.
for user_id in [42, 999_999, 1_000_001]:
    if user_id in known_users:
        print(f"{user_id}: known")
    else:
        print(f"{user_id}: unknown")

כלל אצבע: בכל פעם שאתם מוצאים את עצמכם כותבים if x in some_list בתוך לולאה, וברשימה יש יותר מכמה עשרות פריטים, המירו קודם את הרשימה ל-set.

מתמטיקה של קבוצות

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

frontend = {"html", "css", "javascript", "react"}
backend = {"python", "sql", "javascript", "docker"}

# איחוד: הכול משניהם.
all_skills = frontend | backend
print(all_skills)

# חיתוך: מה שנמצא בשניהם.
shared = frontend & backend
print(shared)

# הפרש: ב-frontend אבל לא ב-backend.
only_frontend = frontend - backend
print(only_frontend)

# הפרש סימטרי: באחד מהם, אבל לא בשניהם.
unique_skills = frontend ^ backend
print(unique_skills)

לכל אופרטור יש גם צורת מתודה (.union(), .intersection(), .difference(), .symmetric_difference()). האופרטורים קומפקטיים יותר, וצורות המתודה מקבלות כל iterable, לא רק set אחר.

הסרת כפילויות מרשימה

אחד השימושים הנפוצים ביותר ב-sets, גם מחוץ ל"לוגיקת קבוצות":

visits = ["alice", "bob", "alice", "carol", "bob", "alice"]
unique_visitors = list(set(visits))
print(unique_visitors)

שורה אחת, והכפילויות נעלמו. דבר אחד לשים לב אליו: הסדר לא נשמר. אם אתם צריכים ייחודיות וגם את הסדר המקורי, השתמשו ב-dict.fromkeys() במקום:

visits = ["alice", "bob", "alice", "carol", "bob", "alice"]
unique_in_order = list(dict.fromkeys(visits))
print(unique_in_order)

ב-Python מודרנית dicts שומרים על סדר ההכנסה, ו-dict.fromkeys בונה אחד שבו הפריטים של ה-iterable הם המפתחות, ולמעשה זה set מסודר.

תת-קבוצות וקבוצות-על

בדיקה אם set אחד מוכל באחר:

known = {"python", "bash", "sql"}
required = {"python", "bash"}

print(required.issubset(known))     # True: required נמצא בתוך known
print(known.issuperset(required))   # True
print(required <= known)            # כמו issubset, עם אופרטור
print(known >= required)            # כמו issuperset

אלה עולים בדברים כמו בדיקות הרשאות ("האם למשתמש הזה יש את כל התפקידים הנדרשים?").

מה יכול להיכנס ל-set

רק פריטים hashable. זה מונח טכני, ובפועל פירושו:

• דברים שאינם ניתנים לשינוי הם hashable: מספרים, מחרוזות, tuples של פריטים hashable, frozensets.
• דברים שניתנים לשינוי לא: רשימות, dicts ו-sets אחרים לא יכולים להיות איברים ב-set.

ok = {1, "hello", (1, 2), 3.14}
print(ok)

# {[1, 2]}  # TypeError: רשימות אינן hashable

אם צריך set של sets, השתמשו ב-frozenset: זו גרסה של set שאינה ניתנת לשינוי.

מעבר על set אינו מסודר

לולאה על set נותנת את הפריטים בסדר לא מובטח:

for item in {"a", "b", "c", "d"}:
    print(item)

הריצו את זה כמה פעמים ותראו שהסדר משתנה. אם הסדר חשוב, set הוא לא המבנה הנכון: מיינו את התוכן כשאתם צריכים אותו, או השתמשו ברשימה.

מתי לא להשתמש ב-set

אם אחד מאלה נכון, כנראה שרשימה או dict מתאימים יותר:

• הסדר חשוב לכם.
• צריך לשמור כפילויות.
• לכל פריט יש נתונים משויכים (השתמשו ב-dict שבו הפריט הוא המפתח).

ממשיכים הלאה

sets מטפלים בייחודיות ובשייכות. Dictionaries, שמגיעים בעמוד הבא, מטפלים בדפוס הרחב יותר של "מצא ערך לפי מפתח", שהוא כנראה מבנה הנתונים השימושי ביותר ב-Python אחרי הרשימה.