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 वैल्यू दिखाता है. अगर default न दिया गया हो, तो यह डिफ़ॉल्ट रूप से None होता है, ताकि यह तरीका कभी कोई गड़बड़ी न करे.
पैरामीटर
| पैरामीटर | जानकारी |
|---|---|
key
|
ज़रूरी है ध्यान देने वाली कुंजी. |
default
|
डिफ़ॉल्ट = कोई नहीं अगर कुंजी नहीं मिलती है, तो इस्तेमाल करने के लिए डिफ़ॉल्ट वैल्यू (कोई नहीं के बजाय). |
आइटम
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
|
डिफ़ॉल्ट = अनबाउंड अगर कुंजी मौजूद नहीं है, तो डिफ़ॉल्ट वैल्यू. |
पॉप-आइटम
tuple dict.popitem()
(key, value) के पहले जोड़े को डिक्शनरी से हटाएं और दिखाएं. popitem, डिक्शनरी में ज़्यादा नुकसान पहुंचाने के लिए मददगार है. इसका इस्तेमाल, अक्सर सेट एल्गोरिदम में किया जाता है. अगर शब्दकोश खाली है, तो popitem कॉल नहीं हो पाएगा.
डिफ़ॉल्ट सेट करें
unknown dict.setdefault(key, default=None)अगर डिक्शनरी में
key है, तो उसकी वैल्यू दिखाएं. अगर नहीं, तो default की वैल्यू वाली कुंजी डालें और default दिखाएं. default का डिफ़ॉल्ट मान None होता है.
पैरामीटर
| पैरामीटर | जानकारी |
|---|---|
key
|
ज़रूरी कुंजी. |
default
|
डिफ़ॉल्ट = कोई नहीं अगर कुंजी मौजूद नहीं है, तो डिफ़ॉल्ट वैल्यू. |
अपडेट करो
None dict.update(pairs=[], **kwargs)पहले, वैकल्पिक पोज़िशनल आर्ग्युमेंट,
pairs, फिर वैकल्पिक कीवर्ड आर्ग्युमेंट के साथ शब्दकोश अपडेट करता है
अगर पोज़िशनल आर्ग्युमेंट मौजूद होता है, तो इस टेक्स्ट को अंग्रेज़ी में लिखा जा सकता है, इसमें बदलाव किया जा सकता है या इनमें से किसी का भी इस्तेमाल नहीं किया जा सकता.
अगर यह कोई शब्द है, तो इसके बटन या वैल्यू के जोड़े इस शब्दकोश में डाले जाते हैं. अगर बार-बार दोहराए जाने वाले इवेंट हैं, तो उन्हें जोड़े गए क्रम (या लंबाई की दूसरी वैल्यू) के क्रम को शामिल करना होगा. इनमें से हर एक को कुंजी/वैल्यू पेयर डालने के लिए माना जाएगा.
हर कीवर्ड के तर्क name=value की वजह से नाम/वैल्यू का जोड़ा इस शब्दकोश में डाला जाता है.
पैरामीटर
| पैरामीटर | जानकारी |
|---|---|
pairs
|
डिफ़ॉल्ट = [] शब्दकोश या एंट्री की सूची. एंट्री सिर्फ़ दो एलिमेंट वाली ट्यूल या सूचियां होनी चाहिए: की, वैल्यू. |
kwargs
|
ज़रूरी है अतिरिक्त एंट्री की डिक्शनरी. |
वैल्यू
list dict.values()वैल्यू की सूची दिखाता है:
{2: "a", 4: "b", 1: "c"}.values() == ["a", "b", "c"]