लिखवाना

अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है लिखवाने की सुविधा पहले से मौजूद है. यह असोसिएशन की मैपिंग या शब्दकोश को दिखाता है. डिक्शनरी में 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")]

शब्दकोश बनाने के चार तरीके हैं:

डिक्शनरी एक्सप्रेशन {k: v, ...}, तय की गई कुंजी/वैल्यू एंट्री के साथ एक नया डिक्शनरी देता है. इसे एक्सप्रेशन में दिखने के क्रम में डाला जाता है. अगर दो कुंजी के किसी एक्सप्रेशन से एक ही वैल्यू मिलती है, तो जांच नहीं हो पाती.
शब्दकोश पर आधारित {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}
```
पहले से मौजूद dict फ़ंक्शन को कॉल करने पर, ऐसी डिक्शनरी मिलती है जिसमें बताई गई एंट्री होती हैं. इन एंट्री को आर्ग्युमेंट के क्रम में, नाम से पहले पोज़िशनल आर्ग्युमेंट डाला जाता है. जैसा कि समझ में आता है, डुप्लीकेट कुंजियों की अनुमति है.
यूनियन एक्सप्रेशन 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 डिक्शनरी में है, तो key के लिए वैल्यू दिखाता है, नहीं तो default के लिए. अगर 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 कॉल नहीं किया जा सकता.

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"]