लिखवाना

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}

सदस्य

• मिटाएं
• सदस्यता लें
• आइटम
• बटन
• पॉप
• पॉपआइटम
• setdefault
• अपडेट करें
• वैल्यू

मिटाएं

None dict.clear()

डिक्शनरी से सभी आइटम हटाएं.

सदस्यता लें

unknown dict.get(key, default=None)

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

पॉपआइटम

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 से अपडेट किया जाता है. इसके बाद, वैकल्पिक कीवर्ड आर्ग्युमेंट से अपडेट किया जाता है . अगर पोज़िशनल आर्ग्युमेंट मौजूद है, तो वह डिक्शनरी, इटरेबल या None होना चाहिए. अगर यह डिक्शनरी है, तो इसके कुंजी/वैल्यू पेयर, इस डिक्शनरी में डाले जाते हैं. अगर यह इटरेबल है, तो इसमें पेयर का क्रम (या दो की लंबाई वाले अन्य इटरेबल) होना चाहिए. इनमें से हर पेयर को, डाली जाने वाली कुंजी/वैल्यू पेयर के तौर पर माना जाता है. हर कीवर्ड आर्ग्युमेंट name=value से, नाम/वैल्यू पेयर को इस डिक्शनरी में डाला जाता है.

पैरामीटर

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

वैल्यू

list dict.values()

वैल्यू की सूची दिखाता है:

{2: "a", 4: "b", 1: "c"}.values() == ["a", "b", "c"]