लिखवाना

किसी समस्या की शिकायत करें सोर्स देखें रात · 7.4 को अपनाएं. 7.3 · 7.2 · 7.1 · 7.0 · 6.5

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

सदस्य

मिटाएं

None dict.clear()

डिक्शनरी से सभी आइटम हटाएं.

रिवॉर्ड पाएँ

unknown dict.get(key, default=None)

अगर key डिक्शनरी में है, तो key के लिए वैल्यू दिखाता है, नहीं तो default के लिए. अगर default नहीं दिया गया है, तो यह डिफ़ॉल्ट रूप से None पर सेट हो जाता है, ताकि इस तरीके से कभी भी गड़बड़ी न दिखे.

पैरामीटर

पैरामीटर ब्यौरा
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)

डायक्शनरी से 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, उसके बाद वैकल्पिक कीवर्ड तर्क के साथ अपडेट करता है अगर पोज़िशनल आर्ग्युमेंट मौजूद है, तो यह एक लिखवाने वाला, बार-बार इस्तेमाल किया जा सकने वाला या कोई नहीं होना चाहिए. अगर यह एक डिक्शनरी है, तो इसके की/वैल्यू पेयर को इस डिक्शनरी में डाला जाता है. अगर इसे बार-बार इस्तेमाल किया जा सकता है, तो इसमें जोड़े जाने वाले जोड़ों का क्रम (या लंबाई 2 की अन्य बार-बार दोहराए जा सकने वाली चीज़ें) देना ज़रूरी है. इनमें से हर एक को शामिल किए जाने के लिए, की/वैल्यू पेयर माना जाएगा. हर कीवर्ड आर्ग्युमेंट name=value की वजह से, इस डिक्शनरी में नाम/वैल्यू पेयर डाला जाता है.

पैरामीटर

पैरामीटर ब्यौरा
pairs डिफ़ॉल्ट तौर पर, []
होता है शब्दकोश या एंट्री की सूची. एंट्री में दो एलिमेंट की संख्या या सूची होनी चाहिए: कुंजी, वैल्यू.
kwargs ज़रूरी है
अतिरिक्त एंट्री की डिक्शनरी.

मान

list dict.values()

वैल्यू की सूची दिखाता है:
{2: "a", 4: "b", 1: "c"}.values() == ["a", "b", "c"]