लिखवाना

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")]

डिक्शनरी बनाने के चार तरीके हैं:

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}

सदस्य

• साफ़ करें
• get
• 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"]