ב-Python, מילון הוא קבוצה לא מסודרת של ערכי נתונים שיכול להיות משמש לאחסון ערכי נתונים בדומה למפה. בניגוד לסוגי נתונים אחרים, שיכולים לכלול רק ערך בודד לכל אלמנט, מילונים יכולים להכיל גם a ערך מפתח זוג. להכין את המילון יותר יעיל , ערך מפתח מוצע.
כשזה נוגע לייחס גישה, הנקודה '.' (כמו ב x.any_attribute ) הוא כל מה שרוב המשתמשים מכירים. פשוט אמר, גישה לתכונה היא תהליך השגת אובייקט שמחובר לאובייקט שכבר יש לך . זה עשוי להיראות פשוט מאוד למישהו שמשתמש ב-Python מבלי להיכנס יותר מדי לפרטים הספציפיים. עם זאת, יש הרבה מה שקורה מאחורי הקלעים לתהליך פשוט יחסית זה.
מה זה _dict_?
לכל מודול יש מאפיין ייחודי הנקרא __dict__. המילון הזה מכיל את טבלת הסמלים עבור המודול . המאפיינים (ניתנים לכתיבה) של פריט מאוחסנים במילון או באובייקט המיפוי האחר.
במילים פשוטות, לכל אובייקט ב-Python יש א מאפיין המסומן על ידי הסמל __dict__ . יתר על כן, לאובייקט זה יש כל מאפיין שצוין עבורו. שם אחר ל-__dict__ הוא מיפוי פרוקסי לְהִתְנַגֵד. אנו יכולים להשתמש במילון באמצעות החלת המאפיין __dict__ לאובייקט מחלקה.
טופס מלא pvr
תחביר :
object.__dict__
דוגמא :
class AnimalClass: def __init__(self,identity,age): self.identity = identity self.age = age def feature(self): if self.age == '10': return True else: return False ac = AnimalClass('Lion','10') print(ac.__dict__)
תְפוּקָה:
{'identity': 'Lion', 'age': '10'} דוגמה 2:
דוגמה זו תוכיח שבאמצעות ה תכונה __dict__ , אפשר ליצור מילון מכל אובייקט :
# class Flowers is defined class Flowers: # constructor def __init__(self): # keys are being initialized with # their corresponding values self.Rose = 'red' self.Lily = 'white' self.Lotus = 'pink' def displayit(self): print('The Dictionary from object fields belongs to the class Flowers :') # object animal of class Animals flower = Flowers() # calling displayit function flower.displayit() # calling the attribute __dict__ on flower # object and making it print it print(flower.__dict__)
תְפוּקָה:
The Dictionary from object fields belongs to the class Flowers : {'Rose': 'red', 'Lily': 'white', 'Lotus': 'pink'} דוגמה 3:
def funct(): pass funct.practice = 1 print(funct.__dict__) class PracticeClass: x = 1 def practice_function(self): pass print(PracticeClass.__dict__)
תְפוּקָה:
{'practice': 1} {'__module__': '__main__', 'x': 1, 'practice_function': , '__dict__': , '__weakref__': , '__doc__': None} שימוש במילון ללא שימוש ב-__dict__ ב-Python:
יצירת מילון:
ב-Python, ניתן ליצור מילון על ידי צירוף א רשימת ערכים בתוך סוגריים מסולסלים והפרדה ביניהם באמצעות פסיק . המילון מאחסן זוגות ערכים, כאשר אלמנט זוג אחד הוא המפתח ואחד אחר הוא שלו ערך מפתח . בניגוד ל מפתחות, איזה לא ניתן לחזור עליהם וחייבים להיות בלתי ניתנים לשינוי, ערכים במילונים יכול להיות מכל סוג של נתונים וניתן לשכפל אותם .
האלמנטים הם מופרד בפסיקים , כל מפתח מובחן מהערך שלו על ידי נקודתיים (:), והמבנה כולו כלול ב סוגריים מתולתלים . מילון חסר כל מילים נכתב כך: {} .
המפתחות של המילון חייבים להיות בלתי ניתן לשינוי , כמו מספרים שלמים, tuples או מחרוזות , למרות שהערכים יכולים להיות מכל סוג. במילוני Python, אותו שם מפתח מאוית אחרת נחשב מפתח מובהק. אנא שימו לב לכך מפתחות המילון הם תלויי רישיות ; מפתחות בעלי שם דומה אך רישיות נפרדות יטופלו אחרת.
דוגמא :
# Creating a Dictionary # using Integer Keys only Dict = {1: 'JAVA', 2: 'T', 3: 'POINT'} print('
Creating a Dictionary by using Integer Keys : ') print(Dict) # Creating a Dictionary # using various Mixed keys Dict = {'Company': 'JavaTpoint', 7: [22, 35, 46, 97]} print('
Creating a Dictionary by using Mixed Keys : ') print(Dict) תְפוּקָה:
Creating a Dictionary by using Integer Keys : {1: 'JAVA', 2: 'T', 3: 'POINT'} Creating a Dictionary by using Mixed Keys : {'Company': 'JavaTpoint', 7: [22, 35, 46, 97]} ה שיטה מובנית dict() מאפשר גם את יצירת מילונים . פשוט לשים שני פלטה מתולתלת {} יחד יביאו ל- מילון ריק .
דוגמא :
# Creating an empty Dictionary myDict = {} print('This is an Empty Dictionary: ') print(myDict) # Creating a Dictionary # using the dict() method myDict = dict({1: 'JAVA', 2: 'T', 3: 'POINT'}) print('
Creating a Dictionary by using the dict() method : ') print(myDict) # Creating a Dictionary # using each item as a different Pair myDict = dict([(1, 'JavaTpoint'), (2, 'Great')]) print('
Creating a Dictionary by using each item as a different pair : ') print(myDict) תְפוּקָה:
This is an Empty Dictionary: {} Creating a Dictionary by using the dict() method : {1: 'JAVA', 2: 'T', 3: 'POINT'} Creating a Dictionary by using each item as a different pair : {1: 'JavaTpoint', 2: 'Great'} מורכבויות ליצירת מילון:
- מורכבות הזמן: O(length(dict))
- מורכבות החלל: עַל)
מילונים מקוננים:
זהו סוג של מילון שבו אחד או יותר מאחד למפתחות מצורף מילון כערך של המפתח.
דוגמא :
# Creating a Nested Dictionary # as mentioned above using a dictionary as a value to a key in # a dictionary myDict = dict({1: 'JAVA', 2: 'T', 3: 'POINT', 4: {1: 'JavaTpoint', 2: 'Great'}}) print('
Creating a Nested Dictionary : ') print(myDict) תְפוּקָה:
Creating a Nested Dictionary : {1: 'JAVA', 2: 'T', 3: 'POINT', 4: {1: 'JavaTpoint', 2: 'Great'}} הוספת אלמנטים למילון:
יש מספר שיטות להוספת אלמנטים למילון פייתון. על ידי ציון הערך והמפתח ביחד, למשל, Dict[Key] = 'ערך', ניתן להוסיף ערך אחד למילון בכל פעם. משתמש ב פונקציית update() מובנית , אפשר לשנות ערך קיים במילון. ניתן להרחיב גם מילון קיים ערכי מפתח מקוננים .
הערה: בעת הוספת ערך, הערך מתעדכן אם שילוב המפתח-ערך כבר קיים. אם לא, מפתח וערך חדשים נוספים למילון.
דוגמא :
# Creating Empty Dictionary myDict = {} print('Empty Dictionary: ') print(myDict) # Adding elements only one at a time myDict[0] = 'Java' myDict[3] = 'T' myDict[6] = 41 print('
Dictionary after the addition of 3 elements: ') print(myDict) # Adding a set of values # to a particular Key myDict['settingValues'] = 7, 8, 9 print('
Dictionary after the adding a set of values to a key : ') print(myDict) # Updating the existing Key's Value myDict[3] = 'tPoint' print('
Dictionary after Updated key value: ') print(myDict) # Adding Nested Key value to Dictionary myDict[8] = {'Nested' :{'A' : 'boy', 'B' : 'Girl'}} print('
Dictionary after Addition of a Nested Key: ') print(myDict) תְפוּקָה:
Empty Dictionary: {} Dictionary after the addition of 3 elements: {0: 'Java', 3: 'T', 6: 41} Dictionary after the adding a set of values to a key : {0: 'Java', 3: 'T', 6: 41, 'settingValues': (7, 8, 9)} Dictionary after Updated key value: {0: 'Java', 3: 'tPoint', 6: 41, 'settingValues': (7, 8, 9)} Dictionary after Addition of a Nested Key: {0: 'Java', 3: 'tPoint', 6: 41, 'settingValues': (7, 8, 9), 8: {'Nested': {'A': 'boy', 'B': 'Girl'}}} מורכבויות להוספת אלמנטים למילון:
- מורכבות זמן: O(1)/O(n)
- מורכבות החלל: O(1)
גישה לרכיבי מילון:
מילון מעסיק מפתחות , בעוד שסוגי נתונים אחרים דורשים אינדקס כדי לאחזר ערכים. ניתן להשתמש במפתחות עם get() פונקציה אוֹ בתוך סוגריים מרובעים [].
המוקרים המוקדמים
במקרה שא לא ניתן למצוא מפתח במילון, נוצרת KeyError אם נשתמש סוגריים מרובעים []. מצד שני, אם לא ניתן לאתר את המפתח, ה הפונקציה get() מחזירה None.
דוגמא :
# Python program to demonstrate the # accessing of an element, from a Dictionary # Creating a Dictionary myDict = {1: 'Java', 'name': 'T', 2: 'Point', 4: 'Website'} # accessing an element using key print('Accessing an element using the key:') print(myDict['name']) print('Accessing another element using the key:') print(myDict[4]) # accessing an element using the get() method print('Accessing an using the get() method:') print(myDict.get(2)) print('Accessing another using the get() method:') print(myDict.get(1)) תְפוּקָה:
Accessing an element using the key: T Accessing another element using the key: Website Accessing an using the get() method: Point Accessing another using the get() method: Java
מורכבויות לגישה לאלמנטים במילון:
- מורכבות זמן: O(1)
- מורכבות החלל: O(1)
גישה לאלמנט של מילון מקונן:
אנחנו יכולים להיעזר ב- טכניקת אינדקס [] כדי לקבל את הערך של מפתח קיים ב- מילון מקונן .
דוגמא :
# Creating a Dictionary myDict = {'myDict1': {3: 'JavatPoint'}, 'myDict2': {'Info.': 'Website'}} # Accessing the elements using the key print(myDict['myDict1']) print(myDict['myDict1'][3]) print(myDict['myDict2']['Info.']) תְפוּקָה:
{3: 'JavatPoint'} JavatPoint Website שיטות מילון מובנות:
ברור() :
הפונקציה dict.clear() מבטל כל זוג מפתח-ערך מתוך המילון.
עותק() :
א עותק רדוד יותר של המילון מוחזר על ידי שיטת dict.copy() .
fromkeys() :
שימוש ב-Iterable שסופק (מחרוזת, רשימה, קבוצה או tuple) כמקשים והערך שצוין, הפונקציה dict.fromkeys() יוצר מילון חדש .
לקבל() :
זֶה נותן את הערך המשויך עם המפתח הנתון.
פריטים() :
א אובייקט תצוגת מילון , המציע הצגה דינמית של פריטי המילון כרשימה של צמדי מפתח-ערך מוחזר על ידי הפונקציה dict.items(). כאשר המילון מתעדכן, זה אובייקט התצוגה מתעדכן גם הוא .
אקראי לא ב-java
dict.keys() :
הפונקציה dict.keys() מחזירה אובייקט תצוגת מילון עם של המילון רשימת מפתחות.
pop() :
זֶה מחזירה את ערך המפתח לאחר הסרתו . אם חסר מפתח במילון, הוא זורק א שגיאת מפתח או מחזיר את ערך ברירת מחדל אם היה מסופק אחד.
משקה() :
זֶה מסיר פריט אחד מהמילון ומחזיר טופל של זוגות (מפתח, ערך). ה Last In First Out (LIFO) רצף משמש להחזרת זוגות.
הגדר ברירת מחדל() :
זֶה מחזירה את ערך המילון עבור המפתח הנתון . אם לא ניתן לגלות את המפתח, המפתח עם המצורף ערך ברירת מחדל נוסף. זה קובע אף אחד בתור ה ערך ברירת מחדל אם זה לא מסופק.
ערכים() :
ה אובייקט תצוגת מילון המציע תצוגה דינמית של כל ערך שהוא קיים במילון, מוחזר על ידי הפונקציה dict.values(). כאשר המילון מתעדכן, זה אובייקט התצוגה מתעדכן גם הוא .
עדכון() :
א מילון או כל איטרציה עם צמדי מפתח-ערך , כמו טופל, ניתן לעדכן באמצעות הפונקציה dict.update() .
דוגמא :
# Example to demonstrate all dictionary methods #Creating a Dictionary mydict1={1:'HTML',2:'CSS',3:'Javascript',4:'Python'} #copy method mydict2=mydict1.copy() print(mydict2) #clear method mydict1.clear() print(mydict1) #get method print(mydict2.get(1)) #items method print(mydict2.items()) #keys method print(mydict2.keys()) #pop method mydict2.pop(4) print(mydict2) #popitem method mydict2.popitem() print(mydict2) #update method mydict2.update({2:'C++'}) print(mydict2) #values method print(mydict2.values()) תְפוּקָה:
{1: 'HTML', 2: 'CSS', 3: 'Javascript', 4: 'Python'} {} HTML dict_items([(1, 'HTML'), (2, 'CSS'), (3, 'Javascript'), (4, 'Python')]) dict_keys([1, 2, 3, 4]) {1: 'HTML', 2: 'CSS', 3: 'Javascript'} {1: 'HTML', 2: 'CSS'} {1: 'HTML', 2: 'C++'} dict_values(['HTML', 'C++']) הבדל בין מילון לרשימה:
מבני נתונים כגון א רשימה ומילון שונות מהותית. א הזמנת סדרת פריטים ניתן לאחסן ב רשימה כדי שנוכל להיכנס אליו או לחזור עליו. ניתן לשנות רשימות גם לאחר שהן כבר נוצרו מכיוון שהן סוג שניתן לשינוי. ה מילון פייתון הוא אחסון ערך מפתח ויישום של א טבלת גיבוב . זה לא עוקב אחר רצף מסוים ודורש מפתחות ניתנים לגיבוש. בנוסף, הוא מהיר עבור חיפושי מפתח.
א של רשימה אלמנטים מכילים את התכונות הבאות:
- אלא אם כן הוזמנו מחדש באופן ספציפי, הם לשמור על הסדר הנוכחי שלהם (לדוגמה, על ידי מיון הרשימה).
- הם עשויים להיות מכל סוג שהוא, או אפילו א שילוב של סוגים .
המאפיינים של מילון האלמנטים הם כדלקמן:
- לכל ערך יש א ערך ומפתח .
- הזמנות הן לא מוצדק .
שימוש:
אנו משתמשים ב- a מילון אם יש לנו א קבוצה של מפתחות נפרדים התואמים לערכים , אבל א רשימה כשיש לנו הורה קבוצת דברים .
סיכום :
- בשפת מחשב, מילונים הם מעין מבנה נתונים המשמש להחזקת מידע זה קשור איכשהו.
- לכל מודול יש מאפיין ייחודי הנקרא __dict__.
- __dict__ מכיל את טבלת הסמלים עבור המודול .
- המאפיינים של אלמנט מאוחסנים ב-a אובייקט מיפוי.
- לכל אובייקט ב-Python יש א מאפיין המסומן על ידי הסמל __dict__ .
- שם אחר ל-__dict__ ידוע גם בשם אובייקט מיפוי פרוקסי.
- שני המרכיבים של מילון Python נקראים מפתחות וערכים .
- אתה עלול לא לקבל הנתונים שלך בחזרה בסדר הדומה שהזנת אותם מכיוון שמילונים אינם שומרים את הנתונים שלהם בסדר מסוים.
- מפתחות יהיו מורכבים רק דבר אחד.
- ערכים יכולים להיות מספרים שלמים, רשימות, רשימות בתוך רשימות , וכו.
- לא יכול להיות יותר מ כניסה אחת לכל מפתח (אין אפשרות לשכפל מפתח)
- המפתחות של המילון חייבים להיות בלתי ניתן לשינוי , כמו מספרים שלמים, tuples או מחרוזות , למרות שהערכים יכולים להיות מכל סוג.
- מילון המפתחות הם תלויי רישיות ; במילוני Python, אותו שם מפתח מאויית אחרת נחשב כ-a מפתח מובהק .