लिखवाना

अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है लिखवाने की सुविधा पहले से मौजूद है. यह असोसिएशन की मैपिंग या शब्दकोश को दिखाता है. डिक्शनरी में 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")]

शब्दकोश बनाने के चार तरीके हैं:

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
• बटन
• पॉप
• पॉपआइटम
• setdefault
• अपडेट करें
• वैल्यू

मिटाएं

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)

पैरामीटर

पॉप आइटम

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