List Comprehension ב-Python: תחביר, סינון ו-Dict Comprehensions

שורה אחת, רעיון אחד

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

numbers = [1, 2, 3, 4, 5]

doubled = []
for n in numbers:
    doubled.append(n * 2)

print(doubled)

list comprehension אומרת את אותו הדבר בשורה אחת:

numbers = [1, 2, 3, 4, 5]

doubled = [n * 2 for n in numbers]
print(doubled)

קראו את זה כך: "רשימה חדשה שמורכבת מ-n * 2, עבור כל n ב-numbers". המבנה הוא [expression for item in iterable].

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

הוספת סינון

הוסיפו פסוקית if אחרי חלק הלולאה כדי לסנן:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

evens = [n for n in numbers if n % 2 == 0]
print(evens)

squares_of_odds = [n * n for n in numbers if n % 2 == 1]
print(squares_of_odds)

קראו את השנייה כך: "n * n עבור כל n ב-numbers, אבל רק אם n אי-זוגי".

הלולאה השקולה:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

squares_of_odds = []
for n in numbers:
    if n % 2 == 1:
        squares_of_odds.append(n * n)

print(squares_of_odds)

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

מיפוי וסינון יחד

אפשר להעביר ערכים דרך פונקציה ולסנן באותו זמן:

words = ["python", "is", "great", "fun"]

long_upper = [w.upper() for w in words if len(w) > 3]
print(long_upper)

עבור כל מילה שארוכה מ-3 אותיות, מכניסים את הגרסה שלה באותיות גדולות.

לולאות מקוננות בתוך comprehension

שני for מייצרים זוגות בסגנון של מכפלה קרטזית:

suits = ["♠", "♥", "♦", "♣"]
ranks = ["J", "Q", "K", "A"]

deck = [rank + suit for suit in suits for rank in ranks]
print(deck)

הסדר זהה לסדר שהיה לכם אילו קיננתם את הלולאות: ה-for הראשון הוא החיצוני, והשני הוא הפנימי. זה נקרא משמאל לימין כמו הלולאה המוזחת השקולה.

שתי רמות הן בערך הגבול, ומעבר לזה לולאה רגילה קריאה יותר. אם הגעתם לשלוש, חזרו ללולאות.

Dict ו-Set Comprehensions

אותו רעיון, סוגריים אחרים:

numbers = [1, 2, 3, 4, 5]

# Dict comprehension: מייצרת dict
squares = {n: n * n for n in numbers}
print(squares)

# Set comprehension: מייצרת set
unique_squares = {n * n for n in [1, -1, 2, -2, 3]}
print(unique_squares)

set comprehensions נראות במבט ראשון זהות ל-dict comprehensions. ההבדל הוא key: value לעומת ביטוי יחיד. סוגריים מסולסלים עם : הם dict, סוגריים מסולסלים בלי : הם set.

Generator Expressions

כמעט תאום של list comprehension, אבל עם סוגריים עגולים במקום מרובעים, ובעיקר: היא לא בונה רשימה:

numbers = [1, 2, 3, 4, 5]

total = sum(n * n for n in numbers)
print(total)

any_negative = any(n < 0 for n in numbers)
print(any_negative)

שימו לב שהעברנו את ה-generator ישירות ל-sum() ול-any(), בלי סוגריים נוספים. generator expressions הן הכלי הנכון כשמי שקורא להן צריך לעבור על הערכים פעם אחת בלבד. הן חסכוניות יותר בזיכרון מרשימה מלאה עבור אוספים גדולים.

מתי להשתמש בלולאה רגילה במקום

comprehensions מפתות. טכנית אפשר לדחוס לתוכן הרבה. לא כדאי.

העדיפו לולאה פשוטה כאשר:

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

הכלל שאני מפעיל: אם אפשר לקרוא את ה-comprehension בנשימה אחת ולהבין מה היא עושה, היא נשארת. אם אני מועד, אני כותב אותה מחדש כלולאה.

יש comprehensions שנראות מתוחכמות אבל מזיקות:

# מתוחכם אבל מתיש:
data = [(x, y) for x in range(5) for y in range(5) if (x + y) % 2 == 0 and x != y]

# ברור יותר כלולאה:
data = []
for x in range(5):
    for y in range(5):
        if (x + y) % 2 == 0 and x != y:
            data.append((x, y))

print(data)

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

כמה דפוסים שתשתמשו בהם שוב ושוב

users = [
    {"name": "Ada", "active": True},
    {"name": "Boris", "active": False},
    {"name": "Ciara", "active": True},
]

# לקחת attribute אחד מכל איבר.
names = [u["name"] for u in users]
print(names)

# לסנן ולבחור שדה בבת אחת.
active_names = [u["name"] for u in users if u["active"]]
print(active_names)

# לבנות dict לחיפוש לפי שדה.
by_name = {u["name"]: u for u in users}
print(by_name["Ada"])

# לספור כמה עוברים בדיקה.
active_count = sum(1 for u in users if u["active"])
print(active_count)

חמשת הדפוסים האלה מכסים כמות מפתיעה של עבודה יומיומית עם נתונים.

הצעד הבא

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