המודול array מספק טיפוס נתונים ייעודי, array.array, לאחסון רצפים של מספרים הומוגניים (מאותו סוג). בניגוד לטיפוס הכללי list, מערכי array.array מציעים שימוש יעיל יותר בזיכרון וביצועים משופרים בעבודה עם נתונים מספריים.

---

📦 יתרונות מרכזיים של array.array

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

---

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

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

import array
import sys

def compare_memory_usage(num_elements: int = 1_000_000) -> None:
    """
    משווה את צריכת הזיכרון בין list ל-array.array.

    Args:
        num_elements (int, optional): מספר הרכיבים לבדיקה. 
                                      ברירת מחדל היא 1,000,000.
    """
    # יצירת רשימה עם אובייקטים שלמים של פייתון
    list_numbers = list(range(num_elements))

    # יצירת מערך שבו מספרים מאוחסנים כמספרים שלמים מטיפוס C בגודל 4 בתים
    array_numbers = array.array('i', range(num_elements))

    list_size = sys.getsizeof(list_numbers)
    array_size = sys.getsizeof(array_numbers)

    print(f"מספר רכיבים: {num_elements}")
    print(f"גודל הרשימה:  {list_size / 1024 / 1024:.2f} MB")
    print(f"גודל המערך: {array_size / 1024 / 1024:.2f} MB")
    if array_size > 0:
        print(f"חיסכון בזיכרון: פי {list_size / array_size:.2f}")

# דוגמה לשימוש
if __name__ == "__main__":
    compare_memory_usage()

פלט:

מספר רכיבים: 1000000
גודל הרשימה:  7.63 MB
גודל המערך: 3.82 MB
חיסכון בזיכרון: פי 2.00

---

2. ביצועים משופרים בפעולות נומריות

בזכות הקצאת זיכרון רציפה, פעולות מתמטיות על רכיבי array.array מתבצעות מהר יותר, מכיוון שהמעבד יכול לנצל את זיכרון המטמון (cache) ביעילות רבה יותר.

import array
import timeit

def compare_performance(num_elements: int = 10_000_000) -> None:
    """
    משווה את ביצועי סיכום הרכיבים ב-list וב-array.array.

    Args:
        num_elements (int, optional): מספר הרכיבים לבדיקה. 
                                      ברירת מחדל היא 10,000,000.
    """
    setup_code = f"""
import array
data = range({num_elements})
list_data = list(data)
array_data = array.array('i', data)
"""

    # מדידת זמן עבור רשימה
    list_time = timeit.timeit("sum(list_data)", setup=setup_code, number=10)

    # מדידת זמן עבור מערך
    array_time = timeit.timeit("sum(array_data)", setup=setup_code, number=10)

    print(f"זמן לסיכום {num_elements} רכיבים (10 פעמים):")
    print(f"רשימה:  {list_time:.4f} שניות")
    print(f"מערך: {array_time:.4f} שניות")

# דוגמה לשימוש
if __name__ == "__main__":
    compare_performance()

פלט:

זמן לסיכום 10000000 רכיבים (10 פעמים):
רשימה:  2.1106 שניות
מערך: 1.1549 שניות

---

3. עבודה ישירה עם ספריות C (באמצעות ctypes, struct)

array.array הוא אידיאלי להעברת נתונים לספריות low-level שנכתבו בשפת C, מכיוון שהמבנה הפנימי שלו תואם למערכים בשפת C.

דוגמה עם ctypes:

import array
from ctypes import c_double, CDLL

def demonstrate_ctypes_usage() -> None:
    """
    מדגים העברת array.array לפונקציית C באמצעות ctypes.
    """
    # מערך עם מספרים בדיוק כפול (טיפוס 'd')
    py_array = array.array('d', [1.1, 2.2, 3.3, 4.4])

    # יצירת מערך תואם-C מתוך py_array
    # הפונקציה (c_double * len(py_array)) יוצרת טיפוס "מערך של 4 c_double"
    # הביטוי (*py_array) פורס את מערך הפייתון לארגומנטים של הבנאי הזה
    c_array = (c_double * len(py_array))(*py_array)

    # כאן יכולה להיות קריאה לפונקציית C, לדוגמה:
    # my_c_library = CDLL("./libmath.so")
    # my_c_library.sum_doubles(c_array, len(c_array))

    print(f"מערך פייתון: {py_array}")
    print(f"מערך תואם-C (ctypes): {[val for val in c_array]}")

# דוגמה לשימוש
if __name__ == "__main__":
    demonstrate_ctypes_usage()```

#### דוגמה עם `struct` לאריזת נתונים:

python
import array
import struct

def demonstrate_struct_packing(data: list[int]) -> bytes:
"""
אורז מערך של מספרים שלמים למחרוזת בינארית.

Args:
    data (list[int]): רשימת מספרים שלמים לאריזה.

Returns:
    bytes: ייצוג בינארי של הנתונים.
"""
arr = array.array('i', data)

# יצירת מחרוזת פורמט כמו '3i' עבור 3 מספרים שלמים
format_string = f'{len(arr)}i'

# אריזת הנתונים לפורמט בינארי
binary_data = struct.pack(format_string, *arr)

print(f"מערך מקורי: {arr}")
print(f"נתונים בינאריים: {binary_data}")

# בדיקה: פריסה חזרה
unpacked_data = struct.unpack(format_string, binary_data)
print(f"נתונים לאחר פריסה: {unpacked_data}")

return binary_data

דוגמה לשימוש

if name == "main":
demonstrate_struct_packing([10, 20, 30])

---

### 4. סריאליזציה ודה-סריאליזציה יעילות

המתודות `.tobytes()` ו-`.frombytes()` מאפשרות להמיר במהירות מערך לבתים ובחזרה, מה שאידיאלי לשמירה בקבצים או להעברה ברשת.

python
import array

def handle_binary_data() -> None:
"""
מדגים סריאליזציה ודה-סריאליזציה של array.array לבתים.
"""
# יצירת מערך מקור
source_array = array.array('i', [1, 2, 3, 4, 5])
print(f"מערך מקורי: {source_array}")

# סריאליזציה של המערך לבתים
binary_data = source_array.tobytes()
print(f"נתונים בבתים: {binary_data}")

# דה-סריאליזציה מבתים למערך חדש
new_array = array.array('i')
new_array.frombytes(binary_data)
print(f"מערך משוחזר: {new_array}")

# בדיקת תקינות
assert source_array == new_array, "אי-התאמה בנתונים!"
print("תקינות הנתונים אומתה.")

דוגמה לשימוש

if name == "main":
handle_binary_data()

---

### 5. הבטחת הומוגניות של טיפוסים

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

python
import array

def demonstrate_type_safety() -> None:
"""
מראה ש-array.array אינו מאפשר הוספת רכיבים מטיפוס שונה.
"""
arr = array.array('i', [100, 200, 300])
print(f"מערך מספרים שלמים: {arr}")

try:
    # ניסיון להוסיף רכיב מסוג מחרוזת
    arr.append('hello')
except TypeError as e:
    # חריגה צפויה
    print(f"\nהניסיון להוסיף 'hello' גרם לשגיאה: {e}")
    print("דבר זה מאשר את אכיפת הטיפוסים המחמירה של המערך.")

דוגמה לשימוש

if name == "main":
demonstrate_type_safety()

---

### 6. כתיבה וקריאה ישירה מקבצים בינאריים

המתודות `.tofile()` ו-`.fromfile()` מפשטות את העבודה עם קבצים בינאריים, תוך הימנעות מסריאליזציה כשלב ביניים.

python
import array
from pathlib import Path

def work_with_binary_files(file_path_str: str = "data.bin") -> None:
"""
כותב מערך לקובץ בינארי וקורא אותו בחזרה.

Args:
    file_path_str (str, optional): שם הקובץ לשמירה.
                                   ברירת מחדל היא "data.bin".
"""
file_path = Path(file_path_str)
source_array = array.array('f', [1.5, 2.7, 3.14])

try:
    # כתיבה לקובץ
    with file_path.open('wb') as f:
        source_array.tofile(f)
    print(f"המערך {source_array} נכתב לקובץ '{file_path}'.")

    # קריאה מהקובץ
    new_array = array.array('f')
    with file_path.open('rb') as f:
        # קריאת 3 רכיבים מטיפוס 'f' (float)
        new_array.fromfile(f, len(source_array))
    print(f"המערך {new_array} נקרא מהקובץ.")

    assert source_array == new_array

finally:
    # הבטחת מחיקת הקובץ לאחר הביצוע
    if file_path.exists():
        file_path.unlink()
        print(f"הקובץ הזמני '{file_path}' נמחק.")

דוגמה לשימוש

if name == "main":
work_with_binary_files()
"`

---

🔹 טבלת השוואה: array.array מול list

מאפיין	array.array	list
טיפוס נתונים	טיפוסים פרימיטיביים והומוגניים (מספרים, תווים)	כל אובייקט פייתון
זיכרון	צריכה נמוכה	צריכה גבוהה
ביצועים	גבוהים בפעולות נומריות	נמוכים יותר בפעולות נומריות
API	סט מוגבל של מתודות	API עשיר וגמיש
תאימות ל-C	גבוהה, העברת נתונים ישירה	דורש המרות
סריאליזציה בינארית	מתודות מובנות (.tobytes, .tofile)	דורש שימוש ב-struct, pickle וכו'.

---

מסקנה:

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

לרוב המשימות היומיומיות, שבהן נדרשת גמישות ואחסון של נתונים הטרוגניים, list נותר הבחירה הטובה ביותר.