Exercism पर Python में डिक्शनरी मेथड

डिक्शनरी मेथड के बारे में

Python में dict क्लास डिक्शनरी के साथ काम करने के लिए कई उपयोगी मेथड देती है। इनमें से कुछ dict के कॉन्सेप्ट में बताए जा चुके हैं। यहाँ हम कुछ और मेथड देखेंगे, साथ ही डिक्शनरी पर इटरेशन करने और उन्हें बदलने की कुछ तकनीकें भी।

<dict>.setdefault() बिना KeyError दिए अपने आप नई की जोड़ देता है।
<dict>.fromkeys(<iterable>, <default value>) किसी भी संख्या के इटरेबल से नई dict बनाता है।
<dict>.keys(), <dict>.values() और <dict>.items() सुविधाजनक इटरेटर देते हैं।
sorted(<dict>.items()) से dict की एंट्री का क्रम आसानी से बदला जा सकता है।
<dict_one>.update(<dict_two>) एक dict को दूसरी dict की मिलती-जुलती वैल्यू से अपडेट करता है।
<dict> | <other_dict> और <dict> |= <other_dict> ऑपरेटर के ज़रिए दो dict को मर्ज या अपडेट करते हैं।
reversed(<dict>.keys()), reversed(<dict>.values()) या reversed(<dict>.items()) उल्टे व्यू बनाते हैं।
<dict>.popitem() एक key, value जोड़ा हटाकर लौटाता है।

बिना एरर के जोड़ने के लिए `setdefault()`

डिक्शनरी के कॉन्सेप्ट में पहले बताया गया था कि <dict>.get(<key>, <default value>) किसी मौजूदा value को, या अगर डिक्शनरी में कोई key न मिले तो default value को लौटाता है, और इस तरह KeyError से बचा जाता है। यह उन स्थितियों में अच्छा काम करता है जहाँ आप अतिरिक्त एरर हैंडलिंग नहीं चाहते, लेकिन यह भरोसा भी नहीं कर सकते कि जिस key को आप ढूँढ रहे हैं वह मौजूद होगी।

इसी तरह के "सुरक्षित" (KeyError के बिना) जोड़ने की क्रिया के लिए <dict>.setdefault(<key>, <default value>) मेथड मौजूद है। अगर डिक्शनरी में key मिल जाए, तो <dict>.setdefault(<key>, <default value>) उस value को लौटाता है। अगर key न मिले, तो यह (key, default value) जोड़ा जोड़ देता है और इस्तेमाल के लिए default value लौटाता है।

>>> palette_I = {'Grassy Green': '#9bc400', 'Purple Mountains Majesty': '#8076a3', 'Misty Mountain Pink': '#f9c5bd'}

# Looking for the value associated with key "Rock Brown".The key does not exist, 
# so it is added with the default value, and the value is returned.
>>> palette.setdefault('Rock Brown', '#694605')
'#694605'

# The (key, default value) pair has now been added to the dictionary.
>>> palette_I
{'Grassy Green': '#9bc400', 'Purple Mountains Majesty': '#8076a3', 'Misty Mountain Pink': '#f9c5bd', 'Rock Brown': '#694605'}

किसी इटरेबल से डिक्शनरी भरने के लिए `fromkeys()`

किसी डिक्शनरी को कई तरह की keys और डिफ़ॉल्ट वैल्यू से जल्दी भरने के लिए क्लास मेथड fromkeys(<iterable>, <default value>) keys के किसी इटरेबल पर इटरेशन करके एक नई dict बनाता है। सभी values को दी गई default value पर सेट कर दिया जाएगा:

>>> new_dict = dict.fromkeys(['Grassy Green', 'Purple Mountains Majesty', 'Misty Mountain Pink'], 'fill in hex color here')

{'Grassy Green': 'fill in hex color here',
 'Purple Mountains Majesty': 'fill in hex color here',
 'Misty Mountain Pink': 'fill in hex color here'}

`.popitem()` से (की, वैल्यू) जोड़ा हटाइए और लौटाइए

.popitem() किसी डिक्शनरी से एक (key, value) जोड़ा हटाकर लौटाता है। जोड़े Last-in-First-out (LIFO) क्रम में लौटाए जाते हैं। अगर डिक्शनरी खाली हो, तो popitem() कॉल करने पर KeyError आती है:

>>> palette_I = {'Grassy Green': '#9bc400', 
                 'Purple Mountains Majesty': '#8076a3', 
                 'Misty Mountain Pink': '#f9c5bd'}
>>> palette_I.popitem()
('Misty Mountain Pink', '#f9c5bd')

>>> palette_I.popitem()
('Purple Mountains Majesty', '#8076a3')

>>> palette_I.popitem()
('Grassy Green', '#9bc400')

# All (key, value) pairs have been removed.
>>> palette_I.popitem()
Traceback (most recent call last):
  line 1, in <module>
    palette_I.popitem()
KeyError: 'popitem(): dictionary is empty'

व्यू के ज़रिए डिक्शनरी की एंट्री पर इटरेशन कीजिए

.keys(), .values() और .items() मेथड किसी डिक्शनरी के इटरेबल व्यू लौटाते हैं।

इन व्यू की मदद से एंट्री पर आसानी से लूप किया जा सकता है, बिना उन्हें बदले। व्यू डायनामिक भी होते हैं। जब नीचे की डिक्शनरी का डेटा बदलता है, तो जुड़ा हुआ view object उस बदलाव को दिखाता है:

>>> palette_I = {'Grassy Green': '#9bc400', 
                 'Purple Mountains Majesty': '#8076a3', 
                 'Misty Mountain Pink': '#f9c5bd'}

# Using .keys() returns a list of keys.
>>> palette_I.keys()
dict_keys(['Grassy Green', 'Purple Mountains Majesty', 'Misty Mountain Pink'])

# Using .values() returns a list of values.
>>> palette_I.values()
dict_values(['#9bc400', '#8076a3', '#f9c5bd'])

# Using .items() returns a list of (key, value) tuples.
>>> palette_I.items()
dict_items([('Grassy Green', '#9bc400'), ('Purple Mountains Majesty', '#8076a3'), ('Misty Mountain Pink', '#f9c5bd')])

# Views are dynamic.  Changing values in the dict 
# changes all of the associated views.
>>> palette_I['Purple Mountains Majesty'] = (128, 118, 163)
>>> palette_I['Deep Red'] = '#932432'

>>> palette_I.values()
dict_values(['#9bc400', (128, 118, 163), '#f9c5bd', '#932432'])

>>> palette_I.keys()
dict_keys(['Grassy Green', 'Purple Mountains Majesty', 'Misty Mountain Pink', 'Deep Red'])

>>> palette_I.items()
dict_items([('Grassy Green', '#9bc400'), ('Purple Mountains Majesty', (128, 118, 163)), ('Misty Mountain Pink', '#f9c5bd'), ('Deep Red', '#932432')])

`.keys()`, `.values()` और `.items()` पर और जानकारी

Python 3.7+ में dicts एंट्री जिस क्रम में जोड़ी गई थीं वही क्रम बनाए रखती हैं, जिससे .keys(), .values() या .items() इस्तेमाल करते समय First-in, First-out (FIFO) इटरेशन मिलता है।

Python 3.8+ में व्यू उलटे भी किए जा सकते हैं। इससे keys, वैल्यू या (key, value) जोड़ों पर reversed(<dict>.keys()), reversed(<dict>.values()) या reversed(<dict>.items()) इस्तेमाल करके Last-in, First-out (LIFO) क्रम में इटरेशन किया जा सकता है:

>>> palette_II = {'Factory Stone Purple': '#7c677f', 
                  'Green Treeline': '#478559', 
                  'Purple baseline': '#161748'}
>>> for item in palette_II.items():
...     print(item)
...
('Factory Stone Purple', '#7c677f')
('Green Treeline', '#478559')
('Purple baseline', '#161748')

>>> for item in reversed(palette_II.items()):
...     print(item)
...
('Purple baseline', '#161748')
('Green Treeline', '#478559')
('Factory Stone Purple', '#7c677f')

`.update()` से डिक्शनरी मिलाइए

<dict_one>.update(<dict_two>) से दो डिक्शनरी मिलाई जा सकती हैं। यह मेथड <dict_two> के (key,value) जोड़े लेकर उन्हें <dict_one> में लिख देता है:

>>> palette_I = {'Grassy Green': '#9bc400',
                 'Purple Mountains Majesty': '#8076a3',
                  'Misty Mountain Pink': '#f9c5bd'}
>>> palette_II = {'Factory Stone Purple': '#7c677f',
                  'Green Treeline': '#478559',
                  'Purple Baseline': '#161748'}

>>> palette_I.update(palette_II)

# Note that new items from palette_II are added.
>>> palette_I
{'Grassy Green': '#9bc400', 'Purple Mountains Majesty': '#8076a3', 'Misty Mountain Pink': '#f9c5bd', 'Factory Stone Purple': '#7c677f', 'Green Treeline': '#478559', 'Purple Baseline': '#161748'}

जहाँ दोनों डिक्शनरी की keys मिलती हैं, वहाँ dict_one की value को dict_two की उससे जुड़ी value ओवरराइट कर देती है:

>>> palette_I = {'Grassy Green': '#9bc400', 
                 'Purple Mountains Majesty': '#8076a3', 
                 'Misty Mountain Pink': '#f9c5bd', 
                 'Factory Stone Purple': '#7c677f', 
                 'Green Treeline': '#478559', 
                 'Purple baseline': '#161748'}
                   
>>> palette_III = {'Grassy Green': (155, 196, 0), 
                   'Purple Mountains Majesty': (128, 118, 163),
                   'Misty Mountain Pink': (249, 197, 189)}
>>> palette_I.update(palette_III)

# Overlapping values in palette_I are replaced with 
# values from palette_III
>>> palette_I
{'Grassy Green': (155, 196, 0),
  'Purple Mountains Majesty': (128, 118, 163), 
  'Misty Mountain Pink': (249, 197, 189), 
  'Factory Stone Purple': '#7c677f', 
  'Green Treeline': '#478559', 'Purple baseline': '#161748'}

यूनियन (`|` और `|=`) ऑपरेटर से डिक्शनरी मर्ज या अपडेट कीजिए

Python 3.9 में dicts को मर्ज करने का एक और तरीका आता है: union ऑपरेटर। dict_one | dict_two एक नई डिक्शनरी बनाता है, जो dict_one और dict_two के (key, value) जोड़ों से बनी होती है। जब दोनों डिक्शनरी में एक ही keys हों, तो dict_two की वैल्यू को प्राथमिकता मिलती है।

>>> palette_I = {'Grassy Green': '#9bc400', 
                 'Purple Mountains Majesty': '#8076a3', 
                 'Misty Mountain Pink': '#f9c5bd'}

>>> palette_II = {'Factory Stone Purple': '#7c677f', 
                  'Green Treeline': '#478559', 
                  'Purple baseline': '#161748'}

>>> new_dict = palette_I | palette_II
>>> new_dict
...
{'Grassy Green': '#9bc400',
 'Purple Mountains Majesty': '#8076a3',
 'Misty Mountain Pink': '#f9c5bd',
 'Factory Stone Purple': '#7c677f',
 'Green Treeline': '#478559',
 'Purple baseline': '#161748'}

dict_one |= other का व्यवहार <dict_one>.update(<other>) जैसा ही है, लेकिन यहाँ other या तो एक dict हो सकता है या (key, value) जोड़ों का कोई इटरेबल:

>>> palette_III = {'Grassy Green': (155, 196, 0),
                   'Purple Mountains Majesty': (128, 118, 163),
                   'Misty Mountain Pink': (249, 197, 189)}
>>> new_dict |= palette_III
>>> new_dict
...
{'Grassy Green': (155, 196, 0),
'Purple Mountains Majesty': (128, 118, 163),
'Misty Mountain Pink': (249, 197, 189),
'Factory Stone Purple': '#7c677f',
'Green Treeline': '#478559',
'Purple baseline': '#161748'}

डिक्शनरी सॉर्ट कीजिए

डिक्शनरी में सॉर्ट करने का कोई अंतर्निहित मेथड नहीं होता। लेकिन किसी dict के व्यू को अंतर्निहित फंक्शन sorted() से .items() के साथ सॉर्ट किया जा सकता है। फिर उस सॉर्ट किए गए व्यू से एक नई डिक्शनरी बनाई जा सकती है। जब तक कोई सॉर्ट की न दी जाए, डिफ़ॉल्ट सॉर्ट डिक्शनरी की keys पर होता है।

# Default ordering for a dictionary is last in, first out (LIFO).
>>> color_palette = {'Grassy Green': '#9bc400', 
                    'Purple Mountains Majesty': '#8076a3', 
                    'Misty Mountain Pink': '#f9c5bd', 
                    'Factory Stone Purple': '#7c677f', 
                    'Green Treeline': '#478559', 
                    'Purple baseline': '#161748'}
 
 
# The default sort order for a dictionary uses the keys.
>>> sorted_palette = dict(sorted(color_palette.items()))
>>> sorted_palette
{'Factory Stone Purple': '#7c677f',
 'Grassy Green': '#9bc400',
 'Green Treeline': '#478559',
 'Misty Mountain Pink': '#f9c5bd',
 'Purple Mountains Majesty': '#8076a3',
 'Purple baseline': '#161748'}


# A sort key can be provided in the form
# of an anonymous function (lambda). 
>>> value_sorted_palette = dict(sorted(color_palette.items(), key=lambda color: color[1]))
>>> value_sorted_palette
{'Purple baseline': '#161748',
 'Green Treeline': '#478559',
 'Factory Stone Purple': '#7c677f',
 'Purple Mountains Majesty': '#8076a3',
 'Grassy Green': '#9bc400',
 'Misty Mountain Pink': '#f9c5bd'}

डिक्शनरी की की और वैल्यू की अदला-बदली कीजिए

किसी डिक्शनरी में की और वैल्यू की भरोसेमंद अदला-बदली में थोड़ी मेहनत लगती है, लेकिन यह dict.items() वाले loop से या डिक्शनरी कॉम्प्रिहेंशन से की जा सकती है। सुरक्षित अदला-बदली के लिए ज़रूरी है कि dict की keys और वैल्यू दोनों हैशेबल हों।

color_reference = {'Purple Mountains Majesty': '#8076a3',
                   'Misty Mountain Pink': '#f9c5bd',
                   'Factory Stone Purple': '#7c677f',
                   'Green Treeline': '#478559',
                   'Purple baseline': '#161748'}

# Creating a new dictionary to hold the swapped entries.
>>> swapped_color_reference = {}

# Iterating through the dictionary, using values as keys.
>>> for key, value in color_reference.items():
...     swapped_color_reference[value] = key

>>> swapped_color_reference
{'#8076a3': 'Purple Mountains Majesty',
 '#f9c5bd': 'Misty Mountain Pink',
 '#7c677f': 'Factory Stone Purple',
 '#478559': 'Green Treeline',
 '#161748': 'Purple baseline'}

 
# A dictionary comprehension can also be used to swap entries.
>>> swapped = {value: key for key, value in
               color_reference.items()}
>>> swapped
{'#8076a3': 'Purple Mountains Majesty',
 '#f9c5bd': 'Misty Mountain Pink',
 '#7c677f': 'Factory Stone Purple',
 '#478559': 'Green Treeline',
 '#161748': 'Purple baseline'}

अगर dict में रखी वैल्यू अनोखी न हों, तो की और वैल्यू की अदला-बदली से पहले कुछ अतिरिक्त जाँचें ज़रूरी हो जाती हैं:

# Things become more complicated if there are duplicates in 
# potential key values.This dict is arranged by hex, RGB, and HSL
# keys, but values repeat.
>>> extended_colors = {'#8076a3': 'Purple Mountains Majesty',
                       (128, 118, 163): 'Purple Mountains Majesty',
                       (21, 28, 0, 36): 'Purple Mountains Majesty',
                       '#f9c5bd': 'Misty Mountain Pink',
                       (249, 197, 189): 'Misty Mountain Pink',
                       (0, 21, 24, 2): 'Misty Mountain Pink',
                       '#7c677f': 'Factory Stone Purple',
                       (124, 103, 127): 'Factory Stone Purple',
                       (2, 19, 0, 50): 'Factory Stone Purple',
                       '#478559': 'Green Treeline',
                       (71, 133, 89): 'Green Treeline',
                       (47, 0, 33, 48): 'Green Treeline'}
                                
# New empty dictionary for holding swapped entries.
>>> consolidated_colors = {}

# Iterating over (key, value) pairs using .items()
>>> for key, value in extended_color_reference.items():
...    if value in consolidated_colors: # <--Check if key has already been created.
...        consolidated_colors[value].append(key)
...    else:
...        consolidated_colors[value] = [key]  # <--Create a value list with the former key in it.

>>> consolidated_colors
{'Purple Mountains Majesty': ['#8076a3', (128, 118, 163), (21, 28, 0, 36)],
 'Misty Mountain Pink': ['#f9c5bd', (249, 197, 189), (0, 21, 24, 2)],
 'Factory Stone Purple': ['#7c677f', (124, 103, 127), (2, 19, 0, 50)],
 'Green Treeline': ['#478559', (71, 133, 89), (47, 0, 33, 48)]}

डिक्शनरी और उन पर काम करने के मेथड की विस्तृत जानकारी के लिए आधिकारिक ट्यूटोरियल और आधिकारिक लाइब्रेरी संदर्भ बढ़िया शुरुआती जगह हैं।

Real Python और Finxter पर भी Python डिक्शनरी पर बहुत विस्तृत लेख हैं।

सॉर्ट करने के बारे में और जानने के लिए Python डॉक्स में Sorting HOW TO देखिए।

और जानिए

GitHub के ज़रिए संपादित करें

भाषा ट्रैक

Jiki के साथ कोड करना सीखिए

आपकी यात्रा

आपके पसंदीदानया

Exercism के खास फायदे

कम्युनिटी वीडियो

संक्षिप्त परिचय शृंखला

इंटरव्यू और कहानियाँ

Discord

फोरम

शुरुआत करें

मेंटर बनें

डॉक्स

योगदानकर्ता

अनुवादकनया

दान करें

Exercism के बारे में

हमारा प्रभाव

GitHub सिंकरनया

इनसाइडर्स

डिक्शनरी मेथड के बारे में

बिना एरर के जोड़ने के लिए setdefault()

किसी इटरेबल से डिक्शनरी भरने के लिए fromkeys()

.popitem() से (की, वैल्यू) जोड़ा हटाइए और लौटाइए

व्यू के ज़रिए डिक्शनरी की एंट्री पर इटरेशन कीजिए

.keys(), .values() और .items() पर और जानकारी

.update() से डिक्शनरी मिलाइए

यूनियन (| और |=) ऑपरेटर से डिक्शनरी मर्ज या अपडेट कीजिए