पायथन में शब्दकोशों के साथ गणना कैसे करें?

समस्या

आप डेटा के शब्दकोश पर विभिन्न गणनाएं (उदा., न्यूनतम मान, अधिकतम मान, सॉर्टिंग, आदि) करना चाहते हैं।

समाधान।

हम टेनिस खिलाड़ियों और उनके ग्रैंडस्लैम खिताबों के साथ एक शब्दकोश तैयार करेंगे।

PlayerTitles = {
   'Federer': 20,
   'Nadal': 20,
   'Djokovic': 17,
   'Murray': 3,
   'Theim' : 1,
   'Zverev': 0
}

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

#type(PlayerTitles)
print(f"Output \n*** The minimum value in the dictionary is {min(PlayerTitles)} ")

आउटपुट

*** The minimum value in the dictionary is Djokovic

2. यह शायद वह नहीं है जो हम चाहते हैं क्योंकि हम वास्तव में एक गणना करने की कोशिश कर रहे हैं जिसमें शब्दकोश मूल्यों को शामिल किया गया है। तो आइए एक शब्दकोश के मान () पद्धति का उपयोग करके इसे ठीक करने का प्रयास करें।

print(f"Output \n*** The minimum value in the dictionary is {min(PlayerTitles.values())} ")

आउटपुट

*** The minimum value in the dictionary is 0

3. दुर्भाग्य से, यह अक्सर वैसा नहीं होता जैसा आप चाहते हैं। उदाहरण के लिए, आप संबंधित कुंजियों के बारे में जानकारी जानना चाह सकते हैं, यानी कम से कम शीर्षक वाले खिलाड़ी का नाम।

4. यदि आप न्यूनतम () और अधिकतम () को एक कुंजी फ़ंक्शन प्रदान करते हैं, तो आप न्यूनतम या अधिकतम मान के अनुरूप कुंजी प्राप्त कर सकते हैं।

print(f"Output \n***{min(PlayerTitles, key=lambda k: PlayerTitles[k])} ")

आउटपुट

***Zverev

5. हालांकि, न्यूनतम मान प्राप्त करने के लिए, आपको एक अतिरिक्त लुकअप करने की आवश्यकता होगी।

min_titles = PlayerTitles[min(PlayerTitles, key=lambda k: PlayerTitles[k])]
print(f"Output \n***{min_titles} ")

आउटपुट

***0

6. जिप () को शामिल करने वाला समाधान डिक्शनरी को (वैल्यू, की) जोड़े के क्रम में "इनवर्टिंग" करके समस्या का समाधान करता है। ऐसे टुपल्स पर तुलना करते समय, मान तत्व की तुलना पहले की जाती है, उसके बाद कुंजी की जाती है।

यह हमें ठीक वैसा ही व्यवहार देता है जैसा हम चाहते हैं और एक कथन का उपयोग करके शब्दकोश सामग्री पर आसानी से कटौती और छँटाई की अनुमति देता है।

min_titles = min(zip(PlayerTitles.values(), PlayerTitles.keys()))
max_titles = max(zip(PlayerTitles.values(), PlayerTitles.keys()))

print(f"Output \n***{min_titles , max_titles} ")

आउटपुट

***((0, 'Zverev'), (20, 'Nadal'))

7. इसी तरह, डेटा को रैंक करने के लिए, zip() का उपयोग सॉर्ट किए गए()

titles_sorted = sorted(zip(PlayerTitles.values(), PlayerTitles.keys()))
print(f"Output \n***{titles_sorted} ")

आउटपुट

***[(0, 'Zverev'), (1, 'Theim'), (3, 'Murray'), (17, 'Djokovic'), (20, 'Federer'), (20, 'Nadal')]

8.इन गणनाओं को करते समय, ध्यान रखें कि zip() एक इटरेटर बनाता है जिसे केवल एक बार ही उपभोग किया जा सकता है।

titles_and_players = zip(PlayerTitles.values(), PlayerTitles.keys())
print(f"Output \n***{min(titles_and_players)} ")

आउटपुट

***(0, 'Zverev')

9. अगर हम इसे फिर से कॉल करने का प्रयास करते हैं, तो हम खाली अनुक्रम के रूप में अपवाद का सामना करेंगे।

10. यह ध्यान दिया जाना चाहिए कि (मान, कुंजी) जोड़े की गणना में, कुंजी का उपयोग उन उदाहरणों में परिणाम निर्धारित करने के लिए किया जाएगा जहां कई प्रविष्टियों का एक ही मान होता है।

उदाहरण के लिए, न्यूनतम () और अधिकतम () जैसी गणनाओं में, डुप्लिकेट मान होने पर सबसे छोटी या सबसे बड़ी कुंजी वाली प्रविष्टि वापस कर दी जाएगी। यही कारण है कि जब हम अधिकतम खिताब वाले खिलाड़ियों के लिए चुनते हैं, तो हम केवल एक मूल्य के साथ समाप्त होते हैं जो नडाल है। (चरण 7 आउटपुट देखें)।