📘 אוספים ב-Python

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

אוספים תומכים בדרך כלל ב:

• איטרציה (for item in collection)
• בדיקת שייכות (x in collection)
• קביעת אורך (len(collection))
• גישה באמצעות אינדקס או מפתח (אם מסודרים או אסוציאטיביים)

ב-Python אין "ממשק אוסף" רשמי, אך קיימים פרוטוקולים לא רשמיים. אם אובייקט מממש __iter__, __len__, __contains__ — ניתן להחשיבו כאוסף.

---

מה שאיננו אוסף

הסוגים הבאים אינם אוספים, מכיוון שאינם מכילים קבוצות של אלמנטים:

• int, float, bool — ערכים סקלריים
• None — העדר ערך
• פונקציות, מודולים, מחלקות — אלו אובייקטים, אך לא מיכלי נתונים (אלא אם כן מכילים __dict__)

---

אוספים מובנים

זמינים ללא ייבוא:

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

---

אוספים מורחבים מהספרייה הסטנדרטית

סוג	מודול	יעד
SimpleNamespace	types	אובייקט עם מאפיינים דינמיים (חלופה למילון עם גישה דרך .).
namedtuple	collections	טאפל בלתי ניתן לשינוי עם שדות בעלי שם.
deque	collections	תור דו-צדדי — יעיל לפעולת הוספה/מחיקה משני הקצוות.
Counter	collections	תת-מחלקה של מילון לספירת אובייקטים הגיבוליים.
defaultdict	collections	מילון עם ערכי ברירת מחדל עבור מפתחות חסרים.
dataclass	dataclasses	מייצר אוטומטית __init__, __repr__, __eq__ וכו'.
UserList	collections	מחלקה בסיסית לאובייקטים דמויי רשימה מותאמים אישית.
UserDict	collections	מחלקה בסיסית לאובייקטים דמויי מילון מותאמים אישית.

---

סוגים דמויי אוסף נוספים

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

1. str — מחרוזת

רצף מסודר, בלתי ניתן לשינוי של תווים.

s = "Python"
print(len(s))        # → 6
print(s[0])          # → P
print('y' in s)      # → True
print(list(s))       # → ['P', 'y', 't', 'h', 'o', 'n']

---

2. bytes, bytearray

• bytes — רצף בלתי ניתן לשינוי של בתים.
• bytearray — גרסה ניתנת לשינוי.

b = b"שלום"
print(b[0])          # → 215
print(len(b))        # → 10

ba = bytearray(b"שלום")
ba[0] = 65
print(ba)            # → bytearray(b'A\xbc\x9c\xbc\x95\xbc\x9d')

---

3. range

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

r = range(3)
print(list(r))       # → [0, 1, 2]
print(1 in r)        # → True
print(r[2])          # → 2

---

4. array.array

מאחסן נתונים מספריים הומוגניים בצורה קומפקטית (כמו ב-C).

from array import array
arr = array('i', [1, 2, 3])
print(arr)           # → array('i', [1, 2, 3])

---

5. גנרטורים ואיטרטורים

לא מאחסנים נתונים — מייצרים אותם לפי דרישה. לא תומכים ב-len() או אינדוקסציה.

gen = (x * 2 for x in range(3))
print(list(gen))     # → [0, 2, 4]
# len(gen) → TypeError

---

6. ChainMap (מ-collections)

מאחד מספר מילונים לתוך תצוגה אחת — החיפוש עובר דרך המפות לפי הסדר.

from collections import ChainMap

d1 = {'a': 1}
d2 = {'b': 2}
cm = ChainMap(d1, d2)
print(cm['a'])       # → 1
print(cm['b'])       # → 2

---

7. OrderedDict (מ-collections)

מילון הזוכר את סדר ההכנסה. רלוונטי עבור Python < 3.7.

from collections import OrderedDict

od = OrderedDict([('a', 1), ('b', 2)])
print(od)            # → OrderedDict([('a', 1), ('b', 2)])

---

8. enum.Enum, enum.Flag

אוספים של קבועים בעלי שם.

from enum import Enum

class Color(Enum):
    RED = 1
    GREEN = 2

print(list(Color))   # → [<Color.RED: 1>, <Color.GREEN: 2>]

---

9. typing.NamedTuple, typing.TypedDict

מעטפות מוטבעות סביב namedtuple ו-dict.

from typing import NamedTuple, TypedDict

class Person(NamedTuple):
    name: str
    age: int

p = Person("נועה", 25)

class Movie(TypedDict):
    title: str
    year: int

m: Movie = {"title": "מטריקס", "year": 1999}

---

10. heapq, bisect — כלים, לא אוספים

עובדים עם אוספים, אך אינם כאלה:

• heapq — אלגוריתם תור עדיפויות דרך רשימות.
• bisect — שומר על סדר ברשימות ממוינות.

---

1. רשימות — list

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

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

יצירת: []

adam_list = ["אדם", "תל אביב", 30, "מהנדס"]
print(f"יצירת רשימה: {adam_list}")
# → יצירת רשימה: ['אדם', 'תל אביב', 30, 'מהנדס']

print(f"אלמנט באינדקס 0: {adam_list[0]}")
# → אלמנט באינדקס 0: אדם

adam_list[2] = 31
print(f"לאחר שינוי: {adam_list}")
# → לאחר שינוי: ['אדם', 'תל אביב', 31, 'מהנדס']

adam_list.append("נשוי")
print(f"לאחר append: {adam_list}")
# → לאחר append: ['אדם', 'תל אביב', 31, 'מהנדס', 'נשוי']

adam_list.insert(1, "ישראל")
print(f"לאחר insert: {adam_list}")
# → לאחר insert: ['אדם', 'ישראל', 'תל אביב', 31, 'מהנדס', 'נשוי']

adam_list.remove("מהנדס")
print(f"לאחר remove לפי ערך: {adam_list}")
# → לאחר remove לפי ערך: ['אדם', 'ישראל', 'תל אביב', 31, 'נשוי']

del adam_list[2]
print(f"לאחר מחיקה לפי אינדקס: {adam_list}")
# → לאחר מחיקה לפי אינדקס: ['אדם', 'ישראל', 31, 'נשוי']

adam_list.extend(["תחביבים", "דייג"])
print(f"לאחר extend: {adam_list}")
# → לאחר extend: ['אדם', 'ישראל', 31, 'נשוי', 'תחביבים', 'דייג']

adam_list.pop()
print(f"לאחר pop: {adam_list}")
# → לאחר pop: ['אדם', 'ישראל', 31, 'נשוי', 'תחביבים']

---

2. מילונים — dict

אוסף של זוגות מפתח → ערך. המפתחות חייבים להיות ניתנים להאש. מאז Python 3.7, סדר ההכנסה נשמר.

שימושי לנתונים מובנים: פרופילים, תצורות, JSON.

יצירת: {}

noa_dict = {"name": "נועה", "age": 25, "city": "חיפה", "profession": "אמנית"}
print(f"יצירת מילון: {noa_dict}")
# → יצירת מילון: {'name': 'נועה', 'age': 25, 'city': 'חיפה', 'profession': 'אמנית'}

print(f"ערך עבור מפתח 'name': {noa_dict['name']}")
# → ערך עבור מפתח 'name': נועה

noa_dict["age"] = 26
print(f"לאחר עדכון: {noa_dict}")
# → לאחר עדכון: {'name': 'נועה', 'age': 26, 'city': 'חיפה', 'profession': 'אמנית'}

noa_dict["hobby"] = "ציור"
print(f"לאחר הוספת זוג: {noa_dict}")
# → לאחר הוספת זוג: {'name': 'נועה', 'age': 26, 'city': 'חיפה', 'profession': 'אמנית', 'hobby': 'ציור'}

del noa_dict["city"]
print(f"לאחר מחיקת זוג: {noa_dict}")
# → לאחר מחיקת זוג: {'name': 'נועה', 'age': 26, 'profession': 'אמנית', 'hobby': 'ציור'}

hobby = noa_dict.pop("hobby")
print(f"לאחר pop: {noa_dict}, ערך: {hobby}")
# → לאחר pop: {'name': 'נועה', 'age': 26, 'profession': 'אמנית'}, ערך: ציור

print(f"מפתח 'name' קיים: {'name' in noa_dict}")
# → מפתח 'name' קיים: True

---

3. טאפלים — tuple

אוסף מסודר, בלתי ניתן לשינוי. מתאים לנתונים קבועים.

משמש כאשר חוסר שינוי הוא קריטי: קואורדינטות, פרמטרים, ערכי החזרה.

יצירת: ()

adam_tuple = ("אדם", "תל אביב", 30, "מהנדס")
print(f"יצירת טאפל: {adam_tuple}")
# → יצירת טאפל: ('אדם', 'תל אביב', 30, 'מהנדס')

print(f"אלמנט באינדקס 2: {adam_tuple[2]}")
# → אלמנט באינדקס 2: 30

# adam_tuple[0] = "יואב"  → TypeError
# adam_tuple.append("משהו") → AttributeError

• טאפלים משתמשים בפחות זיכרון ומהירים יותר מרשימות.
• אידיאליים כאשר שינוי אינו נדרש.

---

4. SimpleNamespace

מחלקה פשוטה מ-types ליצירת אובייקטים עם מאפיינים דינמיים. גישה באמצעות נוטציית נקודה (obj.attr).

שימושי כאשר רוצים תחביר obj.name ללא הגדרת מחלקה מלאה.

from types import SimpleNamespace

noa_ns = SimpleNamespace(name="נועה", age=25, city="חיפה")
print(f"אובייקט: {noa_ns}")
# → אובייקט: namespace(name='נועה', age=25, city='חיפה')

print(f"שם: {noa_ns.name}")
# → שם: נועה

noa_ns.age = 26
print(f"לאחר עדכון: {noa_ns}")
# → לאחר עדכון: namespace(name='נועה', age=26, city='חיפה')

noa_ns.profession = "אמנית"
print(f"עם מאפיין חדש: {noa_ns}")
# → עם מאפיין חדש: namespace(name='נועה', age=26, city='חיפה', profession='אמנית')

del noa_ns.city
print(f"לאחר מחיקה: {noa_ns}")
# → לאחר מחיקה: namespace(name='נועה', age=26, profession='אמנית')

setattr(noa_ns, "hobby", "ציור")
print(f"דרך setattr: {noa_ns}")
# → דרך setattr: namespace(name='נועה', age=26, profession='אמנית', hobby='ציור')

delattr(noa_ns, "hobby")
print(f"דרך delattr: {noa_ns}")
# → דרך delattr: namespace(name='נועה', age=26, profession='אמנית')

• חלופה למילון כאשר obj.name עדיף על obj['name'].

---

5. קבוצות — set

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

משמש להסרת כפילויות ובדיקת שייכות.

יצירת: {} או set()

numbers = {1, 2, 3, 3, 2, 1}
print(f"קבוצה: {numbers}")
# → קבוצה: {1, 2, 3}

numbers.add(4)
print(f"לאחר הוספה: {numbers}")
# → לאחר הוספה: {1, 2, 3, 4}

numbers.remove(2)
print(f"לאחר הסרה: {numbers}")
# → לאחר הסרה: {1, 3, 4}

others = {3, 4, 5}
print(f"איחוד: {numbers | others}")
# → איחוד: {1, 3, 4, 5}

print(f"חיתוך: {numbers & others}")
# → חיתוך: {3, 4}

print(f"הפרש: {numbers - others}")
# → הפרש: {1}

---

6. קבוצות בלתי ניתנות לשינוי — frozenset

גרסה בלתי ניתנת לשינוי של set. ניתן להשתמש בה כמפתח במילון או כאיבר בקבוצה אחרת.

frozen = frozenset([1, 2, 3, 2])
print(f"frozenset: {frozen}")
# → frozenset: frozenset({1, 2, 3})

others = frozenset([3, 4])
print(f"חיתוך: {frozen & others}")
# → חיתוך: frozenset({3})

print(f"איחוד: {frozen | others}")
# → איחוד: frozenset({1, 2, 3, 4})

# frozen.add(5) → AttributeError

---

7. namedtuple — טאפלים בעלי שם

מבנה בלתי ניתן לשינוי עם גישה לפי שם שדה. קריא יותר מטאפלים רגילים.

from collections import namedtuple

Person = namedtuple("Person", ["name", "age", "city"])
noa = Person("נועה", 25, "חיפה")

print(f"אובייקט: {noa}")
# → אובייקט: Person(name='נועה', age=25, city='חיפה')

print(f"שם: {noa.name}")
# → שם: נועה

print(f"גיל: {noa[1]}")
# → גיל: 25

# noa.age = 26 → AttributeError

noa_new = noa._replace(age=26)
print(f"עותק עם שינוי: {noa_new}")
# → עותק עם שינוי: Person(name='נועה', age=26, city='חיפה')

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

---

8. deque — תור דו-צדדי

מאופטם לפעולת הוספה/מחיקה מהירה משני הקצוות. יעיל יותר מ-list עבור appendleft, popleft.

from collections import deque

d = deque([1, 2, 3])
print(f"deque ראשוני: {d}")
# → deque ראשוני: deque([1, 2, 3])

d.appendleft(0)
print(f"לאחר appendleft: {d}")
# → לאחר appendleft: deque([0, 1, 2, 3])

d.append(4)
print(f"לאחר append: {d}")
# → לאחר append: deque([0, 1, 2, 3, 4])

left = d.popleft()
print(f"לאחר popleft: {left}, נותר: {d}")
# → לאחר popleft: 0, נותר: deque([1, 2, 3, 4])

right = d.pop()
print(f"לאחר pop: {right}, נותר: {d}")
# → לאחר pop: 4, נותר: deque([1, 2, 3])

• בשימוש באלגוריתמים: BFS, מטמיעי LRU, חוצצים — כאשר פעולות בקצוות צריכות להיות מהירות.

---

9. Counter — סופר אלמנטים

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

from collections import Counter

text = "abracadabra"
c = Counter(text)
print(f"ספירת אותיות: {c}")
# → ספירת אותיות: Counter({'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1})

print(f"תדירות של 'a': {c['a']}")
# → תדירות של 'a': 5

print(f"TOP 3: {c.most_common(3)}")
# → TOP 3: [('a', 5), ('b', 2), ('r', 2)]

c2 = Counter("bukva")
c.update(c2)
print(f"לאחר update: {c}")
# → לאחר update: Counter({'a': 6, 'b': 3, 'r': 2, 'c': 1, 'd': 1, 'u': 1, 'k': 1, 'v': 1})

• שימושי לניתוח טקסט, לוגים, הצבעות — בכל מקום שבו צריך לספור "מה מופיע הכי הרבה".

---

10. defaultdict — מילון עם ערכי ברירת מחדל

יוצר אוטומטית ערכי ברירת מחדל עבור מפתחות חסרים. מסיר את הצורך בבדיקות if key in dict.

from collections import defaultdict

dd_list = defaultdict(list)
dd_list["fruits"].append("תפוח")
dd_list["fruits"].append("בננה")
print(f"רשימה: {dict(dd_list)}")
# → רשימה: {'fruits': ['תפוח', 'בננה']}

dd_int = defaultdict(int)
for char in "abracadabra":
    dd_int[char] += 1
print(f"ספירות: {dict(dd_int)}")
# → ספירות: {'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1}

dd_set = defaultdict(set)
dd_set["cities"].add("תל אביב")
dd_set["cities"].add("חיפה")
print(f"קבוצה: {dict(dd_set)}")
# → קבוצה: {'cities': {'תל אביב', 'חיפה'}}

• מסיר קוד שחוזר על עצמו כמו if key not in d: d[key] = [].
• הופך את הקוד לפשוט ובטוח יותר.

---

11. dataclass — מחלקות נתונים

דקורטור היוצר אוטומטית __init__, __repr__, __eq__ וכו'.

from dataclasses import dataclass

@dataclass
class Person:
    name: str
    age: int
    city: str = "לא צוין"

noa = Person("נועה", 25)
print(f"אובייקט: {noa}")
# → אובייקט: Person(name='נועה', age=25, city='לא צוין')

print(f"שם: {noa.name}")
# → שם: נועה

noa.age = 26
print(f"לאחר עדכון: {noa}")
# → לאחר עדכון: Person(name='נועה', age=26, city='לא צוין')

yoav = Person("יואב", 30)
print(f"נועה == יואב: {noa == yoav}")
# → נועה == יואב: False

@dataclass(frozen=True)
class ImmutablePerson:
    name: str
    age: int

itay = ImmutablePerson("איתי", 40)
# itay.age = 41 → FrozenInstanceError

• מחליף כתיבה ידנית של __init__, __repr__, __eq__.
• אידיאלי ל-DTO, תצורות, מודלים.

---

12. UserList — רשימות מותאמות אישית

יורש מ-collections.UserList. משמש ליצירת רשימות עם התנהגות מותאמת אישית.

from collections import UserList

class LoggingList(UserList):
    def append(self, item):
        print(f"[LOG] הוספה: {item}")
        super().append(item)

    def remove(self, item):
        print(f"[LOG] הסרה: {item}")
        super().remove(item)

log_list = LoggingList([1, 2, 3])
print(f"התחלתי: {log_list}")
# → התחלתי: [1, 2, 3]

log_list.append(4)
# → [LOG] הוספה: 4
print(f"לאחר append: {log_list}")
# → לאחר append: [1, 2, 3, 4]

log_list.remove(2)
# → [LOG] הסרה: 2
print(f"לאחר remove: {log_list}")
# → לאחר remove: [1, 3, 4]

• שימושי להוספת לוגים, אימות, או שינוי ההתנהגות הסטנדרטית של רשימות.

---

13. UserDict — מילונים מותאמים אישית

יורש מ-collections.UserDict. משמש ליצירת מילונים עם התנהגות מותאמת אישית.

from collections import UserDict

class LowercaseDict(UserDict):
    def __setitem__(self, key, value):
        key = key.lower() if isinstance(key, str) else key
        super().__setitem__(key, value)

    def __getitem__(self, key):
        key = key.lower() if isinstance(key, str) else key
        return super().__getitem__(key)

ld = LowercaseDict()
ld["Name"] = "נועה"
print(f"ערך עבור 'Name': {ld['Name']}")
# → ערך עבור 'Name': נועה
print(f"ערך עבור 'name': {ld['name']}")
# → ערך עבור 'name': נועה
print(f"מפתחות: {list(ld.keys())}")
# → מפתחות: ['name']

• בשימוש לנרמול מפתחות, אימות, לוגים, מטמון וכו'.

---

📈 השוואת זיכרון וביצועים

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

---

1. זיכרון: list vs tuple vs array.array

import sys
from array import array

n = 1_000_000
data = list(range(n))
data_t = tuple(range(n))
data_a = array('i', range(n))

print(f"list:  {sys.getsizeof(data) / 1024 / 1024:.2f} MB")
# → list:  8.00 MB

print(f"tuple: {sys.getsizeof(data_t) / 1024 / 1024:.2f} MB")
# → tuple: 8.00 MB

print(f"array: {sys.getsizeof(data_a) / 1024 / 1024:.2f} MB")
# → array: 3.81 MB

• array.array משתמש ב~2x פחות זיכרון למספרים.
• list ו-tuple משתמשים בזיכרון דומה, אך tuple מהיר יותר מעט באיטרציה.

---

2. מהירות גישה: list vs tuple vs array.array

import time

def time_access(collection, name):
    start = time.perf_counter()
    total = 0
    for i in range(len(collection)):
        total += collection[i]
    end = time.perf_counter()
    print(f"{name}: {end - start:.4f} שניות")

n = 10_000_000
lst = list(range(n))
tpl = tuple(range(n))
arr = array('i', range(n))

time_access(lst, "list")   # → list: 1.2000 שניות
time_access(tpl, "tuple")  # → tuple: 1.0000 שניות
time_access(arr, "array")  # → array: 0.8000 שניות

• array.array הכי מהיר לנתונים מספריים.
• tuple מהיר ב-10–20% מ-list.
• ההבדל בולט בקנה מידה גדול.

---

3. זיכרון: dict vs SimpleNamespace vs dataclass

d = {"name": "A", "age": 25, "city": "X", "hobby": "Y", "job": "Z"}
ns = SimpleNamespace(name="A", age=25, city="X", hobby="Y", job="Z")
dc = Person("A", 25, "X")

print(f"dict:      {sys.getsizeof(d)} בתים")          # → 232
print(f"SimpleNamespace: {sys.getsizeof(ns)} בתים")   # → 64
print(f"dataclass: {sys.getsizeof(dc)} בתים")         # → 64
print(f"ns.__dict__: {sys.getsizeof(ns.__dict__)} בתים")  # → 232

• SimpleNamespace ו-dataclass משתמשים באותה כמות זיכרון כמו dict בגלל __dict__.
• השתמש ב-__slots__ לחיסכון בזיכרון.

---

4. אופטימיזציית זיכרון: dataclass עם __slots__

@dataclass
class PersonSlots:
    __slots__ = ("name", "age", "city", "hobby", "job")
    name: str
    age: int
    city: str
    hobby: str
    job: str

dc_slots = PersonSlots("A", 25, "X", "Y", "Z")
print(f"dataclass + slots: {sys.getsizeof(dc_slots)} בתים")
# → 80 בתים

# dc_slots.new = "value" → AttributeError

• __slots__ חוסך זיכרון ומאיץ גישה למאפיינים.
• החסרון: לא ניתן להוסיף מאפיינים דינמיים.

---

5. מהירות חיפוש: list vs set

n = 1_000_000
lst = list(range(n))
st = set(range(n))

def time_in(collection, target, name):
    start = time.perf_counter()
    for _ in range(1000):
        _ = target in collection
    end = time.perf_counter()
    print(f"{name} (חיפוש {target}): {end - start:.4f} שניות")

time_in(lst, 999_999, "list")   # → 10.0000 שניות
time_in(st, 999_999, "set")     # → 0.0005 שניות

• set מהיר פי אלפיים מ-list לבדיקת שייכות.
• תמיד השתמש ב-set לבדיקות תכופות של x in collection.

---

6. זיכרון: set vs frozenset

s = set(range(1000))
fs = frozenset(range(1000))

print(f"set:       {sys.getsizeof(s)} בתים")     # → 32792
print(f"frozenset: {sys.getsizeof(fs)} בתים")   # → 32792

• frozenset ו-set משתמשים באותה כמות זיכרון.
• ההבדל הוא רק בשינוי.

---

7. מהירות הוספה: list.append vs deque.append vs deque.appendleft

from collections import deque
import time

def time_append(collection, n, method='append'):
    start = time.perf_counter()
    for i in range(n):
        if method == 'appendleft' and hasattr(collection, 'appendleft'):
            collection.appendleft(i)
        else:
            collection.append(i)
    end = time.perf_counter()
    return end - start

n = 100_000

lst = []
dq = deque()

time_list_append = time_append(lst, n)              # → 0.0100 שניות
time_deque_append = time_append(dq, n)              # → 0.0100 שניות
time_deque_appendleft = time_append(deque(), n, 'appendleft')  # → 0.0100 שניות

# list.insert(0):
lst = []
start = time.perf_counter()
for i in range(n):
    lst.insert(0, i)
end = time.perf_counter()
print(f"list.insert(0):   {end - start:.4f} שניות")   # → 5.0000 שניות

• deque.appendleft עובד ב-O(1), בניגוד ל-list.insert(0) שהוא O(n).
• השתמש ב-deque לפעולת תכופות בשני הקצוות.

---

🧠 המלצות לביצועים

מצב	השתמש ב	סיבה
אחסון מספרים, זיכרון קריטי	array.array	2x פחות זיכרון, גישה מהירה יותר
נתונים בלתי ניתנים לשינוי	tuple	מהיר יותר מ-list, בטוח יותר
בדיקות תכופות x in collection	set / frozenset	O(1) נגד O(n) של list
פעולות בשני הקצוות	deque	appendleft/popleft ב-O(1)
נתונים מובנים, זיכרון קריטי	dataclass + __slots__	ללא __dict__, פחות זיכרון
ספירת תדירויות	Counter	מותאם למטרה זו
התנהגות מותאמת אישית	UserList / UserDict	הרחבה בטוחה של אוספים מובנים

---

📊 השוואת אוספים

סוג	מסודר	ניתן לשינוי	אלמנטים ייחודיים	גישה לאינדקס	כפילויות
list	✅ כן	✅ כן	❌ לא	✅ כן	✅ כן
tuple	✅ כן	❌ לא	❌ לא	✅ כן	✅ כן
dict	✅ כן*	✅ כן	רק מפתחות	❌ לא	ערכים: ✅
set	❌ לא	✅ כן	✅ כן	❌ לא	❌ לא
frozenset	❌ לא	❌ לא	✅ כן	❌ לא	❌ לא
SimpleNamespace	✅ כן (מאפיינים)	✅ כן	❌ לא (מאפיינים יכולים לחזור על עצמם סמנטית)	❌ לא	✅ כן
namedtuple	✅ כן	❌ לא	❌ לא	✅ כן	✅ כן
deque	✅ כן	✅ כן	❌ לא	✅ כן	✅ כן
Counter	❌ לא	✅ כן	❌ לא	❌ לא (אבל יש מפתחות)	✅ כן
defaultdict	✅ כן*	✅ כן	רק מפתחות	❌ לא	ערכים: ✅
dataclass	✅ כן (שדות)	✅ כן (אם לא frozen)	❌ לא	❌ לא	✅ כן
UserList	✅ כן	✅ כן	❌ לא	✅ כן	✅ כן
UserDict	✅ כן*	✅ כן	רק מפתחות	❌ לא	ערכים: ✅
str	✅ כן	❌ לא	❌ לא	✅ כן	✅ כן
bytes	✅ כן	❌ לא	❌ לא	✅ כן	✅ כן
bytearray	✅ כן	✅ כן	❌ לא	✅ כן	✅ כן
range	✅ כן	❌ לא	❌ לא	✅ כן	❌ לא
array.array	✅ כן	✅ כן	❌ לא	✅ כן	✅ כן
ChainMap	✅ כן*	✅ כן	רק מפתחות	❌ לא	ערכים: ✅
Enum	✅ כן	❌ לא	✅ כן (חברי)	❌ לא	❌ לא

• — מאז Python 3.7, dict, defaultdict, UserDict, ChainMap שומרים על סדר ההכנסה.

---

💡 מתי להשתמש במה?

משימה	אוסף
רצף ניתן לשינוי	list / deque / UserList / bytearray
נתונים בלתי ניתנים לשינוי	tuple / namedtuple / frozenset / str / bytes
חיפוש מהיר, הסרת כפילויות	set / frozenset
נתונים מובנים	dict / dataclass / SimpleNamespace / UserDict / TypedDict
ניתן לשימוש כמפתח במילון	frozenset
אובייקטים זמניים עם גישה דרך .	SimpleNamespace / dataclass
ספירת תדירויות	Counter
ערכי ברירת מחדל עבור מפתחות	defaultdict
פעולות יעילות בקצוות	deque
התנהגות מותאמת אישית של רשימה	UserList
התנהגות מותאמת אישית של מילון	UserDict
נתונים בינאריים	bytes / bytearray / array.array
תצורות עם היררכיה	ChainMap
קבועים בעלי שם	Enum
רצפים עצלנים	range / גנרטורים