लिखवाना

समस्या की शिकायत करें सोर्स देखें

शब्दकोश पहले से मौजूद एक तरह का शब्द है, जो असोसिएट मैपिंग या डिक्शनरी को दिखाता है. डिक्शनरी में, 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 है
अगर कुंजी नहीं मिलती है, तो यह डिफ़ॉल्ट वैल्यू (कोई भी नहीं) इस्तेमाल करती है.

items

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
होती है. यह डिफ़ॉल्ट वैल्यू के तौर पर सेट होती है.

पॉपआइटम

tuple dict.popitem()

शब्दकोश से पहले (key, value) जोड़े को हटाएं और वापस लाएं. popitem शब्दकोश का गलत इस्तेमाल करके फिर से काम करता है. आम तौर पर, इसे सेट एल्गोरिदम में इस्तेमाल किया जाता है. अगर डिक्शनरी खाली है, तो popitem कॉल नहीं हो पाता.

सेट डिफ़ॉल्ट

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