הבנת מילונים ב־Python 3

הקדמה

המילון הוא סוג הנתונים ממופה המובנה ב־Python. מילונים ממפים מפתחות לערכים וזוגות המפתח-ערך הללו מספקים דרך שימושית לאחסון נתונים ב־Python.

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

A dictionary looks like this:

sammy = {'username': 'sammy-shark', 'online': True, 'followers': 987}

בנוסף לסוגריים מסולם, ישנם גם נקודות שבירה (:) ברחבי המילון.

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

• 'username'
• 'online'
• 'followers'

כל אחד מהמפתחות בדוגמה לעיל הם ערכי מחרוזת.

המילים לימין מהנקודות השבירה הן הערכים. הערכים יכולים להיות מורכבים מכל סוג נתונים. הערכים במילון לעיל הם:

• 'סמי-שרק'
• נכון
• 987

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

בואו נדפיס את המילון sammy:

print(sammy)

Output
{'username': 'sammy-shark', 'followers': 987, 'online': True}

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

דרישות מוקדמות

עליך להיות מותקנת פייתון 3 ולהגדיר סביבת פיתוח על המחשב או השרת שלך. אם אין לך סביבת פיתוח, תוכל להפנות למדריכי ההתקנה וההגדרה עבור סביבת פיתוח מקומית או ל סביבת פיתוח על השרת שלך המתאימה למערכת ההפעלה שלך (אובונטו, CentOS, Debian וכו').

גישה לאלמנטים במילון

ניתן לקרוא לערכים של מילון על ידי הפניה למפתחות הקשורים.

גישה לפריטי נתונים עם מפתחות

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

אם נרצה לבדוק את שם המשתמש של סמי, נוכל לעשות זאת על ידי קריאה sammy['username']. בואו נדפיס את זה:

print(sammy['username'])

Output
sammy-shark

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

על ידי קריאה למפתח 'username' אנו מקבלים את הערך של המפתח הזה, שהוא 'sammy-shark'.

הערכים הנותרים במילון sammy יכולים להיקרא באותו הפורמט:

sammy['followers']
# מחזיר 987

sammy['online']
# מחזיר True

על ידי השימוש בזוגות מפתח-ערך של המילון, ניתן להפנות למפתחים כדי לאחזר ערכים.

שימוש בשיטות לגישה לאלמנטים

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

• dict.keys() מבדיל מפתחות
• dict.values() מבדיל ערכים
• dict.items() מחזיר פריטים בפורמט של רשימת זוגות טאפל (key, value)

כדי להחזיר את המפתחות, נשתמש בשיטת dict.keys(). בדוגמה שלנו, נשתמש בשם המשתנה ונשתמש ב- sammy.keys(). בואו נעביר זאת לשיטת print() ונסתכל על הפלט:

print(sammy.keys())

Output
dict_keys(['followers', 'username', 'online'])

אנו מקבלים פלט שמניח את המפתחות בתוך אובייקט תצוגה של ה- dict_keys class. המפתחות מודפסים כאשר בתוך פורמט של רשימה.

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

sammy = {'username': 'sammy-shark', 'online': True, 'followers': 987}
jesse = {'username': 'JOctopus', 'online': False, 'points': 723}

for common_key in sammy.keys() & jesse.keys():
    print(sammy[common_key], jesse[common_key])

המילון sammy והמילון jesse הם כל אחד מילון פרופיל משתמש.

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

Output
sammy-shark JOctopus
True False

אנו בוודאות יכולים לשפר את התוכנית כך שהפלט יהיה יותר קריא למשתמש, אך זה ממחיש ש־dict.keys() ניתן להשתמש בו כדי לבדוק את ההתאמות בין מספר מפותחים לראות מה משותף ביניהם או מה לא. זה מאוד שימושי במיוחד עבור מפותחים גדולים.

באופן דומה, אנו יכולים להשתמש בשיטת dict.values() כדי לשאול את הערכים במילון sammy, שתיבנה כ־sammy.values(). בואו נדפיס אותם:

sammy = {'username': 'sammy-shark', 'online': True, 'followers': 987}

print(sammy.values())

Output
dict_values([True, 'sammy-shark', 987])

שתי השיטות keys() ו־values() מחזירות רשימות לא ממוינות של המפתחות והערכים הנמצאים במילון sammy עם עצמות התצוגה dict_keys ו־dict_values בהתאמה.

אם אנו מעוניינים בכל הפריטים במילון, ניתן לגשת אליהם באמצעות שיטת items():

print(sammy.items())

Output
dict_items([('online', True), ('username', 'sammy-shark'), ('followers', 987)])

התבנית שמוחזרת מכך היא רשימה המורכבת מזוגות טאפלים (key, value) עם עצם התצוגה dict_items.

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

for key, value in sammy.items():
    print(key, 'is the key for the value', value)

Output
online is the key for the value True
followers is the key for the value 987
username is the key for the value sammy-shark

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

ניתן להשתמש בשיטות מובנות כדי לגשת לפריטים, לערכים, ולמפתחות ממבני נתונים של מילון.

שינוי מילונים

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

הוספת ושינוי של אלמנטים במילון

בלי להשתמש בשיטה או פונקציה, ניתן להוסיף זוגות מפתח-ערך למילונים באמצעות התחביר הבא:

dict[key] = value

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

usernames = {'Sammy': 'sammy-shark', 'Jamie': 'mantisshrimp54'}

usernames['Drew'] = 'squidly'

print(usernames)

Output
{'Drew': 'squidly', 'Sammy': 'sammy-shark', 'Jamie': 'mantisshrimp54'}

אנו רואים כעת כי המילון עודכן עם זוג המפתח-ערך 'Drew': 'squidly'. בגלל שמילונים עשויים להיות לא מסודרים, זוג זה עשוי להופיע בכל מקום בפלט המילון. אם נשתמש במילון usernames מאוחר יותר בקובץ התוכנית שלנו, הוא יכיל את זוג המפתח-ערך הנוסף.

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

בואו נשקול מילון drew שהוא אחד המשתמשים ברשת נתונים נתונים. נגיד שהמשתמש הזה קיבל קידום במספר העוקבים היום, לכן אנו צריכים לעדכן את הערך השלם המועבר למפתח 'followers'. נשתמש בפונקצית print() כדי לוודא שהמילון עודכן.

drew = {'username': 'squidly', 'online': True, 'followers': 305}

drew['followers'] = 342

print(drew)

Output
{'username': 'squidly', 'followers': 342, 'online': True}

בפלט, אנו רואים שמספר העוקבים קפץ מהערך השלם של 305 ל־342.

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

# הגדרת מילון מקורי
usernames = {'Sammy': 'sammy-shark', 'Jamie': 'mantisshrimp54'}

# הגדרת לולאת while עבור חזרות
while True:

    # בקש מהמשתמש להזין שם
    print('Enter a name:')

    # הקצאה למשתנה שם
    name = input()

    # בדיקה אם השם קיים במילון והדפסת משוב
    if name in usernames:
        print(usernames[name] + ' is the username of ' + name)

    # אם השם לא נמצא במילון...
    else:

        # מתן משוב
        print('I don\'t have ' + name + '\'s username, what is it?')

        # קליטת שם משתמש חדש לשם המשוייך
        username = input()

        # הקצאת ערך שם משתמש למפתח שם
        usernames[name] = username

        # הדפסת משוב כי הנתונים עודכנו
        print('Data updated.')

בואו נריץ את התוכנית בפקודה הקו:

python usernames.py

כאשר אנו מפעילים את התוכנית נקבל משהו דומה לפלט הבא:

Output
Enter a name:
Sammy
sammy-shark is the username of Sammy
Enter a name:
Jesse
I don't have Jesse's username, what is it?
JOctopus
Data updated.
Enter a name:

כאשר אנו מסיימים לבדוק את התוכנית, נוכל ללחוץ CTRL + C כדי לצאת מהתוכנית. ניתן להגדיר טריגר כדי לסיים את התוכנית (כמו להקליד את האות q) עם הצהרת תנאי לשפר את הקוד.

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

ניתן גם להוסיף ולשנות מילונים באמצעות השימוש בשיטת dict.update(). זה שונה מה append() שיטה הזמינה ברשימות.

במילון jesse למטה, נוסיף את המפתח 'followers' וניתן לו ערך של מספר שלם עם jesse.update(). לאחר מכן, נשתמש ב- print() כדי להדפיס את המילון המעודכן.

jesse = {'username': 'JOctopus', 'online': False, 'points': 723}

jesse.update({'followers': 481})

print(jesse)

Output
{'followers': 481, 'username': 'JOctopus', 'points': 723, 'online': False}

מהפלט, אנו רואים שהוספנו בהצלחה את הזוג המפתח-ערך 'followers': 481 למילון jesse.

ניתן גם להשתמש בשיטת dict.update() כדי לשנות זוג מפתח-ערך קיים על ידי החלפת ערך נתון עבור מפתח מסוים.

בואו נשנה את מצב המקוון של סמי מ-True ל-False במילון sammy:

sammy = {'username': 'sammy-shark', 'online': True, 'followers': 987}

sammy.update({'online': False})

print(sammy)

Output
{'username': 'sammy-shark', 'followers': 987, 'online': False}

השורה sammy.update({'online': False}) מתייחסת למפתח הקיים 'online' ומשנה את ערכו הבוליאני מ-True ל-False. כאשר אנו קוראים ל-print() את המילון, אנו רואים את העדכון קורה בפלט.

כדי להוסיף פריטים למילונים או לשנות ערכים, נוכל להשתמש בתחביר dict[key] = value או בשיטה dict.update().

מחיקת איברים ממילונים

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

כדי להסיר זוג מפתח-ערך ממילון, נשתמש בתחביר הבא:

del dict[key]

בואו נקח את המילון jesse שמייצג את אחד מהמשתמשים. נגיד שג'סי כבר לא משתמש בפלטפורמה המקוונת למשחקים, אז נסיר את הפריט המשוייך למפתח 'points'. לאחר מכן, נדפיס את המילון כדי לאמת שהפריט נמחק:

jesse = {'username': 'JOctopus', 'online': False, 'points': 723, 'followers': 481}

del jesse['points']

print(jesse)

Output
{'online': False, 'username': 'JOctopus', 'followers': 481}

השורה del jesse['points'] מסירה את זוג המפתח-ערך 'points': 723 מהמילון jesse.

אם נרצה לנקות מילון מכל הערכים שלו, נוכל לעשות זאת עם השיטה dict.clear(). זה ישמור על מילון נתון במקרה שנרצה להשתמש בו מאוחר יותר בתוכנית, אך הוא כבר לא יכיל פריטים.

בואו נסיר את כל הפריטים בתוך המילון jesse:

jesse = {'username': 'JOctopus', 'online': False, 'points': 723, 'followers': 481}

jesse.clear()

print(jesse)

Output
{}

הפלט מראה שכעת יש לנו מילון ריק שחסר זוגות מפתח-ערך.

אם אין לנו יותר צורך במילון ספציפי, נוכל להשתמש ב־del כדי להיפטר ממנו לגמרי:

del jesse

print(jesse)

כאשר אנו מפעילים שיחה ל־print() אחרי מחיקת המילון jesse, נקבל את השגיאה הבאה:

Output
...
NameError: name 'jesse' is not defined

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

מסקנה

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

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

ניתן לראות את סוג הנתונים מסוג מילון בפרוייקטים תכנותיים כמו גייסוף נתונים מאתרי האינטרנט עם Scrapy.