מילונים ב-Python: יצירה, גישה, עדכון ומעבר על dict

מילון הוא טבלת חיפוש

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

prices = {
    "apple": 0.50,
    "bread": 2.00,
    "milk": 1.20,
}

print(prices["apple"])
print(prices["bread"])

המפתחות והערכים יכולים להיות כמעט כל דבר. מפתחות צריכים להיות hashable (כלומר: מספרים, מחרוזות, tuples; לא רשימות ולא dicts אחרים). על ערכים אין שום הגבלה: dict יכול להכיל כל דבר, כולל dicts או רשימות אחרים.

יצירת מילונים

יש כמה דרכים, ולכל אחת המקום שלה:

# ליטרל עם סוגריים מסולסלים
user = {"name": "Rosa", "age": 30, "city": "Lisbon"}
print(user)

# dict ריק שנבנה עם הזמן
counts = {}
counts["a"] = 1
counts["b"] = 2
print(counts)

# מרשימה של זוגות (מפתח, ערך)
pairs = [("one", 1), ("two", 2), ("three", 3)]
mapping = dict(pairs)
print(mapping)

# עם ארגומנטים בעלי שם
config = dict(host="localhost", port=8080, debug=True)
print(config)

קריאת ערכים

שתי דרכים, והבחירה ביניהן חשובה:

prices = {"apple": 0.50, "bread": 2.00}

# []: גישה ישירה לפי מפתח. KeyError אם הוא חסר.
print(prices["apple"])

# .get(): מחזירה None (או ברירת מחדל) אם המפתח חסר.
print(prices.get("milk"))              # None
print(prices.get("milk", 0.00))        # 0.00

בחרו לפי הכוונה:

• השתמשו ב-[] כשהמפתח חייב להיות שם. אם הוא לא שם, זה באג ואתם רוצים שגיאה רועשת.
• השתמשו ב-.get() כש"לא קיים" הוא מקרה תקין. זה מאפשר לכתוב ברירות מחדל בלי try/except.

הוספה, עדכון ומחיקה

הצבה למפתח יוצרת אותו או מעדכנת אותו:

prices = {"apple": 0.50, "bread": 2.00}

prices["milk"] = 1.20        # מפתח חדש
prices["apple"] = 0.60       # מפתח קיים, נדרס

print(prices)

del prices["bread"]          # הסרת מפתח; KeyError אם הוא חסר
print(prices)

gone = prices.pop("apple")   # הסרה והחזרה; מקבלת ברירת מחדל
print("was:", gone, "now:", prices)

# pop עם ברירת מחדל כדי שלא תיזרק שגיאה
prices.pop("missing", None)

update() ממזגת dict אחר או אוסף של זוגות:

settings = {"theme": "dark", "font": "mono"}
overrides = {"font": "sans", "zoom": 1.2}

settings.update(overrides)
print(settings)

מפתחות משותפים ב-overrides דורסים את אלה שב-settings.

בדיקה אם מפתח קיים

in בודק את המפתחות, לא את הערכים:

user = {"name": "Rosa", "age": 30}

print("name" in user)      # True
print("email" in user)     # False
print("Rosa" in user)      # False: זה ערך, לא מפתח

כדי לבדוק דווקא ערכים, השתמשו ב-user.values():

print(30 in user.values())

איך עוברים על מילון בלולאה

יש שלוש תצוגות שאפשר לעבור עליהן בלולאה:

scores = {"ada": 90, "rosa": 85, "malik": 78}

# מפתחות (ברירת המחדל)
for name in scores:
    print(name)

# ערכים
for score in scores.values():
    print(score)

# שניהם: המקרה הנפוץ
for name, score in scores.items():
    print(f"{name}: {score}")

.items() היא מה שתשתמשו בו רוב הזמן: היא נותנת את הזוג, כבר מפורק ומוכן לשימוש.

סדר המעבר ב-Python מודרנית (3.7 ומעלה) תואם לסדר ההכנסה. dict הוא לא "שק קסמים": אם מוסיפים a, אחר כך b ואחר כך c, המעבר מחזיר אותם בסדר הזה. זו הבטחה של השפה שאפשר לסמוך עליה.

איך ממיינים מילון

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

scores = {"rosa": 85, "ada": 90, "malik": 78}

# מיון לפי מפתח
by_key = dict(sorted(scores.items()))
print(by_key)

# מיון לפי ערך (בסדר עולה)
by_value = dict(sorted(scores.items(), key=lambda item: item[1]))
print(by_value)

# מיון לפי ערך, בסדר יורד
top = dict(sorted(scores.items(), key=lambda item: item[1], reverse=True))
print(top)

sorted() מחזירה רשימה של זוגות; עטיפה שלה ב-dict(...) בונה מחדש מילון בסדר החדש. אם צריך רק את הזוגות הממוינים (ולא dict), וותרו על הקריאה החיצונית ל-dict().

איך ממזגים שני מילונים

Python 3.9 ומעלה נותנת את האופרטור |:

defaults = {"theme": "dark", "font": "mono"}
overrides = {"font": "sans", "zoom": 1.2}

merged = defaults | overrides
print(merged)

כשיש התנגשות מפתחות, הערכים מה-dict השני (זה שאחרי ה-|) מנצחים. .update() היא המקבילה שמשנה במקום. בגרסאות Python ישנות יותר, השתמשו ב-{**defaults, **overrides}.

הדפוס setdefault

צורך נפוץ: "אם המפתח קיים, השתמשו בערך שלו; אם לא, הגדירו ברירת מחדל ואז השתמשו בה".

counts = {}

for word in ["one", "two", "one", "three", "two", "one"]:
    counts.setdefault(word, 0)
    counts[word] += 1

print(counts)

או, עדיף, השתמשו ב-collections.Counter:

from collections import Counter

words = ["one", "two", "one", "three", "two", "one"]
print(Counter(words))

Counter היא תת-מחלקה של dict שסופרת כברירת מחדל. זו הבחירה הנכונה בכל פעם שסופרים מופעים.

Dictionary Comprehensions

מקבילות ל-list comprehensions, אבל לבניית dicts:

numbers = [1, 2, 3, 4, 5]
squares = {n: n * n for n in numbers}
print(squares)

# היפוך dict (מפתחות הופכים לערכים ולהפך)
prices = {"apple": 0.50, "bread": 2.00}
lookup = {v: k for k, v in prices.items()}
print(lookup)

אותם כללים כמו list comprehensions, אבל עם key: value בין הסוגריים המסולסלים.

dict כתאום של JSON

dicts של Python מתאימים כמעט בדיוק לאובייקטים של JSON. המרה ביניהם היא קריאה אחת:

import json

data = {"name": "Rosa", "age": 30, "tags": ["python", "docs"]}

as_json = json.dumps(data)
print(as_json)

back = json.loads(as_json)
print(back)

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

דוגמה מעשית

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

user = {
    "name": "Rosa",
    "email": "rosa@example.com",
    "preferences": {
        "theme": "dark",
        "notifications": True,
    },
    "tags": ["python", "docs"],
}

print(user["name"])
print(user["preferences"]["theme"])
print(user.get("last_login", "never"))

user["tags"].append("seo")
user["preferences"]["theme"] = "light"

print(user)

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

ממשיכים הלאה

רשימות, tuples, קבוצות ומילונים. עם ארבעת האוספים האלה ביד, אפשר למדל כמעט כל נתון שתפגשו בשלבים הראשונים. בהמשך נלמד על list comprehension: הדרך התמציתית של Python להפוך אוסף אחד לאחר.