הכתבה

המונח הוא סוג מובנה שמייצג מיפוי אסוציאטיבי או מילון. מילון תומך בהוספה לאינדקס באמצעות d[k] ובבדיקות לחברים עיקריים באמצעות k in d; הפעולות מבצעות זמן קבוע. ניתן לשנות את המילונים שלא הוקפאו, וניתן לעדכן אותם על ידי הקצאה ל-d[k] או על ידי קריאה לשיטות מסוימות. מילונים רלוונטיים. חזרה מחזירה את רצף המקשים לפי סדר ההכנסה. סדר החזרות לא מושפע מעדכון הערך המשויך למפתח קיים, אבל הוא מושפע מהסרה של מפתח והכנסתו מחדש.

d = {0: 0, 2: 2, 1: 1}
[k for k in d]  # [0, 2, 1]
d.pop(2)
d[0], d[2] = "a", "b"
0 in d, "a" in d  # (True, False)
[(k, v) for k, v in d.items()]  # [(0, "a"), (1, 1), (2, "b")]

יש ארבע דרכים לבנות מילון:

1. ביטוי מילון {k: v, ...} נותן מילון חדש עם ערכי המפתח/ערך שצוינו, שנוספו לפי סדר הופעתם בביטוי. ההערכה נכשלת אם שני ביטויים עיקריים מניבים את אותו ערך.
2. הבנת מילון {k: v for vars in seq} מחזירה מילון חדש שבו כל צמד של מפתח/ערך מוכנס בסדר חזרה של לולאה. מותר להשתמש בכפילויות: ההוספה הראשונה של מפתח נתון קובעת את מיקום הרצף, והאחרון קובע את הערך המשויך לו.

   {k: v for k, v in (("a", 0), ("b", 1), ("a", 2))}  # {"a": 2, "b": 1}
   {i: 2*i for i in range(3)}  # {0: 0, 1: 2, 2: 4}
   

3. קריאה לפונקציה המובנית function מחזירה מילון שמכיל את הערכים שצוינו. את הארגומנטים מזינים לפי סדר ארגומנטים, ואחר כך מזינים ארגומנטים לפני המיקום שלהם. כמו במקרה של הבנה, מותר להשתמש במפתחות כפולים.
4. ביטוי האיחוד x | y יוצר מילון חדש על ידי שילוב שני מילונים קיימים. אם לשני המילונים יש מפתח משותף ב-k, הערך של המילון בצד שמאל של המפתח (במילים אחרות, y[k]) זוכה. גרסת |= של אופרטור האיחוד משנה את מילון במקום. דוגמה:
   

   d = {"foo": "FOO", "bar": "BAR"} | {"foo": "FOO2", "baz": "BAZ"}
   # d == {"foo": "FOO2", "bar": "BAR", "baz": "BAZ"}
   d = {"a": 1, "b": 2}
   d |= {"b": 3, "c": 4}
   # d == {"a": 1, "b": 3, "c": 4}

חברי מועדון

• ניקוי
• הורדה
• פריטים
• מפתחות
• פופ
• פריט פריט
• setdefault
• עדכון
• ערכים

נקה

None dict.clear()

מסירים את כל הפריטים מהמילון.

הורדה

unknown dict.get(key, default=None)

מחזירה את הערך של key אם key נמצא במילון, אחרת default. אם default אינו מצוין, ברירת המחדל היא None, כך שהשיטה הזו אף פעם לא גורמת לשגיאה.

פרמטרים

הפרמטר	תיאור
key	נדרש המפתח שיש לחפש.
default	ברירת מחדל = ללא ערך ברירת המחדל שבו יש להשתמש (במקום 'ללא') אם המפתח לא נמצא.

items

list dict.items()

פונקציה זו מחזירה את רשימת התווספות של מפתח-ערך:

{2: "a", 4: "b", 1: "c"}.items() == [(2, "a"), (4, "b"), (1, "c")]

מפתחות

list dict.keys()

מחזירה את רשימת המפתחות:

{2: "a", 4: "b", 1: "c"}.keys() == [2, 4, 1]

פופ

unknown dict.pop(key, default=unbound)

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

פרמטרים

הפרמטר	תיאור
key	חובה המפתח.
default	ברירת מחדל = unbound ערך ברירת מחדל אם המפתח חסר.

פריט קופץ

tuple dict.popitem()

יש להסיר ולהחזיר את זוג (key, value) הראשון מהמילון. popitem שימושי כדי לחזור על מילון באופן הרסני, ולרוב נעשה בו שימוש באלגוריתמים מוגדרים. אם המילון ריק, הקריאה של popitem תיכשל.

setdefault

unknown dict.setdefault(key, default=None)

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

פרמטרים

הפרמטר	תיאור
key	חובה המפתח.
default	ברירת מחדל = ללא ערך ברירת מחדל אם המפתח חסר.

עדכון

None dict.update(pairs=[], **kwargs)

מעדכן את המילון תחילה עם הארגומנט האופציונלי של המיקום, pairs, ולאחר מכן עם הארגומנטים האופציונליים של מילות המפתח אם הארגומנט הממוקם קיים, הוא חייב להיות ארגומנט, חוזר, או ללא. אם מדובר בהקלדה, זוגות המפתח/הערך שלה מוכנסים למשפט זה. אם הוא שווה-ערך, עליו לספק רצף של זוגות (או הגדרות אחרות באורך 2). כל זוג כזה נחשב לצמד של מפתח/ערך שיש להכניס. כל ארגומנט של מילת מפתח name=value גורם להצמדה של שם/ערך למשפט זה.

פרמטרים

הפרמטר	תיאור
pairs	ברירת מחדל = [] מילון או רשימת ערכים. הערכים חייבים להיות מאסטרים או רשימות עם שני רכיבים בדיוק: מפתח, ערך.
kwargs	חובה מילון של ערכים נוספים.

ערכים

list dict.values()

מחזירה את רשימת הערכים:

{2: "a", 4: "b", 1: "c"}.values() == ["a", "b", "c"]