लिखवाना

शब्दकोश पहले से मौजूद होता है, जो असोसिएशन की मैपिंग या शब्दकोश को दिखाता है. डिक्शनरी में, 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}

सदस्य

• साफ़ करें
• पाएं
• items
• कुंजियां
• पॉप
• popitem
• setdefault
• अपडेट करें
• values

मिटाएं

None dict.clear()

रिवॉर्ड पाएँ

unknown dict.get(key, default=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)

पैरामीटर

popitem

tuple dict.popitem()

setdefault

unknown dict.setdefault(key, default=None)

पैरामीटर

अपडेट करें

None dict.update(pairs=[], **kwargs)

पैरामीटर

वैल्यू

list dict.values()

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