इन्वेंटरी प्रबंधन

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

Keys हैश करने योग्य और पूरी डिक्शनरी में अद्वितीय होनी चाहिए। की के टाइप में numbers, str या (अपरिवर्तनीय वैल्यू वाले) tuples शामिल हो सकते हैं। की परिवर्तनीय डेटा स्ट्रक्चर नहीं हो सकतीं, जैसे lists, dict या set। Python 3.7 से यह तय है कि dict में एंट्रियाँ जिस क्रम में डाली गई हों, की का क्रम भी वही रहेगा।

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

किसी की को देखकर डिक्शनरी औसतन स्थिर समय में वैल्यू निकाल सकती है (इसमें कोई फ़र्क नहीं पड़ता कि कितनी एंट्रियाँ हैं)। list या array में वैल्यू ढूँढने (जब index की जगह पता न हो) की तुलना में dict काफ़ी ज़्यादा मेमोरी लेती है, लेकिन वैल्यू बहुत तेज़ी से निकालती है। जब चीज़ों का संग्रह बड़ा हो और उन्हें बार-बार पढ़ना और बदलना पड़े, तब डिक्शनरी ख़ास तौर पर काम आती है।

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

डिक्शनरी कई तरीकों से बनाई जा सकती है। सबसे आसान दो तरीके हैं: dict() कंस्ट्रक्टर का उपयोग करना, या dict लिटरल लिखना।

dict() क्लास का कंस्ट्रक्टर

dict() (डिक्शनरी क्लास का कंस्ट्रक्टर) के साथ की-वैल्यू जोड़ों का कोई भी इटरेबल दिया जा सकता है, या <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}

डिक्शनरी से वैल्यू निकालना

आप डिक्शनरी में किसी एंट्री को चौकोर ब्रैकेट ([]) में की लिखकर पढ़ सकते हैं। अगर dict में कोई की मौजूद न हो, तो 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'

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

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

#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}

डिक्शनरी की एंट्रियाँ हटाना (.pop() करना)

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

डिक्शनरी पर लूप चलाना (इटरेशन करना)

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

>>> for key in bear:
>>>     print((key, bear[key])) #this forms a tuple of (key, value) and prints it.
('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 लौटाता है।