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