Python Dictionary Comprehension: आवश्यक बातें जो आपको जाननी चाहिए

Python डिक्शनरी क्या है?

Python में डिक्शनरी आइटम्स का ऐसा संग्रह है जिसे इंडेक्स से नहीं बल्कि किसी विशिष्ट कुंजी से एक्सेस किया जाता है। इसका अर्थ क्या है?

वास्तविक दुनिया की डिक्शनरी की कल्पना करें। जब आपको किसी शब्द का अर्थ देखना होता है, तो आप उस शब्द के संभावित इंडेक्स से नहीं बल्कि स्वयं शब्द से अर्थ ढूँढ़ते हैं। Python डिक्शनरी भी इसी अवधारणा पर काम करती हैं: जिसका अर्थ आप ढूँढ़ रहे हैं, वह शब्द कुंजी है, और शब्द का अर्थ मूल्य है। अर्थ खोजने के लिए आपको डिक्शनरी में शब्द का इंडेक्स जानने की आवश्यकता नहीं है।

Python में डिक्शनरी इनिशियलाइज़ करना

आप Python में इस तरह डिक्शनरी इनिशियलाइज़ कर सकते हैं:

a = {'apple': 'fruit', 'beetroot': 'vegetable', 'cake': 'dessert'}
a['doughnut'] = 'snack'
print(a['apple'])
संचालित द्वारा

fruit
संचालित द्वारा

print(a[0])
संचालित द्वारा

---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

<ipython-input-9-00d4a978143a> in <module>()
----> 1 print(a[0])


KeyError: 0

संचालित द्वारा

सबसे पहले, हम a नाम की डिक्शनरी बनाते हैं जिसमें तीन कुंजी-मूल्य युग्म हैं: 'apple': 'fruit', 'beetroot': 'vegetable', और 'cake': 'dessert'। कुंजियाँ उन वस्तुओं के नाम दर्शाने वाली स्ट्रिंग्स हैं, और मान उन वस्तुओं के प्रकार या श्रेणी को दर्शाने वाली स्ट्रिंग्स हैं।

इसके बाद, हम a डिक्शनरी में एक नया कुंजी-मूल्य युग्म a ['doughnut'] = 'snack' सिंटैक्स का उपयोग करके जोड़ते हैं। यह डिक्शनरी में 'doughnut' कुंजी को संबंधित मान 'snack' के साथ जोड़ता है।

कोड की तीसरी पंक्ति डिक्शनरी a में कुंजी 'apple' से जुड़े मान को प्रिंट करती है। चूँकि 'apple' डिक्शनरी में एक कुंजी है, कोड 'fruit' प्रिंट करता है।

कोड की चौथी पंक्ति डिक्शनरी a में कुंजी 0 से जुड़े मान को प्रिंट करने की कोशिश करती है, जो डिक्शनरी में मान्य कुंजी नहीं है। इससे KeyError उत्पन्न होता है, जो तब उठता है जब आप डिक्शनरी में मौजूद नहीं किसी कुंजी को एक्सेस करते हैं।

Python डिक्शनरी के डेटा टाइप्स

डिक्शनरी के आइटम्स किसी भी डेटा टाइप के हो सकते हैं। समझ बनाने के लिए नीचे डिक्शनरी के कुछ और उदाहरण देखें:

चार कुंजी-मूल्य युग्मों के साथ डिक्शनरी a बनाएं:

a = {'one': 1, 'two': 'to', 'three': 3.0, 'four': [4,4.0]}
print(a)संचालित द्वारा

डिक्शनरी a में कुंजी 'one' से जुड़े मान को 1.0 में अपडेट करें।

# Update a dictionary
a['one'] = 1.0 
print(a)संचालित द्वारा

{'four': [4, 4.0], 'two': 'to', 'three': 3.0, 'one': 1.0}संचालित द्वारा

डिक्शनरी a से कुंजी 'one' से जुड़े कुंजी-मूल्य युग्म को हटाएँ।

# Delete a single element
del a['one'] 
print(a)संचालित द्वारा

{'four': [4, 4.0], 'two': 'to', 'three': 3.0}संचालित द्वारा

clear() मेथड का उपयोग करके डिक्शनरी a से सभी कुंजी-मूल्य युग्म हटाएँ।

# Delete all elements in the dictionary
a.clear()
print(a)संचालित द्वारा

{}संचालित द्वारा

del कीवर्ड का उपयोग करके डिक्शनरी a को हटाएँ।

# Delete the dictionary
del a 
print(a)
संचालित द्वारा

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-12-701c9d6596da> in <module>()
      1 del a #Deletes the dictionary
----> 2 print(a)


NameError: name 'a' is not defined
संचालित द्वारा

यह याद रखना महत्वपूर्ण है कि डिक्शनरी में कुंजी अद्वितीय होनी चाहिए; डुप्लिकेट मान्य नहीं हैं। हालाँकि, डुप्लिकेट कुंजियों की स्थिति में, त्रुटि देने के बजाय Python आखिरी बार आई कुंजी को मान्य मानेगा और पहले कुंजी-मूल्य युग्म को अनदेखा कर देगा। खुद देखिए:

sweet_dict = {'a1': 'cake', 'a2':'cookie', 'a1': 'icecream'}
print(sweet_dict['a1'])
संचालित द्वारा

icecream
संचालित द्वारा

Python Dictionary Comprehension

Dictionary comprehension एक ऐसी विधि है जिससे एक डिक्शनरी को दूसरी डिक्शनरी में बदला जाता है। इस रूपांतरण के दौरान, मूल डिक्शनरी के आइटम्स को शर्तों के आधार पर नई डिक्शनरी में शामिल किया जा सकता है, और हर आइटम को आवश्यकतानुसार रूपांतरित किया जा सकता है।

अच्छी list comprehension आपके कोड को अधिक अभिव्यंजक बनाती है और इसलिए पढ़ना आसान बनाती है। Comprehensions बनाते समय ध्यान यह रखना है कि वे इतने जटिल न हों कि यह समझना मुश्किल हो जाए कि वे वास्तव में कर क्या रही हैं। "आसानी से पढ़ने योग्य" रखने का विचार ज़िंदा रहे।

Python में dictionary comprehension करने का तरीका यह है कि आप डिक्शनरी के key ऑब्जेक्ट्स और value ऑब्जेक्ट्स तक पहुँच सकें।

यह कैसे किया जा सकता है?

Python ने इसका इंतज़ाम किया है! आप इसके लिए बिल्ट-इन मेथड्स का उपयोग कर सकते हैं:

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
# Put all keys of `dict1` in a list and returns the list
dict1.keys()
संचालित द्वारा

dict_keys(['c', 'd', 'a', 'b'])
संचालित द्वारा

# Put all values saved in `dict1` in a list and returns the list
dict1.values()
संचालित द्वारा

dict_values([3, 4, 1, 2])
संचालित द्वारा

ऊपर दिया गया कोड dict1 नाम का Python डिक्शनरी बनाता है जिसमें चार कुंजी-मूल्य युग्म हैं। डिक्शनरी पर keys() मेथड कॉल किया जाता है, जो डिक्शनरी की सभी कुंजियों वाला एक view ऑब्जेक्ट लौटाता है।

values() मेथड भी डिक्शनरी पर कॉल किया जाता है, जो डिक्शनरी के सभी मानों वाला एक view ऑब्जेक्ट लौटाता है।

दोनों view ऑब्जेक्ट्स सेट्स की तरह व्यवहार करते हैं और क्रमशः कुंजियों और मानों पर सेट ऑपरेशंस करने में उपयोग किए जा सकते हैं।

ध्यान दें कि view ऑब्जेक्ट्स में कुंजियों और मानों का क्रम उस क्रम से मेल खाने की गारंटी नहीं है जिसमें वे डिक्शनरी में जोड़े गए थे।

मूल्य का बेसिक रूपांतरण 

एक सरल dictionary comprehension से शुरुआत करते हैं:

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
# Double each value in the dictionary
double_dict1 = {k:v*2 for (k,v) in dict1.items()}
print(double_dict1)
संचालित द्वारा

{'e': 10, 'a': 2, 'c': 6, 'b': 4, 'd': 8}
संचालित द्वारा

ऊपर दिए गए comprehension कोड में, हम dict1 डिक्शनरी से एक नई डिक्शनरी double_dict1 बनाते हैं, जिसमें बस प्रत्येक मान को दोगुना कर दिया गया है।

आप कुंजियों में भी बदलाव कर सकते हैं। उदाहरण के लिए, आइए ऊपर जैसी ही डिक्शनरी बनाएँ लेकिन कुंजियों के नाम भी बदल दें।

dict1_keys = {k*2:v for (k,v) in dict1.items()}
print(dict1_keys)
संचालित द्वारा

{'dd': 4, 'ee': 5, 'aa': 1, 'bb': 2, 'cc': 3}
संचालित द्वारा

items() मेथड का उपयोग

अब जब आप डिक्शनरी में सभी कुंजियों और उनके मानों तक पहुँच सकते हैं, तो आप items() मेथड का उपयोग करके डिक्शनरी के प्रत्येक कुंजी-मूल्य युग्म तक भी पहुँच सकते हैं:

dict1.items()
संचालित द्वारा

dict_items([('c', 3), ('d', 4), ('a', 1), ('b', 2)])
संचालित द्वारा

यह सामान्य टेम्पलेट है जिसे आप Python में dictionary comprehension के लिए अपना सकते हैं:

dict_variable = {key:value for (key,value) in dictonary.items()}
संचालित द्वारा

यह सबसे बुनियादी और सरल टेम्पलेट के रूप में काम कर सकता है। जैसे-जैसे आप इसमें शर्तें जोड़ते हैं, यह अधिक जटिल हो सकता है।

fromkeys() मेथड का उपयोग

Python fromkeys() मेथड भी देता है, जो आपको किसी निर्दिष्ट कुंजियों के सेट के लिए एक समान मान के साथ डिक्शनरी बनाने की अनुमति देता है। यह मेथड डिफ़ॉल्ट मानों के साथ डिक्शनरी इनिशियलाइज़ करने में उपयोगी है। देखें:

# Create a dictionary with keys ranging from 0 to 4, all set to True
my_dict = dict.fromkeys(range(5), True)
print(my_dict)संचालित द्वारा

{0: True, 1: True, 2: True, 3: True, 4: True}संचालित द्वारा

इस उदाहरण में, fromkeys() मेथड 0 से 4 तक संख्याओं को कुंजी के रूप में लेकर एक डिक्शनरी बनाता है, और हर कुंजी को मान True सौंपा जाता है। यह तरीका बाद में अपडेट या प्रोसेसिंग के लिए डिक्शनरी इनिशियलाइज़ करने जैसे कार्यों को सरल बनाता है।

Dictionary Comprehension का उपयोग क्यों करें?

Dictionary comprehension एक शक्तिशाली अवधारणा है और इसका उपयोग for loops और lambda फ़ंक्शंस के स्थान पर किया जा सकता है। हालाँकि, सभी for loops को dictionary comprehension के रूप में नहीं लिखा जा सकता, लेकिन हर dictionary comprehension को for loop से लिखा जा सकता है।

निम्न समस्या पर विचार करें जहाँ आप 0-10 की रेंज में 2 से विभाज्य संख्या को कुंजी के रूप में और उसके वर्ग को मान के रूप में लेकर नई डिक्शनरी बनाना चाहते हैं।

चलिए देखते हैं कि आप एक ही समस्या को for loop और dictionary comprehension दोनों से कैसे हल कर सकते हैं:

numbers = range(10)
new_dict_for = {}

# Add values to `new_dict` using for loop
for n in numbers:
    if n%2==0:
        new_dict_for[n] = n**2

print(new_dict_for)
संचालित द्वारा

{0: 0, 8: 64, 2: 4, 4: 16, 6: 36}
संचालित द्वारा

# Use dictionary comprehension
new_dict_comp = {n:n**2 for n in numbers if n%2 == 0}

print(new_dict_comp)
संचालित द्वारा

{0: 0, 8: 64, 2: 4, 4: 16, 6: 36}संचालित द्वारा

for loops का विकल्प

For loops किसी ऑपरेशन या निर्देशों के ब्लॉक को एक निश्चित संख्या में दोहराने के लिए उपयोग किए जाते हैं। हालाँकि, nested for loops (एक for loop के अंदर दूसरा for loop) भ्रमित और जटिल हो सकते हैं। ऐसी स्थितियों में dictionary comprehensions बेहतर होते हैं और कोड की पठनीयता और आपकी समझ को सरल बना सकते हैं।

टिप: और जानकारी के लिए DataCamp का Loops in Python ट्यूटोरियल देखें।

lambda फ़ंक्शंस का विकल्प

Lambda फ़ंक्शंस छोटे अनाम फ़ंक्शंस बनाने का एक तरीका हैं। ये बिना नाम के फ़ंक्शंस होते हैं। ये throw-away फ़ंक्शंस होते हैं, जिन्हें केवल वहीं ज़रूरत होती है जहाँ उन्हें बनाया गया है। Lambda फ़ंक्शंस मुख्यतः filter(), map() और reduce() फ़ंक्शंस के साथ उपयोग किए जाते हैं।

आइए map() फ़ंक्शन के साथ lambda फ़ंक्शन देखें:

# Initialize `fahrenheit` dictionary 
fahrenheit = {'t1':-30, 't2':-20, 't3':-10, 't4':0}

#Get the corresponding `celsius` values
celsius = list(map(lambda x: (float(5)/9)*(x-32), fahrenheit.values()))

#Create the `celsius` dictionary
celsius_dict = dict(zip(fahrenheit.keys(), celsius))

print(celsius_dict)
संचालित द्वारा

{'t2': -28.88888888888889, 't3': -23.333333333333336, 't1': -34.44444444444444, 't4': -17.77777777777778}
संचालित द्वारा

एक विस्तृत Python Dictionary Comprehension उदाहरण

एक और स्थिति देखें जहाँ आप Fahrenheit तापमानों की डिक्शनरी को Celsius में बदलना चाहते हैं।

कोड को तोड़कर देखें: पहले, आपको एक गणितीय सूत्र निर्धारित करना है जो Fahrenheit से Celsius में रूपांतरण करता है।

कोड में यह काम lambda फ़ंक्शन की मदद से किया गया है। फिर आप इस फ़ंक्शन को map() फ़ंक्शन के आर्ग्युमेंट के रूप में पास करते हैं, जो फिर fahrenheit.values() सूची के प्रत्येक आइटम पर यह ऑपरेशन लागू करता है।

values() फ़ंक्शन याद है? यह डिक्शनरी में संग्रहित आइटम्स की एक सूची लौटाता है।

अब आपके पास Celsius में तापमान मानों की एक सूची है, लेकिन समाधान में इसे डिक्शनरी होना चाहिए।

Python में zip() नामक एक बिल्ट-इन फ़ंक्शन है जो इटरेटर्स के तत्वों पर चलता है और उन्हें एकत्र करता है। आप इस Python उदाहरण में zip() फ़ंक्शन के बारे में और पढ़ सकते हैं।

ऊपर दिए गए उदाहरण में, zip फ़ंक्शन fahrenheit.keys() और celsius सूची से आइटम्स को एकत्र करता है, जिससे कुंजी-मूल्य युग्म मिलते हैं जिन्हें आप dict फ़ंक्शन से एक डिक्शनरी में बदल देते हैं, जो वांछित परिणाम है।

अब, उसी समस्या को dictionary comprehension का उपयोग करके हल करने की कोशिश करते हैं:

# Initialize the `fahrenheit` dictionary 
fahrenheit = {'t1': -30,'t2': -20,'t3': -10,'t4': 0}

# Get the corresponding `celsius` values and create the new dictionary
celsius = {k:(float(5)/9)*(v-32) for (k,v) in fahrenheit.items()}

print(celsius_dict)
संचालित द्वारा

{'t2': -28.88888888888889, 't3': -23.333333333333336, 't1': -34.44444444444444, 't4': -17.77777777777778}
संचालित द्वारा

ऊपर दिए गए कोड में हमने क्या बनाया है, इसका विवरण: 

1. fahrenheit नाम की एक डिक्शनरी बनाना, जिसमें Fahrenheit में तापमान रीडिंग्स दर्शाने वाले चार कुंजी-मूल्य युग्म हैं।

2. celsius नाम की एक नई डिक्शनरी परिभाषित करना।

3. fahrenheit डिक्शनरी पर dictionary comprehension चलाकर Fahrenheit तापमान रीडिंग्स को (5/9) * (F-32) सूत्र से Celsius में बदलना।

4. fahrenheit के प्रत्येक कुंजी-मूल्य युग्म में, कुंजी को चर k और मान को v सौंपा जाता है।

5. ऊपर दिए गए सूत्र का उपयोग करके प्रत्येक Fahrenheit तापमान के अनुरूप Celsius मान की गणना की जाती है और इसे celsius डिक्शनरी में कुंजी-मूल्य युग्म के रूप में जोड़ा जाता है।

6. परिणामी celsius डिक्शनरी को कंसोल पर प्रिंट किया जाता है।

जैसा कि आप देख सकते हैं, dictionary comprehension का उपयोग करके समस्या को एक पंक्ति के कोड में हल किया जा सकता है, जबकि पहले कार्यान्वयन में दो चरणों और तीन फ़ंक्शंस (lambda, map() और zip()) की कार्यविधि समझनी पड़ती है।

साथ ही, dictionary comprehension के साथ समाधान सहज और समझने में आसान है। इसलिए, dictionary comprehension lambda फ़ंक्शंस का एक अच्छा विकल्प हो सकता है।

Dictionary Comprehension में शर्तें जोड़ना

समस्याओं का समाधान करते समय आपको अक्सर शर्तें जोड़ने की आवश्यकता होती है। आइए देखें कि dictionary comprehension में शर्तें जोड़कर आप इसे और शक्तिशाली कैसे बना सकते हैं।

If शर्त

मान लीजिए कि आपको दी गई डिक्शनरी से एक नई डिक्शनरी बनानी है, लेकिन केवल ऐसे आइटम्स के साथ जिनके मान 2 से बड़े हैं। इसका मतलब है कि आपको ऊपर देखे गए मूल टेम्पलेट में एक शर्त जोड़नी होगी...

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

# Check for items greater than 2
dict1_cond = {k:v for (k,v) in dict1.items() if v>2}

print(dict1_cond)
संचालित द्वारा

{'e': 5, 'c': 3, 'd': 4}
संचालित द्वारा

यह इतना कठिन नहीं है! लेकिन अगर आपके पास कई शर्तें हों तो?

एक से अधिक if शर्तें

ऊपर की समस्या में, अगर आपको न केवल 2 से बड़े आइटम्स चाहिए, बल्कि साथ ही यह भी जाँचना है कि वे 2 के गुणज हैं?

dict1_doubleCond = {k:v for (k,v) in dict1.items() if v>2 if v%2 == 0}
print(dict1_doubleCond)
संचालित द्वारा

{'d': 4}
संचालित द्वारा

एक से अधिक शर्तें जोड़ने का समाधान उतना ही सरल है: अपनी comprehension में शर्तों को एक के बाद एक जोड़ दीजिए। हालाँकि, आपको यह ध्यान रखना होगा कि आप समस्या में क्या करना चाह रहे हैं। याद रखें कि क्रमिक if स्टेटमेंट्स ऐसे काम करते हैं मानो उनके बीच and क्लॉज़ हो।

आइए तीन शर्तों वाला एक और उदाहरण देखें:

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f':6}

dict1_tripleCond = {k:v for (k,v) in dict1.items() if v>2 if v%2 == 0 if v%3 == 0}

print(dict1_tripleCond)
संचालित द्वारा

{'f': 6}
संचालित द्वारा

for loop में, यह इसके अनुरूप होगा:

dict1_tripleCond = {}

for (k,v) in dict1.items():
    if (v>=2 and v%2 == 0 and v%3 == 0):
            dict1_tripleCond[k] = v

print(dict1_tripleCond)
संचालित द्वारा

{'f': 6}संचालित द्वारा

If-else शर्तें

If-else शर्त के साथ काम करना भी dictionary comprehension में आसान है। खुद देखने के लिए निम्न उदाहरण देखें:

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f':6}

# Identify odd and even entries
dict1_tripleCond = {k:('even' if v%2==0 else 'odd') for (k,v) in dict1.items()}

print(dict1_tripleCond)
संचालित द्वारा

{'f': 'even', 'c': 'odd', 'b': 'even', 'd': 'even', 'e': 'odd', 'a': 'odd'}संचालित द्वारा

Nested dictionary comprehension

Nesting एक प्रोग्रामिंग अवधारणा है जहाँ डेटा परतों में व्यवस्थित होता है या जहाँ ऑब्जेक्ट्स में अन्य समान ऑब्जेक्ट्स होते हैं। आपने अक्सर nested 'if' संरचना देखी होगी, जो एक if शर्त के अंदर दूसरी if शर्त होती है।

इसी तरह, डिक्शनरीज़ भी नेस्टेड हो सकती हैं, और इस प्रकार, उनकी comprehensions भी नेस्टेड हो सकती हैं। आइए देखें इसका क्या अर्थ है:

nested_dict = {'first':{'a':1}, 'second':{'b':2}}
float_dict = {outer_k: {float(inner_v) for (inner_k, inner_v) in outer_v.items()} for (outer_k, outer_v) in nested_dict.items()}
print(float_dict)
संचालित द्वारा

{'first': {1.0}, 'second': {2.0}}
संचालित द्वारा

यह एक नेस्टेड डिक्शनरी का उदाहरण है। nested_dict एक ऐसी डिक्शनरी है जिसकी कुंजियाँ first और second हैं, जिनके मानों में डिक्शनरी ऑब्जेक्ट्स हैं। कोड अंदरूनी डिक्शनरी के मानों पर काम करता है, उन्हें float में बदलता है, और फिर बाहरी कुंजियों को नए float अंदरूनी मानों के साथ मिलाकर एक नई डिक्शनरी बनाता है।

कोड में nested dictionary comprehension भी है, यानी एक dictionary comprehension के अंदर दूसरी। Dictionary comprehension, जब नेस्टेड होती है, तो पढ़ने और समझने में काफ़ी कठिन हो सकती है, जो comprehensions के उपयोग के मूल उद्देश्य के खिलाफ़ है।

जैसे-जैसे उस डिक्शनरी की संरचना जटिल होती है जिसके साथ आप काम कर रहे हैं, dictionary comprehension भी जटिल होती जाती है। ऐसी स्थितियों में, अपने कोड में जटिल comprehensions का उपयोग न करना बेहतर हो सकता है।

नोट करें कि आप ऊपर दिए गए कोड हिस्से को nested for loop से भी फिर से लिख सकते हैं:

nested_dict = {'first':{'a':1}, 'second':{'b':2}}

for (outer_k, outer_v) in nested_dict.items():
    for (inner_k, inner_v) in outer_v.items():
        outer_v.update({inner_k: float(inner_v)})
nested_dict.update({outer_k:outer_v})

print(nested_dict)
संचालित द्वारा

{'first': {'a': 1.0}, 'second': {'b': 2.0}}
संचालित द्वारा

अंतिम विचार

उम्मीद है, अब आपने Python में डिक्शनरीज़, comprehension की अवधारणा, और क्यों तथा कहाँ Python dictionary comprehension उपयोगी हो सकती है, के बारे में सीख लिया होगा। 

अभ्यास आपके Python को बेहतर बनाता है! अपने कोड को सुधारने के लिए हमारे शीर्ष Python टिप्स और ट्रिक्स देखें, या हमारा Python Data Fundamentals ट्रैक करें और सबसे महत्वपूर्ण चीज़ों में महारत हासिल करें।