पायथनमध्ये शब्दकोश कसा तयार करायचा. इंटरएक्टिव्ह पायथन ट्यूटोरियल

Python प्रोग्रामिंग भाषेत, शब्दकोष (टाइप डिक्ट) हा याद्या आणि ट्यूपल्ससह डेटा स्ट्रक्चरचा आणखी एक प्रकार आहे. शब्दकोश आहे बदलण्यायोग्य(यादीप्रमाणे) अव्यवस्थित(स्ट्रिंग, लिस्ट आणि ट्यूपल्सच्या विरूद्ध) की:मूल्य घटकांचा संच.

"अनऑर्डर्ड" म्हणजे जोड्यांचा क्रम महत्त्वाचा नाही. प्रोग्रामिंग भाषा ते विचारात घेत नाही, परिणामी निर्देशांकांद्वारे घटकांमध्ये प्रवेश करणे अशक्य आहे.

इतर भाषांमध्ये, शब्दकोषांसारख्या रचनांना वेगळ्या पद्धतीने म्हणतात. उदाहरणार्थ, Java मध्ये, या प्रकारच्या डेटाला मॅपिंग म्हणतात.

शब्दकोशाची कल्पना अधिक स्पष्ट करण्यासाठी, नियमित शब्दकोशासह एक समानता काढूया, उदाहरणार्थ, इंग्रजी-रशियन. अशा शब्दकोशातील प्रत्येक इंग्रजी शब्दासाठी रशियन भाषांतर शब्द आहे: मांजर - मांजर, कुत्रा - कुत्रा, टेबल - टेबल, इ. जर पायथन वापरून इंग्रजी-रशियन शब्दकोश वर्णन केले असेल, तर इंग्रजी शब्द की बनवू शकतात आणि रशियन शब्द त्यांच्या अर्थांमध्ये:

("मांजर": "मांजर", "कुत्रा": "कुत्रा", "पक्षी": "पक्षी", "माऊस": "माऊस")

कुरळे ब्रेसेसकडे लक्ष द्या ते शब्दकोष परिभाषित करण्यासाठी वापरले जातात. पायथनमधील शब्दकोशाचे वाक्यरचना खालील योजनेद्वारे वर्णन केले आहे:

अनेकदा डिक्शनरी आउटपुट असताना, की:मूल्य जोड्यांचा क्रम प्रविष्ट केलेल्या गोष्टीशी जुळत नाही:

>>> a = ( "मांजर" : "मांजर", "कुत्रा" : "कुत्रा", "पक्षी" : "पक्षी", "माऊस" : "माऊस") >>> अ("कुत्रा": "कुत्रा", "मांजर": "मांजर", "पक्षी": "पक्षी", "माऊस": "माऊस")

शब्दकोशातील जोड्यांचा क्रम महत्त्वाचा नसल्यामुळे, दुभाषी त्यांना सोयीस्कर पद्धतीने दाखवतो. मग तत्त्वानुसार अनुक्रमणिका शक्य नसल्यास विशिष्ट घटकात प्रवेश कसा करायचा? शब्दकोशात, मूल्ये की द्वारे ऍक्सेस केली जातात, जी चौकोनी कंसात बंद केलेली असतात (सूची निर्देशांकांप्रमाणे):

>>> एक[ "मांजर" ]"मांजर" >>> एक[ "पक्षी" ]"पक्षी"

शब्दकोष, जसे की सूची, एक बदलता येणारा डेटा प्रकार आहे: तुम्ही घटक बदलू, जोडू आणि काढू शकता (की:मूल्य जोड्या). सुरुवातीला, शब्दकोश रिक्त तयार केला जाऊ शकतो (उदाहरणार्थ, d = ()) आणि नंतर घटकांनी भरला जाऊ शकतो. जोडणे आणि बदलणे हे समान वाक्यरचना आहे: शब्दकोश[की] = मूल्य. की एकतर आधीपासून अस्तित्वात असू शकते (नंतर मूल्य बदलते) किंवा नवीन (शब्दकोश घटक जोडला जातो). पायथनच्या अंगभूत डेल ऑपरेटरचा वापर करून घटक काढून टाकणे केले जाते.

>>> a[ "elephant" ] = "hippopotamus" # जोडा >>> a[ "टेबल" ] = "टेबल" # जोडा >>> अ("कुत्रा": "कुत्रा", "मांजर": "मांजर", "माऊस": "उंदीर", "पक्षी": "पक्षी", "टेबल": "टेबल", "हत्ती": "पाणघोडे") >>> a[ "elephant" ] = "हत्ती" # बदलण्यायोग्य >>> del a[ "टेबल" ] # हटवा >>> अ("कुत्रा": "कुत्रा", "मांजर": "मांजर", "माऊस": "उंदीर", "पक्षी": "पक्षी", "हत्ती": "हत्ती")

डिक्शनरीमध्ये एकाच की असलेले दोन घटक असू शकत नाहीत. तथापि, भिन्न की समान मूल्ये असू शकतात.

की कोणताही अपरिवर्तनीय डेटा प्रकार असू शकतो. मूल्य - कोणताही डेटा प्रकार. शब्दकोश मूल्ये रचना असू शकतात, जसे की इतर शब्दकोश किंवा सूची.

>>> संख्या = ( 1 : "एक", 2 : "दोन", 3 : "तीन") >>> व्यक्ती = ( "नाव" : "टॉम" , 1 : [ 30 , 15 , 16 ] , 2 : 2.34 , ( "ab" , 100 ) : "नाही")

ए फॉर लूपमध्ये शब्दकोश घटकांद्वारे लूप करणे

शब्दकोशातील घटक इतर जटिल वस्तूंच्या घटकांप्रमाणेच लूपमध्ये पुनरावृत्ती केले जातात. तथापि, डीफॉल्टनुसार, फक्त की पुनर्प्राप्त केल्या जातात:

>>> संख्या>>> माझ्यासाठी संख्या: ...मुद्रण(i) ... 1 2 3

परंतु आपण नेहमी कळांमधून मूल्ये मिळवू शकता:

>>> माझ्यासाठी संख्या: ... प्रिंट (संख्या[i]) ... एक दोन तीन

दुसरीकडे, वर्ग म्हणून शब्दकोशात आयटम() पद्धत असते, जी टपल्स असलेली एक विशेष रचना तयार करते. प्रत्येक ट्युपलमध्ये एक की आणि मूल्य समाविष्ट आहे:

>>> n = nums.items() >>> एन dict_items([(1, "एक"), (2, "दोन"), (3, "तीन")])

फॉर लूपमध्ये, तुम्ही ट्यूपल्स अनपॅक करू शकता, त्याद्वारे की आणि त्याचे मूल्य दोन्ही एकाच वेळी काढू शकता:

>>> की साठी, nums.items मधील मूल्य () : ... प्रिंट (की, "आहे" , मूल्य) ... 1 म्हणजे एक 2 म्हणजे दोन 3 म्हणजे तीन

डिक्शनरी मेथड्स की() आणि व्हॅल्यूज() तुम्हाला की आणि व्हॅल्यूजच्या स्वतंत्र सूची मिळवण्याची परवानगी देतात. म्हणून, उदाहरणार्थ, आपल्याला केवळ मूल्ये किंवा फक्त की वर पुनरावृत्ती करण्याची आवश्यकता असल्यास, यापैकी एक पद्धत वापरणे चांगले आहे:

>>> v_nums = >>> nums.values() मध्ये v साठी : ...v_nums.append(v) ... >>> v_nums["एक", "दोन", "तीन"]

शब्दकोश पद्धती

वर चर्चा केलेल्या आयटम(), की() आणि व्हॅल्यू() या तीन पद्धतींव्यतिरिक्त, डिक्शनरीमध्ये आणखी आठ आहेत. या पद्धती आहेत clear(), copy(), fromkeys(), get(), pop(), popitem(), setdefault(), update().

clear() पद्धत डिक्शनरीतील सर्व घटक काढून टाकते, परंतु डिक्शनरी स्वतः काढून टाकत नाही. परिणामी, रिक्त शब्दकोश शिल्लक आहे:

>>> अ("कुत्रा": "कुत्रा", "मांजर": "मांजर", "माऊस": "उंदीर", "पक्षी": "पक्षी", "हत्ती": "हत्ती") >>> a.clear() >>> अ {}

शब्दकोश हा एक बदलता येणारा डेटा प्रकार आहे. म्हणून, सूचीप्रमाणे, ते संदर्भानुसार फंक्शनमध्ये दिले जाते. म्हणून, कधीकधी, जागतिक शब्दकोशात अवांछित बदल टाळण्यासाठी, ते कॉपी केले जाते. हे इतर कारणांसाठी देखील केले जाते.

>>> nums2 = nums.copy() >>> nums2[ 4 ] = "चार" >>> संख्या(1: "एक", 2: "दोन", 3: "तीन") >>> संख्या२(1: "एक", 2: "दोन", 3: "तीन", 4: "चार")

fromkeys() पद्धत तुम्हाला सूचीमधून एक शब्दकोश तयार करण्यास अनुमती देते ज्याचे घटक की बनतात. तुम्ही ही पद्धत dict क्लास आणि त्याच्या ऑब्जेक्ट्सवर लागू करू शकता:

>>> a = [ 1 , 2 , 3 ] >>> c = dict .fromkeys (a) >>>ग(1: काहीही नाही, 2: काहीही नाही, 3: काहीही नाही) >>> d = dict .fromkeys (a, 10 ) >>> डी {1: 10, 2: 10, 3: 10} >>>ग(1: काहीही नाही, 2: काहीही नाही, 3: काहीही नाही)

get() पद्धत तुम्हाला त्याच्या की द्वारे घटक मिळवण्याची परवानगी देते:

>>> nums.get (1)"एक"

अंकांच्या समतुल्य.

pop() पद्धत निर्दिष्ट की वापरून डिक्शनरीमधून घटक काढून टाकते आणि काढलेल्या जोडीचे मूल्य परत करते. popitem() पद्धत कोणतेही वितर्क घेत नाही आणि एक अनियंत्रित घटक काढून टाकते आणि परत करते.

>>> nums.pop (1 )"एक" >>> संख्या(2: "दोन", 3: "तीन") >>> nums.popitem()(2, "दोन") >>> संख्या(३: "तीन")

शब्दकोशात घटक जोडण्यासाठी तुम्ही setdefault() वापरू शकता:

>>> nums.setdefault (4 , "चार" )"चार" >>> संख्या(3: "तीन", 4: "चार")

की 4 सह घटक शब्दकोशात नसल्यास nums = "चार" च्या समतुल्य. जर ते आधीच अस्तित्वात असेल, तर nums = "four" जुने मूल्य अधिलिखित करेल, setdefault() नाही.

शब्दकोशात दुसरा शब्दकोश जोडण्यासाठी तुम्ही update() वापरू शकता:

>>> nums.update ( 6 : "सहा", 7 : "सात" ) ) >>> संख्या(3: "तीन", 4: "चार", 6: "सहा", 7: "सात")

पद्धत विद्यमान की ची मूल्ये देखील अद्यतनित करते. इतर अनेक वैशिष्ट्यांचा समावेश आहे.

व्यावहारिक काम

शाळेच्या व्हेरिएबलला जोडून एक शब्दकोश तयार करा आणि त्यात डेटा भरा जो वेगवेगळ्या वर्गातील विद्यार्थ्यांची संख्या दर्शवेल (1a, 1b, 2b, 6a, 7c, इ.). खालीलप्रमाणे शब्दकोशात बदल करा: अ) एका वर्गातील विद्यार्थ्यांची संख्या बदलली आहे, ब) शाळेत नवीन वर्ग दिसला आहे, क) दुसरा वर्ग शाळेतून काढून टाकण्यात आला आहे (काढला आहे). शाळेतील एकूण विद्यार्थी संख्येची गणना करा.

एक शब्दकोष तयार करा जिथे की संख्या आहेत आणि मूल्ये स्ट्रिंग आहेत. त्यावर आयटम() पद्धत लागू करा, परिणामी dict_items ऑब्जेक्ट तुम्ही लिहिलेल्या फंक्शनमध्ये पास करा जो नवीन शब्दकोश तयार करतो आणि परत करतो, मूळचा “उलटा”, म्हणजे की स्ट्रिंग आहेत आणि मूल्ये संख्या आहेत.

याद्यांनंतर शब्दकोश हा दुसरा सर्वात लवचिक अंगभूत प्रकार आहे. सूची एक क्रमबद्ध संग्रह आहे, तर शब्दकोश एक अक्रमित संग्रह आहे.

शब्दकोशांची अनेक विशिष्ट वैशिष्ट्ये आहेत:

1. त्यांना ऍक्सेस करण्यासाठी, तो वापरला जाणारा निर्देशांक नसून की आहे. याद्यांप्रमाणेच, शब्दकोषांमध्ये की द्वारे लूप घटकांमध्ये प्रवेश करण्याची क्षमता असते.
2. शब्दकोष क्रमवारी न लावलेल्या क्रमाने संग्रहित केले जातात आणि की ज्या क्रमाने जोडल्या गेल्या त्यापेक्षा वेगळ्या क्रमाने संग्रहित करणे देखील शक्य आहे.
3. त्याचप्रमाणे, मधील यादी शब्दकोशनेस्टेड डिक्शनरी असू शकतात. शब्दकोश मूल्ये कोणत्याही प्रकारच्या वस्तू असू शकतात (विजातीय). डिक्शनरी की - एक अपरिवर्तनीय प्रकार फ्लोट, पूर्णांक, स्ट्रिंग किंवा निर्दिष्ट प्रकार असलेले ट्यूपल असू शकते.
4. शब्दकोश द्रुत ऍक्सेस हॅश टेबलसारखा दिसतो.
5. सूचींप्रमाणेच, शब्दकोष थेट वस्तू संग्रहित करत नाहीत, परंतु केवळ त्यांचे संदर्भ देतात.

शब्दकोश संकल्पना

शब्दकोशहॅश किंवा असोसिएटिव्ह ॲरे आहे. हा की जोड्यांचा एक अक्रमित संच आहे: किल्या अद्वितीय असल्याचे मूल्य आणि आवश्यकता. दोन कुरळे ब्रेसेस () रिक्त शब्दकोश तयार करतात. अनुक्रमांमधील एक विशिष्ट वैशिष्ट्य म्हणजे शब्दकोशातील घटकांमध्ये प्रवेश एक की वापरून केला जातो, निर्देशांक नव्हे, की स्वतःच कोणत्याही प्रकारच्या बदलांना परवानगी नाही;

सह शब्दकोशदोन मुख्य ऑपरेशन्स केल्या जातात - निर्दिष्ट की सह जतन करणे, तसेच त्यातून मूल्य पुनर्प्राप्त करणे. डेल टूल तुम्हाला की हटवण्याची परवानगी देते: मूल्य जोडी.

यादृच्छिक क्रमाने लागू केलेल्या सर्व कीजची सूची परत करण्यासाठी शब्दकोषांसाठी की() पद्धत वापरली जाते. सूची क्रमवारी लावण्यासाठी तुम्हाला sort() पद्धत वापरावी लागेल. विशिष्ट कीची उपस्थिती निश्चित करण्यासाठी, तुम्ही has key() पद्धत वापरली पाहिजे, परंतु आवृत्ती 3 मध्ये ती आधीच अप्रचलित आहे आणि तुम्ही त्याऐवजी in ऑपरेटर वापरावी. शब्दकोशात नवीन जोडण्यासाठी वस्तूप्राथमिक तपासणी करण्याची आवश्यकता नाही: जर याच्या किल्लीचे आधीच निश्चित मूल्य असेल तर ते अधिलिखित केले जाईल.

उदाहरण म्हणून, वास्या पपकिनच्या इलेक्ट्रॉनिक डॉसियरसह कार्य घेऊ.

# रिक्त शब्दकोश डेटा तयार करा = () # किंवा याप्रमाणे डेटा = dict() # त्याची लांबी निश्चित करा - 0 len(data) # डेटासह भरा - नाव आणि आडनाव डेटा = ("firstname": "Vasya", " lastname": "पपकिन" ") # शब्दकोषाची लांबी # या क्षणी कळांच्या संख्येने निर्धारित केली जाते - 2 लेन(डेटा) # मधले नाव डेटा जोडा["मध्यचे नाव"] = "वासीलेविच" # वास्याच्या लग्नानंतर , आडनाव फील्ड अद्यतनित करा आणि बँक खाते जोडा data.update("lastname" :"Gates", "bank_account": 10000000)) # पत्नीच्या डेटासह शब्दकोशात एक नवीन घटक जोडा... डेटा["wife "] = ("प्रथम नाव": "ॲनेट", "आडनाव": "गेट्स", "मध्यचे नाव" : "बिलोव्हना") # ... आणि हुंडा गॅरेज डेटामध्ये टाका["गॅरेज"] = ["जॅग्वार" , "Toyota Camry"] # आणि आणखी एक कार डेटा["garage"].append("Honda Civic") # त्याच्या पत्नीचे नाव शोधा - Annet print data["wife"]["firstname"] # वास्या त्याच्या मित्रांना बढाई मारतो मुद्रित डेटा["bank_account"] # आवश्यक कीसह कोणताही घटक नसल्यास, # डेटामध्ये "bank_account" असल्यास तुम्ही त्रुटी टाळू शकता: डेटा मुद्रित करा ["bank_account"] अन्यथा: "no money" # किंवा डेटा प्रिंट करा .get("bank_account", 0) # खाते बंद करा del data["bank_account"] # डेटामधील कीसाठी डॉसियर मुद्रित करा: प्रिंट की, ":" , डेटा #### मुद्रणानंतर खालील # प्रथमनाव तयार करेल: वास्या # पत्नी: ("मध्यचे नाव": "बिलोव्हना", "आडनाव": "गेट्स", "फर्स्टनेम": "अनेट") # मधले नाव: वासिलीविच # आडनाव: गेट्स # गॅरेज: ["जॅग्वार", "टोयोटा कॅमरी", "Honda Civic"] #### आणि डॉसियर स्वतः असे दिसते # ("पहिले नाव": "वस्य", "पत्नी": ("मध्यनाव": "बिलोव्हना", "आडनाव": "गेट्स", # "पहिले नाव" ": "ॲनेट"), "मध्यचे नाव": "वसिलीविच", "आडनाव": "गेट्स", # "गॅरेज": ["जॅग्वार", "टोयोटा केमरी", " होंडा सिविक"])

बहुधा एवढेच.

आज मी अशा डेटा प्रकाराबद्दल बोलणार आहे शब्दकोश, शब्दकोषांसह कार्य करण्याबद्दल, त्यांच्यावरील ऑपरेशन्स, पद्धती, शब्दकोश जनरेटरबद्दल.

Python मध्ये शब्दकोश- कीद्वारे प्रवेशासह अनियंत्रित वस्तूंचे अक्रमित संग्रह. त्यांना कधीकधी असोसिएटिव्ह ॲरे किंवा हॅश टेबल देखील म्हणतात.

शब्दकोशासह कार्य करण्यासाठी, आपल्याला ते तयार करणे आवश्यक आहे. ते तयार करण्याचे अनेक मार्ग आहेत. प्रथम, शाब्दिक वापरून:

>>> d = () >>> d () >>> d = ( "dict" : 1 , "dictionary" : 2 ) >>> d ( "dict" : 1 , "dictionary" : 2 )

दुसरे म्हणजे, फंक्शन वापरणे dict:

>>> d = dict (लहान = "dict" , long = "dictionary" ) >>> d ("शॉर्ट": "डिक्ट", "लाँग": "डिक्शनरी")>>> d = dict ([(1 , 1 ), (2 , 4 )]) >>> d (1: 1, 2: 4)

तिसरे, fromkeys पद्धत वापरून:

>>> d = dict. fromkeys ([ "a" , "b" ]) >>> d ("a": काहीही नाही, "b": काहीही नाही) >>> d = dict . fromkeys ([ "a" , "b" ], 100 ) >>> d ("a": 100, "b": 100)

चौथे, शब्दकोश जनरेटर वापरणे, जे सारखेच आहेत.

>>> d = ( a : a ** 2 श्रेणीतील a साठी (7 )) >>> d {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36}

आता शब्दकोशात नोंदी जोडण्याचा प्रयत्न करूया आणि मुख्य मूल्ये काढूया:

>>> d = ( 1 : 2 , 2 : 4 , 3 : 9 ) >>> d [ 1 ] 2 >>> d [ 4 ] = 4 ** 2 >>> d ( 1: 2, 2: 4 , 3: 9, 4: 16) >>> d [ "1" ] ट्रेसबॅक (सर्वात अलीकडील कॉल शेवटचा):फाइल "", लाइन 1, d["1"] मध्ये की त्रुटी: "1"

जसे तुम्ही उदाहरणावरून पाहू शकता, नवीन कीला असाइनमेंट केल्याने शब्दकोशाचा विस्तार होतो, विद्यमान कीला असाइनमेंट ते अधिलिखित करते आणि अस्तित्वात नसलेली की पुनर्प्राप्त करण्याचा प्रयत्न अपवाद ठरतो. अपवाद टाळण्यासाठी, एक विशेष पद्धत आहे (खाली पहा), किंवा आपण हे करू शकता.

आपण शब्दकोषांसह आणखी काय करू शकता? होय, इतर वस्तूंप्रमाणेच: , (उदाहरणार्थ, ), तसेच शब्दकोषांच्या विशेष पद्धती.

शब्दकोश पद्धती

dict.clear() - शब्दकोश साफ करते.

dict.copy() - शब्दकोशाची प्रत परत करते.

वर्ग पद्धत dict.fromkeys(seq[, value]) - seq आणि व्हॅल्यू व्हॅल्यू (डिफॉल्टनुसार काहीही नाही) मधील कीसह एक शब्दकोश तयार करते.

dict.get(की[, डीफॉल्ट]) - कीचे मूल्य परत करते, परंतु ते अस्तित्वात नसल्यास, ते अपवाद देत नाही, परंतु डीफॉल्ट परत करते (डीफॉल्ट काहीही नाही).

dict.items() - परतावा (की, मूल्य) जोड्या.

dict.keys() - शब्दकोशातील की परत करते.

dict.pop(की[, डीफॉल्ट]) - एक की काढून टाकते आणि मूल्य परत करते. कोणतीही की नसल्यास, डीफॉल्ट परत करते (डीफॉल्टनुसार अपवाद फेकते).

dict.popitem() - काढते आणि एक (की, मूल्य) जोडी परत करते. शब्दकोश रिक्त असल्यास, KeyError अपवाद टाकतो. लक्षात ठेवा की शब्दकोष क्रमरहित आहेत.

dict.setdefault(की[, डीफॉल्ट]) - कीचे मूल्य परत करते, परंतु ते अस्तित्वात नसल्यास, ते अपवाद देत नाही, परंतु डीफॉल्ट मूल्यासह की तयार करते (डिफॉल्टनुसार काहीही नाही).

dict.update() - इतरांकडून (की, मूल्य) जोड्या जोडून शब्दकोश अद्यतनित करते. विद्यमान की अधिलिखित केल्या आहेत. काहीही मिळत नाही (नवीन शब्दकोश नाही!).

dict.values() - शब्दकोशातील मूल्ये परत करते.

रेग्युलर लिस्ट (ॲरे) हा क्रमांकित घटकांचा संच असतो, म्हणजेच सूचीतील कोणत्याही घटकामध्ये प्रवेश करण्यासाठी, तुम्ही त्याची संख्या निर्दिष्ट करणे आवश्यक आहे. सूचीतील घटकाची संख्या विशिष्टपणे घटकाची ओळख करून देते. परंतु संख्यात्मक संख्येद्वारे डेटा ओळखणे नेहमीच सोयीचे नसते. उदाहरणार्थ, रशियामधील रेल्वे मार्ग संख्यात्मक-वर्णमाला कोड (एक संख्या आणि एक अक्षर) द्वारे ओळखले जातात आणि हवाई उड्डाणे संख्यात्मक-वर्णमाला कोडद्वारे देखील ओळखली जातात, म्हणजेच, ट्रेन किंवा विमान उड्डाणांची माहिती संग्रहित करण्यासाठी, अभिज्ञापक म्हणून संख्येऐवजी मजकूर स्ट्रिंग वापरण्यास सोयीस्कर व्हा.

डेटा स्ट्रक्चर जी त्याच्या घटकांना संख्यात्मक निर्देशांकाने नव्हे तर अनियंत्रित द्वारे ओळखण्याची परवानगी देते, त्याला म्हणतात. शब्दकोशकिंवा सहयोगी ॲरे. Python मधील संबंधित डेटा स्ट्रक्चरला dict म्हणतात.

शब्दकोश वापरण्याचे एक साधे उदाहरण पाहू. चला कॅपिटल्सचा शब्दकोश तयार करूया, जिथे निर्देशांक हे देशाचे नाव आहे आणि मूल्य हे या देशाच्या राजधानीचे नाव आहे. यामुळे देशाच्या नावाच्या रेषेनुसार राजधानी निश्चित करणे सोपे होईल.

# रिक्त शब्द तयार करा Capitals Capitals = dict() # ते अनेक मूल्यांसह भरा Capitals["Russia"] = "मॉस्को" कॅपिटल्स["Ukraine"] = "Kiev" Capitals["USA"] = "वॉशिंग्टन" देश = ["रशिया" ", "फ्रान्स", "यूएसए", "रशिया"] देशांमधील देशासाठी: # सूचीतील प्रत्येक देशासाठी, कॅपिटलमधील देश असल्यास ते कॅपिटल डिक्शनरीमध्ये आहे का ते तपासा: print("Capital of देश " + देश + ": " + कॅपिटल्स) इतर: प्रिंट ("डेटाबेसमध्ये " + देश नावाचा कोणताही देश नाही)

तर, प्रत्येक शब्दकोश घटकामध्ये दोन वस्तू असतात: कीआणि मूल्ये. आमच्या उदाहरणात, की देशाचे नाव आहे, मूल्य हे राजधानीचे नाव आहे. की शब्दकोषातील घटक ओळखते, मूल्य हे दिलेल्या कीशी संबंधित डेटा आहे. मुख्य मूल्ये अद्वितीय आहेत; शब्दकोशात दोन समान की असू शकत नाहीत.

जीवनात शब्दकोश मोठ्या प्रमाणावर वापरले जातात, उदाहरणार्थ, नेहमीच्या कागदी शब्दकोश (स्पष्टीकरणात्मक, शब्दलेखन, भाषिक). त्यामध्ये, मुख्य म्हणजे लेखाचे शब्द-शीर्षक आणि मूल्य हे लेखाचेच आहे. लेखात प्रवेश करण्यासाठी, आपण एक मुख्य शब्द निर्दिष्ट करणे आवश्यक आहे.

डेटा स्ट्रक्चर म्हणून शब्दकोशाचे आणखी एक उदाहरण टेलिफोन डिरेक्टरी आहे. त्यामध्ये, की नाव आहे आणि मूल्य फोन नंबर आहे. डिक्शनरी आणि टेलिफोन डिरेक्टरी दोन्ही अशा प्रकारे संग्रहित केले जातात की ज्ञात की द्वारे शब्दकोश एंट्री शोधणे सोपे आहे (उदाहरणार्थ, जर नोंदी कीच्या वर्णक्रमानुसार संग्रहित केल्या गेल्या असतील तर ज्ञात की शोधणे सोपे आहे. , उदाहरणार्थ, बायनरी शोधाद्वारे), परंतु की अज्ञात असल्यास आणि फक्त मूल्य ज्ञात असल्यास, दिलेल्या मूल्यासह घटक शोधण्यासाठी शब्दकोशातील सर्व घटक अनुक्रमे स्कॅन करणे आवश्यक असू शकते.

असोसिएटिव्ह ॲरेचे एक विशेष वैशिष्ट्य म्हणजे त्याची गतिशीलता: तुम्ही अनियंत्रित कीसह नवीन घटक जोडू शकता आणि विद्यमान घटक हटवू शकता. या प्रकरणात, वापरलेल्या मेमरीचा आकार असोसिएटिव्ह ॲरेच्या आकाराच्या प्रमाणात असतो. असोसिएटिव्ह ॲरेच्या घटकांमध्ये प्रवेश करणे, जरी नियमित ॲरेपेक्षा हळू असले तरी, सामान्यतः बरेच जलद असते.

पायथन भाषेत, की हा एक अनियंत्रित अपरिवर्तनीय डेटा प्रकार असू शकतो: पूर्णांक आणि वास्तविक संख्या, स्ट्रिंग, ट्युपल्स. शब्दकोषातील की संच असू शकत नाही, परंतु तो प्रकार फ्रोझनसेटचा घटक असू शकतो: एक विशेष डेटा प्रकार जो सेट प्रकाराशी साधर्म्य असलेला असतो, जो निर्मितीनंतर बदलला जाऊ शकत नाही. डिक्शनरी घटकाचे मूल्य म्युटेबलसह कोणताही डेटा प्रकार असू शकतो.

शब्दकोष कधी वापरायचे

खालील प्रकरणांमध्ये शब्दकोश वापरावे:

• काही वस्तूंची संख्या मोजत आहे. या प्रकरणात, आपल्याला एक शब्दकोश तयार करण्याची आवश्यकता आहे ज्यामध्ये कीज ऑब्जेक्ट्स आहेत आणि मूल्ये त्यांची संख्या आहेत.
• ऑब्जेक्टशी संबंधित कोणताही डेटा संग्रहित करणे. की वस्तू आहेत, मूल्ये त्यांच्याशी संबंधित डेटा आहेत. उदाहरणार्थ, जर तुम्हाला महिन्याच्या नावावरून त्याचा अनुक्रमांक निश्चित करायचा असेल, तर हे डिक्शनरी Num["January"] = 1 वापरून करता येईल; संख्या["फेब्रुवारी"] = २; ...
• ऑब्जेक्ट्स दरम्यान पत्रव्यवहार स्थापित करणे (उदाहरणार्थ, "पालक-मुल").
• की एक ऑब्जेक्ट आहे, मूल्य संबंधित ऑब्जेक्ट आहे.

जर तुम्हाला नियमित ॲरेची आवश्यकता असेल, परंतु घटकाचे कमाल अनुक्रमणिका मूल्य खूप मोठे असेल आणि सर्व संभाव्य निर्देशांक वापरले जाणार नाहीत (तथाकथित "विरळ ॲरे"), तर तुम्ही मेमरी जतन करण्यासाठी सहयोगी ॲरे वापरू शकता.

शब्दकोश तयार करणे

राजधानी = ("रशिया": "मॉस्को", "युक्रेन": "कीव", "यूएसए": "वॉशिंग्टन") राजधानी = डिक्ट(रशिया = "मॉस्को", युक्रेन = "कीव", यूएसए = "वॉशिंग्टन") राजधानी = dict([("रशिया", "मॉस्को"), ("युक्रेन", "कीव"), ("यूएसए", "वॉशिंग्टन")]) कॅपिटल्स = dict(zip(["रशिया", "युक्रेन", "यूएसए"], ["मॉस्को", "कीव", "वॉशिंग्टन"])) प्रिंट(राजधानी)

पहिल्या दोन पद्धती फक्त लहान शब्दकोष तयार करण्यासाठी वापरल्या जाऊ शकतात, त्यांचे सर्व घटक सूचीबद्ध करतात. या व्यतिरिक्त, दुसऱ्या पद्धतीमध्ये, डिक्ट फंक्शनमध्ये की नावाच्या पॅरामीटर्स म्हणून पास केल्या जातात, म्हणून या प्रकरणात की फक्त स्ट्रिंग असू शकतात आणि त्या वैध अभिज्ञापक आहेत. तिसऱ्या आणि चौथ्या प्रकरणांमध्ये, तुम्ही युक्तिवाद म्हणून तयार केलेल्या याद्या पास केल्यास तुम्ही मोठे शब्दकोष तयार करू शकता, जे सर्व घटकांची यादी करून मिळू शकत नाही, परंतु प्रोग्रामच्या अंमलबजावणीदरम्यान तयार केलेल्या इतर कोणत्याही प्रकारे मिळवता येते. तिसऱ्या पद्धतीसाठी dict फंक्शनला एक सूची पास करणे आवश्यक आहे, ज्यातील प्रत्येक घटक दोन घटकांचा ट्युपल आहे: एक की आणि एक मूल्य. चौथी पद्धत झिप फंक्शन वापरते, जी समान लांबीच्या दोन सूची पास केली जाते: कीची सूची आणि मूल्यांची सूची.

शब्दकोश घटकांसह कार्य करणे

मुख्य ऑपरेशन: की द्वारे घटकाचे मूल्य मिळवणे, सूचीसाठी तशाच प्रकारे लिहिलेले आहे: A . दिलेल्या की सह घटक शब्दकोशात नसल्यास, एक KeyError अपवाद वाढविला जातो.

की द्वारे मूल्य निर्धारित करण्याचा दुसरा मार्ग म्हणजे get पद्धत: A.get(key) . गेट की असलेले घटक शब्दकोशात नसल्यास, काहीही परत केले जात नाही. टू-अर्ग्युमेंट नोटेशन फॉर्ममध्ये, की सह घटक शब्दकोशात नसल्यास A.get(key, val) पद्धत val मिळवते.

संचाप्रमाणे, इन आणि ऑपरेशनमध्ये नसून एखादा घटक डिक्शनरीचा आहे की नाही हे तुम्ही तपासू शकता.

शब्दकोशात नवीन घटक जोडण्यासाठी, तुम्हाला फक्त काही मूल्य नियुक्त करावे लागेल: A = मूल्य.

डिक्शनरीमधून घटक काढून टाकण्यासाठी, तुम्ही del A ऑपरेशन वापरू शकता (डिक्शनरीमध्ये अशी कोणतीही की नसल्यास ऑपरेशन KeyError अपवाद वाढवते. शब्दकोशातून घटक हटवण्याचे दोन सुरक्षित मार्ग येथे आहेत.

पहिल्या प्रकरणात, आम्ही प्रथम घटकाची उपस्थिती तपासतो आणि दुसऱ्या प्रकरणात, आम्ही अपवाद रोखतो आणि हाताळतो.

शब्दकोशातून घटक काढून टाकण्याचा दुसरा मार्ग म्हणजे पॉप पद्धत वापरणे: A.pop(key) . ही पद्धत काढून टाकल्या जाणाऱ्या घटकाचे मूल्य परत करते; जर तुम्ही दुसरे पॅरामीटर पॉप मेथडमध्ये पास केले, तर घटक डिक्शनरीमध्ये नसल्यास, पॉप पद्धत या पॅरामीटरचे मूल्य परत करेल. हे डिक्शनरीमधून घटक सुरक्षितपणे काढून टाकण्याचा सर्वात सोपा मार्ग देते: A.pop(key, None).

शब्दकोश घटकांद्वारे पळवाट

तुम्ही डिक्शनरीमधील सर्व घटकांच्या कीजची गणना सहजपणे व्यवस्थापित करू शकता:

A = A मधील की साठी dict(zip("abcdef", list(range(6)))): print(key, A)

खालील पद्धती परत येतात सबमिशनशब्दकोश घटक. दृश्ये बरीचशी संचासारखी असतात, परंतु शब्दकोश घटकांची मूल्ये बदलल्यास ते बदलतात. की पद्धत सर्व घटकांच्या कीचे प्रतिनिधित्व देते, मूल्य पद्धत सर्व मूल्यांचे प्रतिनिधित्व देते आणि आयटम पद्धत की आणि मूल्यांच्या सर्व जोड्यांचे (ट्यूपल्स) प्रतिनिधित्व देते.

त्यानुसार, तुम्ही डिक्शनरी A च्या घटकांच्या सर्व मूल्यांमध्ये व्हॅल आहे की नाही हे त्वरीत तपासू शकता: val मधील A.values() , आणि लूप व्यवस्थापित करा जेणेकरून व्हेरिएबल कीमध्ये घटकाची की असेल. , आणि व्हेरिएबल val मध्ये त्याचे मूल्य असे आहे:

A = dict(zip("abcdef", यादी(श्रेणी(6)))) की साठी, A.items() मध्ये val: print(key, val)

पायथन प्रोग्रॅमिंग भाषेतील डिक्शनरी म्हणजे की द्वारे प्रवेशासह अनियंत्रित प्रकारच्या डेटाचा एक क्रमरहित संच आहे. अशा संग्रहाचे घटक ऑब्जेक्ट्सच्या जोड्या असतात, त्या प्रत्येकामध्ये एक की आणि मूल्य समाविष्ट असते. शब्दकोषांसह कार्य करण्यासाठी, कार्ये उपलब्ध आहेत जी त्यांची सामग्री बदलतात आणि त्यांच्यावर विविध ऑपरेशन्स करतात. हे इतर डेटा प्रकारांमध्ये रूपांतरित केले जाऊ शकते, जसे की स्ट्रिंग.

निर्मिती

आपण शब्दकोशासह कार्य करण्यास प्रारंभ करण्यापूर्वी, आपल्याला तो तयार करणे आवश्यक आहे. फ्री व्हेरिएबलला ऑब्जेक्ट्सच्या जोड्यांची अनियंत्रित संख्या नियुक्त करून भाषेच्या मूलभूत माध्यमांचा वापर करून हे केले जाऊ शकते. घटक कुरळे ब्रेसेसमध्ये बंद केलेले असणे आवश्यक आहे आणि की आणि मूल्य यांच्यामध्ये कोलन असणे आवश्यक आहे. खालील उदाहरण a नावाच्या शब्दकोशाची निर्मिती दर्शविते ज्यामध्ये संख्या म्हणून की आणि स्ट्रिंग म्हणून मूल्ये समाविष्ट आहेत.

A = (1: "एक", 2: "दोन", 3: "तीन") प्रिंट(a) (1: "एक", 2: "दोन", 3: "तीन")

वितर्क म्हणून आवश्यक डेटा सेट निर्दिष्ट करून, मानक प्रिंट फंक्शन वापरून आपण शब्दकोशातील सामग्री प्रदर्शित करू शकता. डिक्शनरी तयार करण्यासाठी डिक्ट पद्धत देखील वापरली जाते, की-मूल्य जोड्यांची अनियंत्रित संख्या प्राप्त करणे. या प्रकरणात, खालील कोड उदाहरणामध्ये दर्शविल्याप्रमाणे, फक्त एक स्ट्रिंग ही की असू शकते.

A = dict(एक = 1, दोन = 2, तीन = 3) प्रिंट(a) ("एक": 1, "दोन": 2, "तीन": 3)

मागील वेळेप्रमाणेच, प्रिंट फंक्शन डिक्शनरीमधील मजकूर दाखवते. या प्रकरणात, वस्तूंच्या जोड्या आहेत, ज्या संख्या आणि स्ट्रिंग म्हणून देखील दर्शविल्या जातात.

एक घटक जोडत आहे

Python 3 मध्ये, आपल्या गरजेनुसार शब्दकोशातील सामग्री कधीही बदलली जाऊ शकते. उदाहरणार्थ, कलेक्शनमध्ये ऑब्जेक्ट्सची नवीन जोडी जोडण्यासाठी, तुम्हाला फक्त स्क्वेअर ब्रॅकेटमध्ये एक नवीन की, तसेच त्याचे संबंधित मूल्य निर्दिष्ट करणे आवश्यक आहे.

A = (1: "एक", 2: "दोन", 3: "तीन") a = "चार" प्रिंट(a) (1: "एक", 2: "दोन", 3: "तीन", 4 : "चार")

वरील कोड पूर्वी तयार केलेल्या संग्रहाच्या शेवटी नवीन जोडी (4: “चार”) ठेवण्यासाठी असाइनमेंट ऑपरेटर वापरतो.

शब्दकोश विलीन करणे

डेटा एका डिक्शनरीमधून दुसऱ्या डिक्शनरीमध्ये हलवायचा असल्यास, तुम्ही अपडेट मर्ज फंक्शन वापरावे. नवीन की-व्हॅल्यू जोड्यांसह विस्तारित केल्या जाणाऱ्या ऑब्जेक्टवर तुम्हाला ते कॉल करणे आवश्यक आहे. पायथनमधील शब्दकोशात शब्दकोश कसा जोडायचा याचे उदाहरण येथे आहे:

A = (1: "एक", 2: "दोन", 3: "तीन") b = (4: "चार", 5: "पाच") a. अद्यतन(b) प्रिंट(a) (1: " एक", 2: "दोन", 3: "तीन", 4: "चार", 5: "पाच")

मुद्रण पद्धतीचा परिणाम म्हणजे शब्दकोशातील अद्ययावत सामग्री प्रदर्शित करणे ज्याला a म्हणतात.

विलीन झाल्यानंतर, नवीन घटक आपोआप संग्रहाच्या शेवटी लिहिले गेले.

एक घटक काढून टाकत आहे

डिक्शनरीमध्ये अनावश्यक माहिती असल्यास, विशेष डेल ऑपरेशन वापरून आपण सहजपणे त्यातून मुक्त होऊ शकता. ते कार्यान्वित करण्यासाठी, आपण संग्रहाचे नाव तसेच चौरस कंसात की निर्दिष्ट करणे आवश्यक आहे. पुढील उदाहरण जोडी काढणे दर्शविते.

A = (1: "एक", 2: "दोन", 3: "तीन") प्रिंट (अ) (1: "एक", 2: "दोन")

ऑपरेशनला की 3 प्राप्त झाल्यापासून, त्याच्या ऑपरेशनच्या परिणामी मूल्य तीन देखील हटविले गेले.

आकार मिळत आहे

कार्य len तुम्हाला कोणत्याही वेळी शब्दकोश घटकांची वर्तमान संख्या निर्धारित करण्यास अनुमती देते, जर तुम्ही ते पास केले तर वितर्क म्हणून संग्रहाचे नाव द्या. खालील उदाहरणात, मुद्रण पद्धत शब्दकोशाचे परिमाण मुद्रित करते a.

A = (1: "एक", 2: "दोन", 3: "तीन") प्रिंट(लेन(ए)) 3

हे लक्षात घेण्यासारखे आहे len फंक्शन जोड्यांची अचूक संख्या देते, परंतु ऑब्जेक्ट्स नाही. या प्रकरणात, एक शब्दकोश आहे ज्यामध्ये अगदी 3 जोड्या आहेत.

शब्दकोश शोध

तुम्ही डिक्शनरीच्या घटकांची अनेक प्रकारे गणन करू शकता, तुम्ही त्यातील मजकुराबद्दल मिळवू इच्छित असलेल्या माहितीवर अवलंबून.

पुढील प्रक्रियेसाठी प्राप्त करण्यासाठी घटकांची पुनरावृत्ती केली जाऊ शकते:

• की-मूल्याच्या जोड्या;
• सर्व कळांची गणना;
• मूल्यांवर पुनरावृत्ती.

या कलेक्शनच्या सर्व जोड्या फॉरमॅट की: value मध्ये कसे प्रदर्शित करायचे हे उदाहरण दाखवते. हे करण्यासाठी, आम्ही फॉर लूप आणि आयटम फंक्शन वापरतो, जे डिक्शनरी घटकांसह कार्य करते.

A = (1: "एक", 2: "दोन", 3: "तीन"), a.items() मधील मूल्य: print(की, ":", मूल्य) 1: एक 2: दोन 3: तीन

फक्त की मिळवण्यासाठी, की पद्धत वापराडिक्शनरीवर कॉल करून.

A = (1: "एक", 2: "दोन", 3: "तीन") a.keys(): print(की) 1 2 3 मधील कीसाठी

फक्त डिक्शनरी व्हॅल्यूज दाखवण्यासाठी तुम्हाला तेच करावे लागेल. तथापि, या प्रकरणात, फॉर लूप मूल्ये पद्धत वापरते.

A = (1: "एक", 2: "दोन", 3: "तीन") a.values(): print(val) एक दोन तीन

दोन्ही प्रकरणांमध्ये, जोडीचा फक्त निवडलेला भाग, की किंवा मूल्य, प्रदर्शित केले जाते.

शोधा

इन ऑपरेशन वापरून तुम्ही विशिष्ट कीची उपस्थिती तपासू शकता. हे करण्यासाठी, नावाच्या शब्दकोशासाठी त्याच्या अंमलबजावणीचा परिणाम प्रदर्शित करणे पुरेसे आहे.

A = (1: "एक", 2: "दोन", 3: "तीन") मुद्रित (2 अ मध्ये) मुद्रण (4 मध्ये अ) खरे खोटे

जसे आपण पाहू शकता, की 2 तपासल्याने सकारात्मक परिणाम आला (सत्य). दुसऱ्या प्रकरणात, मूल्य असत्य होते कारण की 4 शब्दकोषात आढळली नाही.

वर्गीकरण

भाषा साधने गरजेनुसार, की आणि मूल्यांनुसार पायथनमधील शब्दकोश क्रमवारी लावणे शक्य करतात. खालील उदाहरणामध्ये एक नावाचा डेटा संग्रह आहे ज्यामध्ये कोणत्याही विशिष्ट क्रमाने माहिती नाही. येथे की संख्या आहेत आणि मूल्ये स्ट्रिंग आहेत. आयात केलेले ऑपरेटर मॉड्यूल आणि अंगभूत आयटमजेटर पद्धत वापरून क्रमवारी लावली जाते 0 किंवा 1 प्राप्त करत आहे.

आयात ऑपरेटर a = (2: "दोन", 3: "तीन", 1: "एक") b = सॉर्टेड(a.items(), key = operator.itemgetter(0)) print(b) b = sorted( a.items(), key = operator.itemgetter(1)) print(b) [(1, "एक"), (2, "दोन"), (3, "तीन")] [(1, "एक " "), (3, "तीन"), (2, "दोन")]

जसे तुम्ही बघू शकता, वितर्क 0 तुम्हाला की नुसार शब्दकोश क्रमवारी लावण्याची परवानगी देतो, तर 1 तुम्हाला त्यातील मजकूर मूल्यांच्या वर्णक्रमानुसार प्रदर्शित करण्यास अनुमती देतो.

तुलना

काहीवेळा आपल्याला हे सुनिश्चित करणे आवश्यक आहे की दोन शब्दकोषांमध्ये अगदी समान डेटा आहे किंवा कोणता संग्रह मोठा किंवा लहान आकारात आहे हे शोधा. या प्रकरणात, cmp पद्धत बचावासाठी येते, पॅरामीटर्स म्हणून दोन शब्दकोष प्राप्त करतात.

A = (1: "एक", 2: "दोन", 3: "तीन") b = (4: "चार", 5: "पाच") c = (1: "एक", 2: "दोन" , 3: "तीन") प्रिंट(cmp(a, b)) प्रिंट(cmp(b, c)) प्रिंट(cmp(a, c)) 1 -1 0

खालील कोडने वितर्कांच्या तीन संयोजनांसह cmp पद्धतीची अंमलबजावणी दर्शविली आहे. आउटपुट परिणामांवरून पाहिल्याप्रमाणे, फंक्शन प्रथम दुसऱ्यापेक्षा मोठे असल्यास 1, उलट असल्यास -1 आणि डेटा पूर्णपणे सारखा असल्यास 0 मिळवते.

कॉपी करा

एका शब्दकोशातील मजकूर दुसऱ्या शब्दकोशात कॉपी करण्यासाठी कॉपी पद्धत वापरली जाते. हे उदाहरण संग्रह a पासून b मध्ये की आणि मूल्ये हस्तांतरित करते हे दर्शवते.

A = (1: "एक", 2: "दोन", 3: "तीन") b = a.copy() प्रिंट(b) (1: "एक", 2: "दोन", 3: "तीन" )

तुम्ही बघू शकता, नवीन सेटमध्ये सर्व जोड्यांचा क्रम आणि सामग्री जतन केली गेली आहे.

साफसफाई

शब्दकोशातील सर्व घटकांपासून मुक्त होण्यासाठी, आपण त्यावर स्पष्ट कार्य कॉल केले पाहिजे.

A = (1: "एक", 2: "दोन", 3: "तीन") a.clear() print(a) ()

परिणाम पूर्णपणे रिक्त डेटा संच आहे.

शब्दकोश जनरेटर

इतर डेटा सेट प्रमाणे, वापरून शब्दकोश भरू शकता. खालील उदाहरणात Python डिक्शनरी जनरेटर वापरून संख्यात्मक संग्रह जोड्यांची निर्मिती दर्शवते ज्यामध्ये 5 ही युक्तिवाद म्हणून श्रेणी पद्धत आहे.

A = (a: a * a साठी श्रेणी(5)) प्रिंट(a) (0: 0, 1: 1, 2: 4, 3: 9, 4: 16)

अशा प्रकारे, आउटपुट एक शब्दकोश a आहे, ज्यामध्ये अगदी 5 जोड्या समाविष्ट आहेत. की 0 ते 4 पर्यंतच्या संख्या आहेत आणि मूल्ये त्यांचे गणितीय वर्ग आहेत.

स्ट्रिंगमध्ये रूपांतरित करा

एक शब्दकोश त्याच्या सामग्रीच्या सुसंगत दृश्यासह सुलभ कार्यासाठी अगदी सहजपणे स्ट्रिंगमध्ये रूपांतरित केला जाऊ शकतो. हे करण्यासाठी तुम्हाला str फंक्शनची आवश्यकता असेल. आपण प्रकार पद्धतीच्या परिणामांवरून पाहू शकता, रूपांतरण यशस्वी झाले.

A = (1: "एक", 2: "दोन", 3: "तीन") b = str(a) मुद्रण(b) मुद्रण(प्रकार(b)) (1: "एक", 2: "दोन" , 3: "तीन")

Python स्ट्रिंगला डिक्शनरीमध्ये रूपांतरित करणे त्याच प्रकारे कार्य करते.. हे महत्त्वाचे आहे की त्यातील मजकूर सामग्री प्रश्नातील संग्रहाच्या संरचनेशी जुळते.

A = "(1: "एक", 2: "दोन", 3: "तीन")" b = eval(a) प्रिंट(b) प्रिंट(प्रकार(b)) (1: "एक", 2: " दोन", 3: "तीन")

जसे तुम्ही उदाहरणावरून पाहू शकता, eval पद्धत स्ट्रिंगचा संपूर्ण मजकूर नवीन शब्दकोशात रूपांतरित करते.

घरटे

Python मध्ये, शब्दकोश नेस्टेड केले जाऊ शकतात, म्हणजेच ते दुसर्या मोठ्या शब्दकोशाचा भाग असू शकतात.. परिचित कुरळे ब्रेसेस आणि कोलन वापरून, तुम्ही या डेटा सेटच्या सीमा रेखाटू शकता आणि प्रोग्रामला की-व्हॅल्यू जोड्यांसह प्रदान करू शकता.

A = ( "प्रथम": ( 1: "एक", 2: "दोन", 3: "तीन"), "दुसरा": ( 4: "चार", 5: "पाच") ) प्रिंट(अ) ( "प्रथम": (1: "एक", 2: "दोन", 3: "तीन"), "दुसरा": (4: "चार", 5: "पाच"))

वर वर्णन केलेल्या उदाहरणामध्ये, एक शब्दकोश a तयार केला आहे ज्यामध्ये दोन इतर शब्दकोश (प्रथम आणि द्वितीय) समाविष्ट आहेत. त्या बदल्यात, की आणि मूल्यांच्या अनेक जोड्या असतात.

पुन्हा सुरू करा

खालील तक्ता दाखवतो Python 3 मधील शब्दकोशांसह कार्य करण्यासाठी चर्चा केलेल्या सर्व पद्धतींचा संक्षिप्त सारांश. सारणी पद्धतींची नावे तसेच त्यांच्या उद्देशाबद्दल माहिती दर्शविते.