पायथन में डिक्शनरी के साथ गणना कैसे करें

समस्या

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

समाधान

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

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

1. सबसे कम खिताब वाले खिलाड़ी को ढूंढने का प्रयास

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

आउटपुट: Djokovic (यह गलत है क्योंकि यह कीज़ पर लेक्सिकोग्राफिकली तुलना करता है)

2. values() मेथड का उपयोग करके सही करें

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

आउटपुट: 0 (लेकिन हमें खिलाड़ी का नाम भी चाहिए)

3. min() और max() में key फंक्शन सप्लाई करके संबंधित की प्राप्त करें

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

आउटपुट: Zverev

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

आउटपुट: 0

4. zip() का उपयोग करके समस्या हल करें - डिक्शनरी को (value, key) जोड़ियों में "इनवर्ट" करें

ऐसे टपल्स पर तुलना करते समय, वैल्यू एलिमेंट की पहले तुलना की जाती है, उसके बाद की की।

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'))

5. डेटा रैंक करने के लिए zip() के साथ sorted() का उपयोग करें

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')]

6. ध्यान दें: zip() एक इटरेटर बनाता है जिसे केवल एक बार उपभोग किया जा सकता है

titles_and_players = zip(PlayerTitles.values(), PlayerTitles.keys())
print(f"Output \n***{min(titles_and_players)}")
# दोबारा कॉल करने पर एरर होगा - खाली सीक्वेंस

7. डुप्लीकेट वैल्यूज़ के मामले में

(value, key) जोड़ियों वाली गणनाओं में, डुप्लीकेट वैल्यूज़ होने पर परिणाम निर्धारित करने के लिए key का उपयोग किया जाता है। इसीलिए अधिकतम खिताब वाले खिलाड़ियों के लिए, हमें केवल एक मान मिलता है जो नडाल है (क्योंकि 'Nadal' 'Federer' से लेक्सिकोग्राफिकली बड़ा है)।