डिक्ट में

डिक्ट के बारे में

Python में डिक्शनरी (dict) एक डेटा स्ट्रक्चर है, जो हैशेबल की को वैल्यू से जोड़ती है। दूसरी प्रोग्रामिंग भाषाओं में इसे रीसाइज़ होने वाली हैश टेबल, हैशमैप या एसोसिएटिव ऐरे कहा जाता है। डिक्शनरी ही Python का एकमात्र बिल्ट-इन मैपिंग टाइप है।

keys हैशेबल और पूरी डिक्शनरी में अद्वितीय होनी चाहिए। की के टाइप में number, str या इम्यूटेबल वैल्यू वाले tuple शामिल हो सकते हैं। इनमें list, dict या set जैसे म्यूटेबल डेटा स्ट्रक्चर नहीं हो सकते। Python 3.7 से यह तय है कि dict में की का क्रम वही रहेगा, जिस क्रम में एंट्री जोड़ी गई थीं।

values किसी भी डेटा टाइप या स्ट्रक्चर की हो सकती हैं। वैल्यू मनमाने ढंग से नेस्टेड भी हो सकती हैं, यानी उनमें ऐरे के अंदर ऐरे, उप-डिक्शनरी और दूसरे कस्टम या मिश्रित डेटा स्ट्रक्चर हो सकते हैं।

डिक्शनरी में किसी key के ज़रिए value निकालने पर औसतन हर बार लगभग एक जैसा समय लगता है, चाहे एंट्री कितनी भी हों। किसी list या ऐरे में (बिना index जाने) वैल्यू ढूँढने की तुलना में dict कहीं ज़्यादा मेमोरी लेती है, लेकिन वैल्यू बहुत तेज़ी से निकाल देती है।

जहाँ चीज़ों का संग्रह बड़ा हो और उसे बार-बार देखना और बदलना पड़े, वहाँ डिक्शनरी खास तौर पर काम आती है।

डिक्शनरी बनाना

डिक्शनरी कई अलग-अलग तरीकों से बनाई जा सकती है, जैसे:

• fromkeys() क्लास मेथड इस्तेमाल करके।
• डिक्शनरी कॉम्प्रिहेंशन से।
• अनपैकिंग (**) के ज़रिए दो डिक्शनरी मर्ज करके।
• | (अपडेट) ऑपरेटर के ज़रिए डिक्शनरी मर्ज करके।
• पहले से बनी खाली dict में लूप चलाकर एक-एक करके एंट्री जोड़कर।

सबसे सीधे तरीके दो हैं: डिक्शनरी कंस्ट्रक्टर और डिक्शनरी लिटरल।

डिक्शनरी कंस्ट्रक्टर

dict() (यानी dict क्लास का कंस्ट्रक्टर) को key, value जोड़ों के किसी भी इटरेबल के साथ इस्तेमाल किया जा सकता है। इसे <name>=<value> आर्गुमेंट की एक श्रृंखला के साथ भी कॉल किया जा सकता है:

# Passing a list of key,value tuples.
>>> wombat = dict([('name', 'Wombat'),
...              ('speed', 23),
...              ('land_animal', True)])
{'name': 'Wombat', 'speed': 23, 'land_animal': True}


# Using key=value arguments.
>>> bear = dict(name="Black Bear",
...             speed=40,
...             land_animal=True)
{'name': 'Black Bear', 'speed': 40, 'land_animal': True}

कंस्ट्रक्टर के इस्तेमाल के और भी रूप और विकल्प dict का डॉक्यूमेंटेशन में बताए गए हैं।

डिक्शनरी लिटरल

डिक्शनरी को सीधे डिक्शनरी लिटरल के रूप में भी लिखा जा सकता है। इसमें घुंघराले ब्रैकेट ({}) के अंदर key : value जोड़े रखे जाते हैं। {} के अंदर की एंट्री अलग-अलग लाइनों पर भी लिखी जा सकती हैं:

>>> whale = {"name": "Blue Whale", 
             "speed": 35, 
             "land_animal": False}
{'name': 'Blue Whale', 'speed': 35, 'land_animal': False}

>>> wombat = {'name': 'Wombat',
              'speed': 23,
              'land_animal': True,
              'color': 'Brindle'}

>>> wombat
{'name': 'Wombat', 'speed': 23, 'land_animal': True, 'color': 'Brindle'}

नेस्टेड डिक्शनरी

डिक्शनरी को मनमाने ढंग से नेस्टेड किया जा सकता है:

animals = {
    "Real" : {
        "Winged" : {
            "Sparrow" : {'name': 'sparrow','speed': 12, 'land_animal': True},
            "Kestrel" : {'name': 'kestrel', 'speed': 15, 'land_animal': True}
           },
        "Legged" : {
            "Wombat" : {'name': 'Wombat', 'speed': 23, 'land_animal': True},
            "Black Bear": {'name': 'Black Bear', 'speed': 40, 'land_animal': True},
            "Polecat" : {'name': 'Polecat', 'speed': 15, 'land_animal': True}
           },
        "Other" :  {
            "Whale" : {'name': 'Blue Whale', 'speed': 35, 'land_animal': False},
            "Orca" : {'name': 'Orca', 'speed': 45, 'land_animal': False},
            "Snake" : {'name': 'Python', 'speed': 25, 'land_animal': True}
            }
        },
        
    "Imaginary": {
        "Winged" : {
            "Dragon" : {'name': 'Fire Dragon','speed': 100, 'land_animal': True},
            "Phoenix" : {'name': 'Phoenix', 'speed': 1500, 'land_animal': True}
            },
        "Legged" : {
            "Sphinx" : {'name': 'Sphinx','speed': 10, 'land_animal': True},
            "Minotaur" : {'name': 'Minotaur', 'speed': 5, 'land_animal': True}
            },
        "Other" :  {}
        }
   }

dict से वैल्यू निकालना

डिक्शनरी में किसी value तक चौकोर ब्रैकेट के अंदर key लिखकर पहुँचा जा सकता है। अगर वह की डिक्शनरी में मौजूद न हो, तो KeyError मिलती है:

>>> bear["speed"]
40

>>> bear["color"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'color'

एंट्री को get(<key>, <default value>) मेथड से निकालने पर KeyError से बचा जा सकता है:

>>> bear.get("color", 'not found')
'not found'

नेस्टेड डिक्शनरी की एंट्री निकालना

नेस्टेड डिक्शनरी की एंट्री तक पहुँचने के लिए एक के बाद एक ब्रैकेट लगाइए। अगर कोई की न मिले, तो आम तौर पर KeyError आती है:

# Using the animals nested dictionary.
>>> animals["Real"]["winged"]["Kestrel"]["speed"]
15

>>> animals["Imaginary"]["winged"]["Kestrel"]["speed"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Kestrel'

KeyError से बचने के लिए .get() इस्तेमाल किया जा सकता है, लेकिन .get() की कॉल्स को एक के बाद एक जोड़कर ही लिखना होगा:

# Using the animals nested dictionary.
# Note the use of parenthesis to enable placing the 
# .get() calls on separate lines.
>>> (animals.get("Imaginary", {})
            .get("Legged", {})
            .get("Sphinx", {})
            .get("Color", "I have no idea!"))
'I have no idea!'

डिक्शनरी की वैल्यू बदलना या जोड़ना

किसी एंट्री की value उसकी key को नई वैल्यू असाइन करके बदली जा सकती है:

# Assigning the value "Grizzly Bear" to the name key.
>>> bear["name"] = "Grizzly Bear"
{'name': 'Grizzly Bear', 'speed': 40, 'land_animal': True}

>>> whale["speed"] = 25
{'name': 'Blue Whale', 'speed': 25, 'land_animal': False}

नए key:value जोड़े भी इसी तरह जोड़े जा सकते हैं:

# Adding a new "color" key with a new "tawney" value.
>>> bear["color"] = 'tawney'
{'name': 'Grizzly Bear', 'speed': 40, 'land_animal': True, 'color': 'tawney'}

>>> whale["blowholes"] = 1
{'name': 'Blue Whale', 'speed': 25, 'land_animal': False, 'blowholes': 1}

डिक्शनरी की एंट्री हटाना (पॉप करना और del)

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

# Using .pop() removes both the key and value, returning the value.
>>> bear.pop("name")
'Grizzly Bear'


# The "name" key is now removed from the dictionary.
# Attempting .pop() a second time will throw a KeyError.
>>> bear.pop("name")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'name'


# Using a default argument with .pop() will 
# prevent a KeyError from a missing key.
>>> bear.pop("name", "Unknown")
'Unknown'

एक या एक से अधिक एंट्री हटाने के लिए del स्टेटमेंट भी इस्तेमाल किया जा सकता है। अगर हटाई जाने वाली एंट्री डिक्शनरी में न मिले, तो KeyError आती है:

>>> wombat = {'name': 'Wombat',
              'speed': 23,
              'land_animal': True,
              'color': 'Brindle',
              'talent': 'Singing',
              'size': 'small'}

# Remove a single entry from the dictionary.
>>> del wombat["color"]
>>> wombat
{'name': 'Wombat', 'speed': 23, 'land_animal': True, 'talent': 'Singing', 'size': 'small'}


# Remove multiple entries from the dictionary.
>>> del wombat["talent"], wombat["size"]
>>> wombat
{'name': 'Wombat', 'speed': 23, 'land_animal': True}


# Attempting a deletion of a non-existent key raises a KeyError
>>> del wombat["number_of_legs"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'number_of_legs'

डिक्शनरी पर लूप चलाना

for item in dict या while item से डिक्शनरी पर लूप चलाने पर डिफ़ॉल्ट रूप से keys पर इटरेशन होता है। उसी लूप के अंदर चौकोर ब्रैकेट इस्तेमाल करके values तक भी पहुँचा जा सकता है:

>>> for key in bear:
...     print((key, bear[key])) # <--This prints a tuple of (key, value).
('name', 'Black Bear')
('speed', 40)
('land_animal', True)

आप .items() मेथड भी इस्तेमाल कर सकते हैं, जो (key, value) टपल लौटाता है:

# dict.items() forms (key, value tuples) that can be 
# unpacked and iterated over.
>>> for key, value in whale.items():
...     print(key, ":", value)
name : Blue Whale
speed : 25
land_animal : False
blowholes : 1

इसी तरह .keys() keys लौटाता है और .values() values लौटाता है।

Python में डिक्शनरी की विस्तृत जानकारी के लिए आधिकारिक डॉक्यूमेंटेशन शुरुआत करने की बहुत अच्छी जगह है। आप W3-Schools का ट्यूटोरियल भी देख सकते हैं।

डिक्शनरी की कार्यक्षमता बढ़ाना: collections मॉड्यूल

array मॉड्यूल Python के स्टैंडर्ड कलेक्शन डेटा टाइप (dict, set, list, tuple) में कुछ खास कार्यक्षमता जोड़ता है। डिक्शनरी पर आधारित तीन सबसे काम के क्लास ये हैं:

• Counter चीज़ों की गिनती खुद करता है और उन्हें एक dict में लौटाता है, जिसमें चीज़ें की होती हैं और उनकी गिनती वैल्यू।
• OrderedDict में डिक्शनरी की एंट्री का क्रम लगाने के लिए खास मेथड हैं।
• defaultdict तब डिफ़ॉल्ट वैल्यू सेट करने के लिए एक फैक्ट्री मेथड इस्तेमाल करता है, जब किसी एंट्री को निकालते या असाइन करते समय key न मिले।