शब्दकोश

डिक्टेशन, पहले से मौजूद टाइप का होता है, जो असोसिएशन की मैपिंग या डिक्शनरी होता है. डिक्शनरी, 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. पहले से मौजूद फ़ैसले फ़ंक्शन में किया गया कॉल, तय किए गए नामों वाली डिक्शनरी दिखाता है. इसमें, तर्क के हिसाब से क्रम में डाले गए तर्क, नाम के पहले तय किए गए तर्क शामिल होते हैं. साथ ही, समझ कर भी डुप्लीकेट कुंजियों की अनुमति है.
  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}

सदस्य

मिटाएं

None dict.clear()

शब्दकोश से सभी आइटम हटाएं.

पाएं

unknown dict.get(key, default=None)

अगर key, शब्दकोश में है, तो default के लिए key का मान देता है. अगर default नहीं दिया गया है, तो यह None पर डिफ़ॉल्ट हो जाता है. इससे इस तरीके में कभी कोई गड़बड़ी नहीं होती.

पैरामीटर

पैरामीटर ब्यौरा
key ज़रूरी है
खोजी जाने वाली कुंजी.
default डिफ़ॉल्ट = कोई नहीं
अगर कुंजी नहीं मिलती है, तो इस्तेमाल करने के लिए डिफ़ॉल्ट मान (कोई नहीं) के बजाय डिफ़ॉल्ट मान होता है.

आइटम

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 डिफ़ॉल्ट = अनबाउंड
अगर मान मौजूद नहीं है, तो डिफ़ॉल्ट मान.

पॉप आइटम

tuple dict.popitem()

शब्दकोश से पहली (key, value) जोड़ी को हटाएं और वापस लौटाएं. popitem किसी शब्दकोश पर गलती से दोहराने के लिए उपयोगी है, जिसका इस्तेमाल अक्सर सेट एल्गोरिदम में किया जाता है. अगर शब्दकोश खाली है, तो popitem कॉल विफल हो जाता है.

डिफ़ॉल्ट सेटिंग

unknown dict.setdefault(key, default=None)

अगर key डिक्शनरी में है, तो उसकी वैल्यू दिखाएं. अगर नहीं, तो default के मान वाली कुंजी डालें और default लौटाएं. default डिफ़ॉल्ट रूप से None पर सेट है.

पैरामीटर

पैरामीटर ब्यौरा
key ज़रूरी है
कुंजी.
default डिफ़ॉल्ट = कोई नहीं
अगर कुंजी मौजूद नहीं है, तो डिफ़ॉल्ट मान होता है.

अपडेट करें

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

सबसे पहले वैकल्पिक पोज़िशनल तर्क, pairs के साथ शब्दकोश को अपडेट करें, फिर वैकल्पिक कीवर्ड तर्कों के साथ अगर पोज़िशनल तर्क मौजूद है, तो यह कोई इनपुट, एक दोहराने वाला या कोई नहीं होना चाहिए. अगर यह एक सवाल है, तो इसकी कुंजी/वैल्यू के जोड़े इस ऑडिट में डाले जाते हैं. अगर यह फिर से दोहराए जाने की सुविधा है, तो इसे पेयर का एक क्रम (या दोहराए जाने वाले दूसरे क्रम) देना ज़रूरी है. इनमें से हर एक को कुंजी/मान की जोड़ी के तौर पर माना जाता है. हर कीवर्ड तर्क name=value की वजह से नाम/मान का जोड़ा इस निर्देश में डाला जाता है.

पैरामीटर

पैरामीटर ब्यौरा
pairs डिफ़ॉल्ट = []
कोई डिक्शनरी या एंट्री की सूची. एंट्री को सिर्फ़ दो एलिमेंट के साथ जोड़ा या सूची बनाया जाना चाहिए: कुंजी, मान.
kwargs ज़रूरी है
अन्य एंट्री का शब्दकोश.

मान

list dict.values()

मानों की सूची लौटाता है:
{2: "a", 4: "b", 1: "c"}.values() == ["a", "b", "c"]