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")]
डिक्शनरी बनाने के चार तरीके हैं:
- डिक्शनरी एक्सप्रेशन
{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है अगर कोई कुंजी नहीं मिलती है, तो 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"]