लिखवाना

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}

सदस्य

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

मिटाएं

None dict.clear()

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

सदस्यता लें

unknown dict.get(key, default=None)

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

पैरामीटर

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

वैल्यू

list dict.values()

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

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