लिखवाना

dict एक बिल्ट-इन टाइप है. यह असोसिएटिव मैपिंग या डिक्शनरी के बारे में बताता है. डिक्शनरी में, d[k] का इस्तेमाल करके इंडेक्सिंग की जा सकती है. साथ ही, k in d का इस्तेमाल करके सदस्यता की जांच की जा सकती है. इन दोनों कार्रवाइयों में एक जैसा समय लगता है. अनफ़्रीज़ की गई डिक्शनरी में बदलाव किया जा सकता है. इन्हें d[k] को असाइन करके या कुछ तरीकों को कॉल करके अपडेट किया जा सकता है. डिक्शनरी को दोहराया जा सकता है. दोहराने पर, इंसर्शन ऑर्डर में कुंजियों का क्रम मिलता है. किसी मौजूदा कुंजी से जुड़ी वैल्यू को अपडेट करने पर, पुनरावृति के क्रम पर कोई असर नहीं पड़ता. हालांकि, किसी कुंजी को हटाने और फिर से डालने पर, इस पर असर पड़ता है. 
d = {0: "x", 2: "z", 1: "y"}
[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, "y"), (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. बिल्ट-इन dict फ़ंक्शन को कॉल करने पर, तय की गई एंट्री वाली एक डिक्शनरी मिलती है. इन्हें आर्ग्युमेंट के क्रम में डाला जाता है. नाम वाले आर्ग्युमेंट से पहले, पोज़िशनल आर्ग्युमेंट डाले जाते हैं. कॉम्प्रिहेंशन की तरह, डुप्लीकेट कुंजियों का इस्तेमाल किया जा सकता है.
  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 डिक्शनरी में है, तो key की वैल्यू दिखाता है. अगर key डिक्शनरी में नहीं है, तो default की वैल्यू दिखाता है. अगर default नहीं दिया गया है, तो डिफ़ॉल्ट रूप से None लागू हो जाता है, ताकि यह तरीका कभी गड़बड़ी न दिखाए.

पैरामीटर

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

आइटम

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 अगर कुंजी मौजूद नहीं है, तो डिफ़ॉल्ट वैल्यू unbound
डिफ़ॉल्ट वैल्यू होती है.

popitem

tuple dict.popitem()

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

setdefault

unknown dict.setdefault(key, default=None)

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

पैरामीटर

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

अपडेट करें

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

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

पैरामीटर

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

वैल्यू

list dict.values()

यह वैल्यू की सूची दिखाता है:
{2: "a", 4: "b", 1: "c"}.values() == ["a", "b", "c"]