लिखवाना

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