Dictionary Use Cases

Dictionary Use Cases – जब हम Dictionaries को Use करते हैं तब हमें कुछ बातों को ध्‍यान में रखना जरूरी होता है क्‍योंकि Dictionary, Lists की तुला में काफी अलग तरीके से Implement होता है। Python में Dictionaries वास्‍तव में Mappings होते हैं, Sequence नहीं क्‍योंकि Dictionary में Exist विभिन्‍न Data Items का कोई क्रम नहीं होता।

इसीलिए जो Operations, Sequence Concepts पर आधारित होते हैं, उन्‍हें Dictionary पर Apply नहीं किया जा सकता। जैसे कि Concatenation और Slicing क्‍योंकि इन दोनों Operations को Perform होने के लिए Sequential Data Items की जरूरत होती है। अत: किसी Dictionary पर इन Operations को Apply करने का प्रयास भी नहीं करना चाहिए और यदि हम इन Operations को Dictionaries के साथ Apply करने का प्रयास करते हैं, तो Python ऐसे Codes को Run करते समय Error ही Return करता है।

जिस समय हम Dictionary Create करते हैं, उसी समय हम उस Dictionary में Data Items को Dictionary Literal Notation के माध्‍यम से Initialize भी कर सकते हैं या फिर हम हमारी जरूरत के अनुसार Program के Runtime में किसी Key के साथ किसी Value को Assign कर सकते हैं। इन दोनों ही तरीकों का End Result समान ही होता है।

यानी जरूरी नहीं है कि हम Dictionary Object Create करते ही उसे Data Items से Initialize भी करें। हम हमारी जरूरत के अनुसार एक Blank Dictionary भी Create कर सकते हैं और फिर Program के Runtime में Dynamically भी Key:Value Pairs को उस पहले से Created Dictionary Object में Assign भी कर सकते हैं।

अभी तक हमने जितने भी Examples Create किए हैं, उन सभी में हमने Dictionary Keys के रूप में String Type को ही Use किया है। लेकिन ऐसा जरूरी नहीं है। हम किसी भी Immutable Object को Key की तरह Use कर सकते हैं।

उदाहरण के लिए यदि हम चाहें तो Strings के स्‍थान पर हम Integer Core Type को भी Dictionary Key की तरह Use करते हुए Dictionary को List की तरह Treat कर सकते हैं अथवा Compound Key Values जैसे कि Date अथवा IP Address जैसे Data को Represent करने वाले Tuple Core Type को भी Dictionary Key की तरह Use कर सकते हैं।

हम किसी User Defined Class के Instant Object को भी Dictionary Key की तरह Use कर सकते हैं। हालांकि जब हम इस तरह के Instant Object को Key की तरह Use करते हैं, तब ये जरूरी होता है कि हमने Proper Class Methods को Define किया हो, क्‍योंकि इन Methods के माध्‍यम से Python को इस बात का Instruction देना जरूरी होता है उन Instances की Values “Hashable” हैं इसलिए Change नहीं होंगे।

क्‍योंकि हम किसी भी Changing Value वाले किसी भी तरह के Mutable Objects जैसे कि List, Set और अन्‍य Dictionary Object को Dictionary Key की तरह Use नहीं कर सकते, लेकिन Values की तरह हम किसी भी Core Type या User Defined Type के Object को Use कर सकते हैं।

जब हम Dictionary Create करते हैं, तब हम Blank Dictionary Create करके किसी भी Integer Number को Key की तरह Specify करते हुए किसी Value को उस Key के साथ Assign कर सकते हैं, लेकिन ही काम हम किसी List के साथ नहीं कर सकते क्‍योंक‍ि List में हम उसी Index Position पर किसी Value को Place कर सकते हैं, जो कि पहले से Exist हो। हम किसी Non-Existing Out of Range Index Position पर किसी Value को Dynamically Assign नहीं कर सकते। इस Concept को बेहतर तरीके से समझने के लिए निम्‍नानुसार एक Example Create किया जा सकता है-

[code]
FileName: DataItemDynamicAssignment.py
# Create Empty Dictionary
dicNames = {}

# Assign Key:Value Paired Data Item
dicNames[1] = 'KRISHNA'
dicNames[2] = 'MURARI'
dicNames[9] = 'BIHARI'

# Display the Dictionary Data Items
print("Dynamically Added Data Items of the Dictionary: \n", dicNames)
print()

# Create Empty List
lstNames = []

# Assign Data Items into the List
lstNames[0] = 'KRISHNA'

#lstNames[1] = 'MURARI'
#lstNames[9] = 'BIHARi'
# Display the List Data Items

print("Dynamically Added Data Items of the Dictionary: \n", lstNames)

Output
Dynamically Added Data Items of the Dictionary:
 {1: 'KRISHNA', 2: 'MURARI', 9: 'BIHARI'}
Traceback (most recent call last):
  File ".\DataItemDynamicAssignment.py", line 18, in <module>
    lstNames[0] = 'KRISHNA'
IndexError: list assignment index out of range
[/code]

जैसाकि इस Example में हम देख सकते हैं कि हम किसी Dictionary में तो Key के रूप में Integer Value को Use कर सकते हैं और Dynamically उन Integer Keys के साथ Values को भी Associate कर सकते हैं, लेकिन हम इसी तरह की समान प्रक्रिया को List पर Apply नहीं कर सकते, क्‍योंकि List में हम जब भी किसी Index Position पर किसी Value को Assign करना चाहते हैं, तब उस Index Position का List में पहले से Exist होना जरूरी होता है।

जबकि इस उदाहरण में Created Empty List में कोई भी Item पहले से Exist नहीं है। इसलिए जैसे ही हम Index Number 0 पर Value को Assign करने का प्रयास करते हैं, Python Interpreter “IndexError” Return कर देता है। यदि फिर भी हमें इस List में समान Index Number पर Value को Insert करना ही हो, तो पहले हमें इस List को Specified Index Number तक का Memory Allocate करना होगा और इस काम को हम इसी Program में निम्‍नानुसार तरीके से कर सकते हैं-

[code]
# Create Empty Dictionary
dicNames = {}

# Assign Key:Value Paired Data Item
dicNames[1] = 'KRISHNA'
dicNames[2] = 'MURARI'
dicNames[9] = 'BIHARI'

# Display the Dictionary Data Items
print("Dynamically Added Data Items of the Dictionary: \n", dicNames)
print("Number of Items in the List:", len(dicNames))
print()

# # Create Empty List
# lstNames = [0]
# # Assign Data Items into the List
# lstNames[0] = 'KRISHNA'
# #lstNames[1] = 'MURARI'
# #lstNames[9] = 'BIHARI'
# # Display the List Data Items
# print("Dynamically Added Data Items of the Dictionary: \n", lstNames)

# Create Empty List
lstNames = [0] * 10

# Assign Data Items into the List
lstNames[0] = 'KRISHNA'
lstNames[1] = 'MURARI'
lstNames[9] = 'BIHARI '

# Display the List Data Items
print("Dynamically Added Data Items of the Dictionary: \n", lstNames)
print("Number of Items in the List:", len(lstNames))

Output
Dynamically Added Data Items of the Dictionary:
 {1: 'KRISHNA', 2: 'MURARI', 9: 'BIHARI'}
Number of Items in the List: 3
Dynamically Added Data Items of the Dictionary:
 ['KRISHNA', 'MURARI', 0, 0, 0, 0, 0, 0, 0, 'BIHARI ']
Number of Items in the List: 10
[/code]

इस तरह से इस Example में हमने List Object Create करते ही उसमें 10 Data Items Create कर दिए हैं, जिनमें Data Value के रूप में मान 0 है। यानी वास्‍तव में ये List Object Empty है ही नहीं, बल्कि प्रत्‍येक List Item में Data के रूप में मान 0 Exist है। इसीलिए वास्‍तव में ये List 3 Data Items की नहीं बल्कि 10 Data Items की है, जबकि इसी Example में Define किए गए Dictionary में वास्‍तव में कुल 3 ही Items हैं।

जब हम किसी Sparse Data Structure को Define करना चाहते हैं, तब List के स्‍थान पर Dictionary का प्रयोग करना ज्‍यादा बेहतर होता है क्‍योंकि Dictionary में हम किसी Specific Index Number को Key की तरह Specify करते हुए ज्‍यादा Optimized तरीके से Sparse Matrix Create कर सकते हैं।

लेकिन जब हम List का प्रयोग करते हुए इसी तरह का Sparse Matrix Create करना चाहते हैं, तब जैसा हमने पिछले Example में किया, हमें List के सभी Data Elements को पूरी तरह से Define करना जरूरी होता है, उसके बाद ही हम किसी Index Position पर किसी Value को Insert कर सकते हैं।

जबकि Dictionary का प्रयोग करके Sparse Matrix Create करते हैं, तब हमें केवल उन्‍हीं Data Items के लिए Memory Create करना पड़ता है, जो कि Exist होते हैं और Sparse Matrix में वास्‍तव में बहुत कम Actual Data Exist होते हैं, बाकी का Most of the Matrix Empty ही रहता है। जैसे-

इस तरह से यदि हमें इस Sparse Matrix को Python Program द्वारा Represent करना हो, तो हमारा Example Program कुछ निम्‍नानुसार हो सकता है-

[code]
FileName: DictionarySparseMatrix.py
# Create Empty Dictionary
dicSparse = {}

# Assign Key:Value Paired Data Item
dicSparse[(0,0)] = 1.1
dicSparse[(0,6)] = 0.5
dicSparse[(1,1)] = 1.9
dicSparse[(1,6)] = 0.5
dicSparse[(2,2)] = 2.6
dicSparse[(2,6)] = 0.5
dicSparse[(3,2)] = 7.8
dicSparse[(3,3)] = 0.6
dicSparse[(4,3)] = 1.5
dicSparse[(4,4)] = 2.7
dicSparse[(5,0)] = 1.6
dicSparse[(5,4)] = 0.4
dicSparse[(6,5)] = 0.9
dicSparse[(6,6)] = 1.7

# Display the Sparse Matrix
print("Dynamically Added Data Items of the Dictionary: \n", dicSparse)
print("Number of Items in the List:", len(dicSparse))

Output
Dynamically Added Data Items of the Dictionary:
 {(0, 0): 1.1, (0, 6): 0.5, (1, 1): 1.9, (1, 6): 0.5, (2, 2): 2.6, (2, 6): 0.5, (3, 2): 7.8, (3, 3): 0.6, (4, 3): 1.5, (4, 4): 2.7, (5, 0): 1.6, (5, 4): 0.4, (6, 5): 0.9, (6, 6): 1.7}

Number of Items in the List: 14
[/code]

इस Example में हमने एक Dictionary Object के माध्‍यम से Sparse Matrix को Define किया है और क्‍योंकि हम एक Two-Dimensional Array के माध्‍यम से Matrix को Define कर रहे हैं, और Dictionary में किसी भी Key को केवल Immutable Object के माध्‍यम से ही Represent किया जा सकता है, इसीलिए 2D Array के Elements की Index Position को Represent करने के लिए हमने Tuple Core Type का प्रयोग किया है।

Dictionary Create करने के कई तरीके उपलब्‍ध हैं क्‍योंकि Dictionary, Python का एक बहुत ही महत्‍वपूर्ण Data Structure है। इनमें से कुछ तरीकों को हम पहले भी देख चुके हैं। फिर भी एक Simple Example द्वारा Dictionary Create करने के विभिन्‍न तरीकों को समझना निश्चित रूप से उपयोगी होगा।

[code]
FileName: DictionaryCreationWays.py
# Traditional Literal Expression
dicStud1 = {'Name':'KRISHNA', 'age':'5'}
print("Using Traditional Literal Expression:\n", dicStud1, "\n")

# Assign Keys with Values Dynamically
dicStud2 = {}
dicStud2['Name'] = 'MURARI'
dicStud2['age'] = 6
print("Assign Keys with Values Dynamically:\n", dicStud2, "\n")

# Using dict() Constructor
dicStud3 = dict(Name='SHYAM', Age=6)
print("Using dict() Constructor:\n", dicStud3, "\n")

# Using zip() Function
dicStud5 = dict(zip(['Name', 'Age'],['BIHARI',7]))
print("Using zip() Function in dict() Constructor:\n", dicStud5, "\n")

# Using dict() Constructor with Key/Value Tuple Argument
dicStud4 = dict([('Name', 'MOHAN'), ('Age',6)])
print("Using dict() Constructor with Key/Value Tuple Argument:")
print(dicStud4, "\n")

# Using Dictionary's fromkeys() Method
dicStud6 = dict.fromkeys(['Name', 'Age'],'')
print("Using fromkeys() Method of Dictionary:\n", dicStud6, "\n")

Output
Using Traditional Literal Expression:
 {'Name': 'KRISHNA', 'age': '5'}
Assign Keys with Values Dynamically:
 {'Name': 'MURARI', 'age': 6}
Using dict() Constructor:
 {'Name': 'SHYAM', 'Age': 6}
Using zip() Function in dict() Constructor:
 {'Name': 'BIHARI', 'Age': 7}
Using dict() Constructor with Key/Value Tuple Argument:
{'Name': 'MOHAN', 'Age': 6}
Using fromkeys() Method of Dictionary:
 {'Name': '', 'Age': ''}
[/code]

इस Example के पहले चार तरीकों को हम पहले भी देख चुके हैं और काफी Use भी कर चुके हैं। zip() Function एक थोड़ा अलग तरीका है, जिसे हमने Core Types Chapter में एक Simple Example द्वारा समझा था। ये Function दो Arguments Accept करता है, पहला Argument Keys की List को Represent करता है जबकि दूसरा Argument उन Keyes के साथ Associate होने वाली Values की List होता है।

परिणामस्‍वरूप जब Python इस zip() Function को Execute करता है, तो सभी Keys को क्रम से Values के साथ Associate करके Return कर देता है, जिसे dict() Constructor एक Dictionary Object में Translate करके Return कर देता है।

इस Example में Discuss किया गया पांचवा तरीथा थोड़ा Special है, जिसमें dict() Constructor के Parameter के रूप में एक List Object होता है और इस List Object में Data Items की तरह Tuples को Specify किया जाता है, जहां प्रत्‍येक Tuple एक Key:Value Pair के रूप में Setup हो जाते हैं, और dict() Constructor इस List के सभी Tuples को Data Items की तरह Use करते हुए एक Dictionary Object Return कर देता है।

इस Example का अन्तिम तरीका dict Core Type के fromkeys() Method को Use करता है। ये Method पहले Argument के रूप में Keys की List Accept करता है, और दूसरे Argument के रूप में हमें एक Default Value को Specify करना होता है। पहले Argument के रूप में हम जो Keys की List Specify करते हैं, Python एक Dictionary Object Create करता है और Data Items के रूप में उन सभी Keys के साथ Default Value को Specify करते हुए एक Dictionary Object Return कर देता है।