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 की वैल्यू दिखाता है. अगर 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"]