शब्दकोश में अधिकतम मूल्य के साथ कुंजी प्राप्त करना?


866

मेरे पास a dictionary: चाबियाँ स्ट्रिंग्स हैं, मान पूर्णांक हैं।

उदाहरण:

stats = {'a':1000, 'b':3000, 'c': 100}

मैं 'b'एक उत्तर के रूप में प्राप्त करना चाहता हूं , क्योंकि यह उच्च मूल्य के साथ कुंजी है।

मैंने निम्न कार्य किया, उल्टे की-वैल्यू टुपल्स के साथ एक मध्यवर्ती सूची का उपयोग करते हुए:

inverse = [(value, key) for key, value in stats.items()]
print max(inverse)[1]

क्या यह एक बेहतर (या अधिक सुरुचिपूर्ण) दृष्टिकोण है?


1
उम, इसमें गलत क्या है max(stats)?
जॉन रेड

12
max(stats)कुंजियों को कुंजियों के रूप में उपयोग करेगा (यह लौटाएगा 'c', यह देखते हुए कि अधिकतम लेबल है), max(stats, key=lambda key: stats[key])वह है जो ओपी के बाद था (जो वापस आ जाएगा 'b', अधिकतम अनुक्रमित मूल्य का लेबल)। क्या यह कोई स्पष्ट है?
एटकॉल्ड

जवाबों:


609

आप इसके लिए उपयोग कर सकते हैं operator.itemgetter:

import operator
stats = {'a':1000, 'b':3000, 'c': 100}
max(stats.iteritems(), key=operator.itemgetter(1))[0]

और स्मृति उपयोग में एक नई सूची बनाने के बजाय stats.iteritems()keyकरने के लिए पैरामीटर max()समारोह एक समारोह है कि एक महत्वपूर्ण यह है कि पद आइटम के लिए कैसे निर्धारित करने के लिए प्रयोग किया जाता है की गणना करता है।

कृपया ध्यान दें कि यदि आप किसी अन्य कुंजी-मान पेयर 'प' के लिए गए थे, तो: 3000 है कि इस विधि केवल वापस आ जाएगी एक की दो भले ही वे दोनों अधिकतम मूल्य की है।

>>> import operator
>>> stats = {'a':1000, 'b':3000, 'c': 100, 'd':3000}
>>> max(stats.iteritems(), key=operator.itemgetter(1))[0]
'b' 

यदि Python3 का उपयोग कर रहे हैं:

>>> max(stats.items(), key=operator.itemgetter(1))[0]
'b'

241
यहां तक ​​कि क्लीनर, मुझे लगता है किmax(stats.iterkeys(), key=(lambda key: stats[key]))
Lucretiel

18
सिर्फ उपयोग क्यों नहीं key=lambda x: x[1]?
बेनाडुंडी

43
अजगर में 3 @ Lucretiel (सही ढंग से वर्तनी) समाधान विफल रहता है। यह होना चाहिए: अधिकतम (ysts.keys (), कुंजी = (लैम्ब्डा k: आँकड़े [k])) चूंकि चाबियाँ () अब iterkeys () स्वचालित रूप से करती थीं।
वाट्सएप

73
रिग्थ तुम हो। दिलचस्प बात यह है कि एक ऐसा उपाय जो स्मृति के लिए बिल्कुल कारगर है और पायथन 2 और 3 दोनों में काम करता है:max(stats, key=lambda key: stats[key])
ल्यूक्रिएल

3
ईमानदारी से मुझे लगता है कि टिप्पणियों में क्लीनर और बेहतर समाधान है।
अगस्तो गोंजालेज

1177
max(stats, key=stats.get)

17
अगर आप वास्तव में इसे इस तरह से करना चाहते हैं, तो आप कर सकते हैंstats[max(stats, key=stats.get)]
क्रैकस्मोकर

81
@scottmrogowski, ss यह कुंजी को अधिकतम मूल्य प्रदान करता है, जैसा कि पूछा गया है। अधिकतम मान केवल अधिकतम (आँकड़ें) () होगा।
ए। कोड़ी

25
यह उत्तर होना चाहिए क्योंकि यह सबसे सरल है और वास्तव में ओपी ने पूछा था।
इटाकेचे

4
@ कोडी क्या होगा यदि दो कुंजी (एक ही मूल्य के साथ) के बीच एक टाई है? मैं उन दोनों को प्राप्त करना चाहता हूं, लेकिन मुझे केवल एक ही मिलता है।
oba2311

10
@ oba2311max_value = max(stats.values()); {key for key, value in stats.items() if value == max_value}
ए।

208

मैंने MANY वेरिएंट का परीक्षण किया है, और यह अधिकतम मूल्य के साथ तानाशाह की कुंजी को वापस करने का सबसे तेज़ तरीका है:

def keywithmaxval(d):
     """ a) create a list of the dict's keys and values; 
         b) return the key with the max value"""  
     v=list(d.values())
     k=list(d.keys())
     return k[v.index(max(v))]

आपको एक विचार देने के लिए, यहाँ कुछ उम्मीदवार तरीके दिए गए हैं:

def f1():  
     v=list(d1.values())
     k=list(d1.keys())
     return k[v.index(max(v))]

def f2():
    d3={v:k for k,v in d1.items()}
    return d3[max(d3)]

def f3():
    return list(filter(lambda t: t[1]==max(d1.values()), d1.items()))[0][0]    

def f3b():
    # same as f3 but remove the call to max from the lambda
    m=max(d1.values())
    return list(filter(lambda t: t[1]==m, d1.items()))[0][0]        

def f4():
    return [k for k,v in d1.items() if v==max(d1.values())][0]    

def f4b():
    # same as f4 but remove the max from the comprehension
    m=max(d1.values())
    return [k for k,v in d1.items() if v==m][0]        

def f5():
    return max(d1.items(), key=operator.itemgetter(1))[0]    

def f6():
    return max(d1,key=d1.get)     

def f7():
     """ a) create a list of the dict's keys and values; 
         b) return the key with the max value"""    
     v=list(d1.values())
     return list(d1.keys())[v.index(max(v))]    

def f8():
     return max(d1, key=lambda k: d1[k])     

tl=[f1,f2, f3b, f4b, f5, f6, f7, f8, f4,f3]     
cmpthese.cmpthese(tl,c=100) 

परीक्षण शब्दकोश:

d1={1: 1, 2: 2, 3: 8, 4: 3, 5: 6, 6: 9, 7: 17, 8: 4, 9: 20, 10: 7, 11: 15, 
    12: 10, 13: 10, 14: 18, 15: 18, 16: 5, 17: 13, 18: 21, 19: 21, 20: 8, 
    21: 8, 22: 16, 23: 16, 24: 11, 25: 24, 26: 11, 27: 112, 28: 19, 29: 19, 
    30: 19, 3077: 36, 32: 6, 33: 27, 34: 14, 35: 14, 36: 22, 4102: 39, 38: 22, 
    39: 35, 40: 9, 41: 110, 42: 9, 43: 30, 44: 17, 45: 17, 46: 17, 47: 105, 48: 12, 
    49: 25, 50: 25, 51: 25, 52: 12, 53: 12, 54: 113, 1079: 50, 56: 20, 57: 33, 
    58: 20, 59: 33, 60: 20, 61: 20, 62: 108, 63: 108, 64: 7, 65: 28, 66: 28, 67: 28, 
    68: 15, 69: 15, 70: 15, 71: 103, 72: 23, 73: 116, 74: 23, 75: 15, 76: 23, 77: 23, 
    78: 36, 79: 36, 80: 10, 81: 23, 82: 111, 83: 111, 84: 10, 85: 10, 86: 31, 87: 31, 
    88: 18, 89: 31, 90: 18, 91: 93, 92: 18, 93: 18, 94: 106, 95: 106, 96: 13, 9232: 35, 
    98: 26, 99: 26, 100: 26, 101: 26, 103: 88, 104: 13, 106: 13, 107: 101, 1132: 63, 
    2158: 51, 112: 21, 113: 13, 116: 21, 118: 34, 119: 34, 7288: 45, 121: 96, 122: 21, 
    124: 109, 125: 109, 128: 8, 1154: 32, 131: 29, 134: 29, 136: 16, 137: 91, 140: 16, 
    142: 104, 143: 104, 146: 117, 148: 24, 149: 24, 152: 24, 154: 24, 155: 86, 160: 11, 
    161: 99, 1186: 76, 3238: 49, 167: 68, 170: 11, 172: 32, 175: 81, 178: 32, 179: 32, 
    182: 94, 184: 19, 31: 107, 188: 107, 190: 107, 196: 27, 197: 27, 202: 27, 206: 89, 
    208: 14, 214: 102, 215: 102, 220: 115, 37: 22, 224: 22, 226: 14, 232: 22, 233: 84, 
    238: 35, 242: 97, 244: 22, 250: 110, 251: 66, 1276: 58, 256: 9, 2308: 33, 262: 30, 
    263: 79, 268: 30, 269: 30, 274: 92, 1300: 27, 280: 17, 283: 61, 286: 105, 292: 118, 
    296: 25, 298: 25, 304: 25, 310: 87, 1336: 71, 319: 56, 322: 100, 323: 100, 325: 25, 
    55: 113, 334: 69, 340: 12, 1367: 40, 350: 82, 358: 33, 364: 95, 376: 108, 
    377: 64, 2429: 46, 394: 28, 395: 77, 404: 28, 412: 90, 1438: 53, 425: 59, 430: 103, 
    1456: 97, 433: 28, 445: 72, 448: 23, 466: 85, 479: 54, 484: 98, 485: 98, 488: 23, 
    6154: 37, 502: 67, 4616: 34, 526: 80, 538: 31, 566: 62, 3644: 44, 577: 31, 97: 119, 
    592: 26, 593: 75, 1619: 48, 638: 57, 646: 101, 650: 26, 110: 114, 668: 70, 2734: 41, 
    700: 83, 1732: 30, 719: 52, 728: 96, 754: 65, 1780: 74, 4858: 47, 130: 29, 790: 78, 
    1822: 43, 2051: 38, 808: 29, 850: 60, 866: 29, 890: 73, 911: 42, 958: 55, 970: 99, 
    976: 24, 166: 112}

और पायथन 3.2 के तहत परीक्षा परिणाम:

    rate/sec       f4      f3    f3b     f8     f5     f2    f4b     f6     f7     f1
f4       454       --   -2.5% -96.9% -97.5% -98.6% -98.6% -98.7% -98.7% -98.9% -99.0%
f3       466     2.6%      -- -96.8% -97.4% -98.6% -98.6% -98.6% -98.7% -98.9% -99.0%
f3b   14,715  3138.9% 3057.4%     -- -18.6% -55.5% -56.0% -56.4% -58.3% -63.8% -68.4%
f8    18,070  3877.3% 3777.3%  22.8%     -- -45.4% -45.9% -46.5% -48.8% -55.5% -61.2%
f5    33,091  7183.7% 7000.5% 124.9%  83.1%     --  -1.0%  -2.0%  -6.3% -18.6% -29.0%
f2    33,423  7256.8% 7071.8% 127.1%  85.0%   1.0%     --  -1.0%  -5.3% -17.7% -28.3%
f4b   33,762  7331.4% 7144.6% 129.4%  86.8%   2.0%   1.0%     --  -4.4% -16.9% -27.5%
f6    35,300  7669.8% 7474.4% 139.9%  95.4%   6.7%   5.6%   4.6%     -- -13.1% -24.2%
f7    40,631  8843.2% 8618.3% 176.1% 124.9%  22.8%  21.6%  20.3%  15.1%     -- -12.8%
f1    46,598 10156.7% 9898.8% 216.7% 157.9%  40.8%  39.4%  38.0%  32.0%  14.7%     --

और पायथन 2.7 के तहत:

    rate/sec       f3       f4     f8    f3b     f6     f5     f2    f4b     f7     f1
f3       384       --    -2.6% -97.1% -97.2% -97.9% -97.9% -98.0% -98.2% -98.5% -99.2%
f4       394     2.6%       -- -97.0% -97.2% -97.8% -97.9% -98.0% -98.1% -98.5% -99.1%
f8    13,079  3303.3%  3216.1%     --  -5.6% -28.6% -29.9% -32.8% -38.3% -49.7% -71.2%
f3b   13,852  3504.5%  3412.1%   5.9%     -- -24.4% -25.8% -28.9% -34.6% -46.7% -69.5%
f6    18,325  4668.4%  4546.2%  40.1%  32.3%     --  -1.8%  -5.9% -13.5% -29.5% -59.6%
f5    18,664  4756.5%  4632.0%  42.7%  34.7%   1.8%     --  -4.1% -11.9% -28.2% -58.8%
f2    19,470  4966.4%  4836.5%  48.9%  40.6%   6.2%   4.3%     --  -8.1% -25.1% -57.1%
f4b   21,187  5413.0%  5271.7%  62.0%  52.9%  15.6%  13.5%   8.8%     -- -18.5% -53.3%
f7    26,002  6665.8%  6492.4%  98.8%  87.7%  41.9%  39.3%  33.5%  22.7%     -- -42.7%
f1    45,354 11701.5% 11399.0% 246.8% 227.4% 147.5% 143.0% 132.9% 114.1%  74.4%     -- 

आप देख सकते हैं कि f1पायथन 3.2 और 2.7 के तहत सबसे तेज़ है (या, पूरी तरह से, keywithmaxvalइस पोस्ट के शीर्ष पर)


12
यह गड़बड़ लगता है। f7की तरह है f1, बस एक मध्यवर्ती वस्तु को नाम नहीं दे रहा है। f7होना चाहिए (बहुत थोड़ा) की तुलना में तेजी से f1, बहुत धीमी नहीं । और यही मुझे मिलता है:>>> timeit.timeit("f1()","from __main__ import f1, f7, d1", number=10000) 0.26785888786807277 >>> timeit.timeit("f7()","from __main__ import f1, f7, d1", number=10000) 0.26770628307832567
मोनिका

1
सहमत F1 f7 की तरह है। Ipython% timeit के साथ परीक्षण किया और दोनों ने python 2.7 पर मेरी मशीन पर समान प्रदर्शन के साथ आया। परीक्षण: f1 - 18 प्रति लूप परीक्षण: f2 - 33.7 प्रति लूप परीक्षण: f3b - 50 प्रति लूप परीक्षण: f4b - 30.7 प्रति लूप परीक्षण: f5 - 28 प्रति लूप परीक्षण: f6 - 23 प्रति लूप परीक्षण: F7 - प्रति पाश परीक्षण 18 μs: F8 - प्रति पाश परीक्षण 43.9 μs: F4 - प्रति पाश परीक्षण 2.16 एमएस: f3 - पाश प्रति 2.29 एमएस
Joop

जहाँ भी अधिकतम (d, कुंजी) उपलब्ध नहीं है, f1 भी लागू है।
निकोस एलेक्जेंड्रिस

5
मुझे लगा कि तानाशाही अनसुलझी है, d.keys और d.values ​​सैद्धांतिक रूप से अलग-अलग आदेश नहीं दे सकते हैं?
दिमथ

1
सूची-प्रतिलिपि समाधान मेरे लिए बदबूदार हैं। हजारों या लाखों प्रविष्टियों के साथ एक तानाशाही पर कैसा प्रदर्शन है?

63

यदि आपको अधिकतम मूल्य के साथ केवल एक कुंजी जानने की आवश्यकता है, तो आप इसे बिना कर सकते हैं iterkeysया iteritemsक्योंकि पायथन में शब्दकोश के माध्यम से पुनरावृत्ति इसके लिए कुंजी है।

max_key = max(stats, key=lambda k: stats[k])

संपादित करें:

टिप्पणियों से, @ user1274878:

मैं अजगर के लिए नया हूं। क्या आप कृपया अपना उत्तर चरणों में बता सकते हैं?

हां...

अधिकतम

अधिकतम (चलने योग्य [, कुंजी])

अधिकतम (arg1, arg2, * args [, कुंजी])

एक पुनरावृत्ति या दो या अधिक तर्कों में से सबसे बड़ी वस्तु लौटाएँ।

वैकल्पिक keyतर्क यह बताता है कि तत्वों को उनके बीच अधिकतम करने के लिए कैसे तुलना करें:

lambda <item>: return <a result of operation with item> 

लौटाए गए मूल्यों की तुलना की जाएगी।

dict

पायथन तानाशाह एक हैश टेबल है। तानाशाह की एक चाबी के रूप में घोषित किसी वस्तु का हैश होता है। प्रदर्शन के कारणों के कारण पुनरावृत्ति हालांकि एक कुंजी के माध्यम से चलना के रूप में इसे लागू किया जाता है।

इसलिए हम कुंजी सूची प्राप्त करने के संचालन से छुटकारा पाने के लिए इसका उपयोग कर सकते हैं।

समापन

किसी अन्य फ़ंक्शन के अंदर परिभाषित फ़ंक्शन को नेस्टेड फ़ंक्शन कहा जाता है। नेस्टेड फ़ंक्शंस चर के दायरे तक पहुँच सकते हैं।

statsचर उपलब्ध के माध्यम से __closure__की विशेषता lambdaचर माता पिता दायरे में परिभाषित का मूल्य के सूचक के रूप कार्य करते हैं।


1
@ I159: मैं अजगर के लिए नया हूं। क्या आप कृपया अपना उत्तर चरणों में बता सकते हैं
user1274878

57

उदाहरण:

stats = {'a':1000, 'b':3000, 'c': 100}

यदि आप इसकी कुंजी के साथ अधिकतम मूल्य प्राप्त करना चाहते हैं, तो शायद follwing सरल हो सकता है, बिना किसी प्रासंगिक कार्यों के।

max(stats, key=stats.get)

आउटपुट वह कुंजी है जिसका अधिकतम मूल्य है।


इस समाधान को अधिकतम (आंकड़े, कुंजी =
लंबो की

46

यहाँ एक और एक है:

stats = {'a':1000, 'b':3000, 'c': 100}
max(stats.iterkeys(), key=lambda k: stats[k])

फ़ंक्शन keyकेवल वह मान लौटाता है जिसका उपयोग रैंकिंग के लिए किया जाना चाहिए और max()मांगे गए तत्व को तुरंत लौटाता है।


10
.iterkeys को आपके उत्तर की आवश्यकता नहीं है (यह एक डिफॉल्ट करते समय डिफ़ॉल्ट है)। हालांकि, ध्यान दें कि .iteritems विधि एक चरण में कुंजी और मूल्य दोनों प्राप्त करती है, इसलिए .iterkeys के साथ आवश्यकतानुसार एक अतिरिक्त गेटिटेम की आवश्यकता नहीं है ।
13

यह एक महान जवाब है क्योंकि यह बहुत स्पष्ट है कि क्या चल रहा है और इस प्रकार अन्य स्थितियों का विस्तार करना आसान है।
तेंदुए

python3 संस्करण में:max(stats, key=lambda k: stats[k])
HeyJude

40
key, value = max(stats.iteritems(), key=lambda x:x[1])

यदि आप मूल्य के बारे में परवाह नहीं करते हैं (मुझे आश्चर्य होगा, लेकिन) आप कर सकते हैं:

key, _ = max(stats.iteritems(), key=lambda x:x[1])

मैं अभिव्यक्ति के अंत में एक [0] सबस्क्रिप्ट की तुलना में बेहतर ट्यूपल को पसंद करता हूं। मैं लैम्ब्डा के भावों की पठनीयता को कभी पसंद नहीं करता, लेकिन आप इसे ऑपरेटर से बेहतर पाते हैं। यह (1) IMHO।


9
_के बजाय इस्तेमाल किया जा सकता है ignored
jfs

1
@JFSebastian मैं सहमत हूँ ignoredकि बहुत बदसूरत लग रहा है, लेकिन कुछ लोग _कई कारणों से उपयोग करने के खिलाफ हैं । मुझे लगता है कि पहला स्निपेट ठीक है, भले ही आप मूल्य को नजरअंदाज कर दें
जैमिलैक

30

यह देखते हुए कि एक से अधिक प्रविष्टि में मेरा अधिकतम मूल्य है। मैं उन कुंजियों की एक सूची बनाऊंगा जिनके मूल्य के रूप में अधिकतम मूल्य है।

>>> stats = {'a':1000, 'b':3000, 'c': 100, 'd':3000}
>>> [key for m in [max(stats.values())] for key,val in stats.iteritems() if val == m]
['b', 'd']

यह आपको 'बी' और साथ ही कोई अन्य अधिकतम कुंजी देगा।

नोट: अजगर 3 के stats.items()बजाय का उपयोग करेंstats.iteritems()


9
आपका समाधान ठीक है, लेकिन अधिकतम मूल्य की गणना कई बार करता है, क्योंकि इसमें कुछ आइटम हैं। यदि कंप्यूटिंग maxमहंगी थी (उदाहरण के लिए, एक लंबी डिक्शनरी) तो मैं [key for m in [max(stats.values())] for key,val in stats.iteritems() if val == m]आपको सलाह दूंगा कि क्या आप एक-लाइनर चाहते हैं, अन्यथा m = ...पहले से गणना करें ।
22

4
बस एक छोटी टिप्पणी: अजगर के लिए 3 का उपयोग करें।
सुजा

21

आप उपयोग कर सकते हैं:

max(d, key = d.get) 
# which is equivalent to 
max(d, key = lambda k : d.get(k))

कुंजी वापस करने के लिए, जोड़ी का उपयोग करें:

max(d.items(), key = lambda k : k[1])

7
यह स्वीकृत उत्तर होना चाहिए, यह ऑपरेटर का उपयोग करने की तुलना में बहुत सरल है
सिग्मैटिक्स

19

शब्दकोश की अधिकतम कुंजी / मूल्य प्राप्त करने के लिए stats:

stats = {'a':1000, 'b':3000, 'c': 100}
  • चाबियों के आधार पर

>>> max(stats.items(), key = lambda x: x[0]) ('c', 100)

  • मूल्यों के आधार पर

>>> max(stats.items(), key = lambda x: x[1]) ('b', 3000)

बेशक, यदि आप परिणाम से केवल कुंजी या मूल्य प्राप्त करना चाहते हैं, तो आप टपल इंडेक्सिंग का उपयोग कर सकते हैं। उदाहरण के लिए, अधिकतम मान के अनुरूप कुंजी प्राप्त करने के लिए:

>>> max(stats.items(), key = lambda x: x[1])[0] 'b'

व्याख्या

items()पायथन 3 में डिक्शनरी मेथड डिक्शनरी का एक व्यू ऑब्जेक्ट है। जब maxफ़ंक्शन द्वारा इस ऑब्जेक्ट ऑब्जेक्ट को पुन: प्रसारित किया जाता है, तो यह डिक्शनरी आइटम को प्रपत्र के ट्यूपल्स के रूप में देता है (key, value)

>>> list(stats.items()) [('c', 100), ('b', 3000), ('a', 1000)]

जब आप lambdaअभिव्यक्ति का उपयोग करते हैं lambda x: x[1], प्रत्येक पुनरावृत्ति में, x इन ट्यूपल्स में से एक है (key, value)। इसलिए, सही इंडेक्स चुनकर, आप यह चुनते हैं कि आप कुंजियों से या मानों से तुलना करना चाहते हैं या नहीं।

अजगर २

पायथन 2.2+ रिलीज के लिए, एक ही कोड काम करेगा। हालांकि, प्रदर्शन iteritems()के items()लिए शब्दकोश विधि का उपयोग करना बेहतर है ।

टिप्पणियाँ

  • यह उत्तर Climbs_lika_Spyder के उत्तर पर टिप्पणियों पर आधारित है ।

  • प्रयुक्त कोड का परीक्षण Python 3.5.2 और Python 2.7.10 पर किया गया था।



10

चयनित उत्तर में टिप्पणियों के माध्यम से पुनरावृत्त समाधान ...

पायथन 3 में:

max(stats.keys(), key=(lambda k: stats[k]))

पायथन 2 में:

max(stats.iterkeys(), key=(lambda k: stats[k]))

पायथन 3 के लिए आपका समाधान पायथन 2.7 के लिए भी काम करता है।
patapouf_ai

4
क्योंकि चाबियाँ () अजगर 2 में एक
पुनरावृत्तिकर्ता नहीं लौटती हैं

10

मैं यहाँ कैसे mydict.keys()मूल्य के आधार पर लौटने के लिए देख रहा हूँ mydict.values()। केवल एक कुंजी वापस करने के बजाय, मैं शीर्ष x संख्या मानों को वापस करना चाह रहा था ।

यह समाधान max()फ़ंक्शन का उपयोग करने की तुलना में सरल है और आप आसानी से दिए गए मानों की संख्या को बदल सकते हैं:

stats = {'a':1000, 'b':3000, 'c': 100}

x = sorted(stats, key=(lambda key:stats[key]), reverse=True)
['b', 'a', 'c']

यदि आप एकल सर्वोच्च रैंकिंग कुंजी चाहते हैं, तो केवल सूचकांक का उपयोग करें:

x[0]
['b']

यदि आप शीर्ष दो सर्वोच्च रैंकिंग कुंजी चाहते हैं, तो बस सूची स्लाइसिंग का उपयोग करें:

x[:2]
['b', 'a']

यह बहुत ही अकुशल उपाय है। हुकुम को छाँटने से n लॉग (n) का रनटाइम घट जाएगा, क्योंकि आप अपने आप को उन मानों के एक समूह से संबंधित हैं जो अधिकतम नहीं हैं। अधिकतम फ़ंक्शन का उपयोग करने से बस n का रनटाइम घटेगा जो बहुत तेज़ है।
पीटर ग्राहम

1
@PeterGraham बहुत अधिक हर समाधान यहाँ (स्वीकृत उत्तर सहित) का उपयोग करता है max()। यह स्पष्ट है कि यह सबसे तेज़ है। मैंने सोचा था कि मैं स्लाइसिंग के लाभ के साथ एक अलग समाधान पेश करूंगा, जो उस समय मेरे लिए अधिक उपयोगी था
डॉनरनडॉन

8

मैं इनमें से किसी भी जवाब से संतुष्ट नहीं था। maxहमेशा अधिकतम मान के साथ पहली कुंजी चुनता है। शब्दकोश में उस मान के साथ कई कुंजी हो सकती हैं।

def keys_with_top_values(my_dict):
    return [key  for (key, value) in my_dict.items() if value == max(my_dict.values())]

इस उत्तर को पोस्ट करने से यह किसी को बाहर निकालने में मदद करता है। नीचे SO पोस्ट देखें

टाई के मामले में पायथन कौन सा अधिकतम उठाता है?


7

collections.Counterतुम्हारे साथ कर सकता है

>>> import collections
>>> stats = {'a':1000, 'b':3000, 'c': 100}
>>> stats = collections.Counter(stats)
>>> stats.most_common(1)
[('b', 3000)]

यदि उपयुक्त हो, तो आप बस एक खाली के साथ शुरू कर सकते collections.Counterहैं और इसे जोड़ सकते हैं

>>> stats = collections.Counter()
>>> stats['a'] += 1
:
etc. 

5

एक ढेर कतार एक सामान्यीकृत समाधान है जो आपको मूल्य द्वारा आदेशित शीर्ष n कुंजी निकालने की अनुमति देता है :

from heapq import nlargest

stats = {'a':1000, 'b':3000, 'c': 100}

res1 = nlargest(1, stats, key=stats.__getitem__)  # ['b']
res2 = nlargest(2, stats, key=stats.__getitem__)  # ['b', 'a']

res1_val = next(iter(res1))                       # 'b'

नोट dict.__getitem__सिंटैक्टिक शुगर द्वारा कहा जाने वाला तरीका है dict[]। इसका विरोध करने पर dict.get, KeyErrorयदि कोई कुंजी नहीं मिली है, तो यह वापस आ जाएगी ।


4

max((value, key) for key, value in stats.items())[1]


1
यह डुप्लिकेट अधिकतम मानों के साथ कुंजी द्वारा आदेश देगा। जो वांछित हो या न हो।
रॉब रोज

2

+1 से @Aric Coady का सबसे सरल समाधान।
और यादृच्छिक तरीके से शब्दकोश में अधिकतम मूल्य वाली कुंजियों में से एक का चयन करने का एक तरीका:

stats = {'a':1000, 'b':3000, 'c': 100, 'd':3000}

import random
maxV = max(stats.values())
# Choice is one of the keys with max value
choice = random.choice([key for key, value in stats.items() if value == maxV])


1

कैसा रहेगा:

 max(zip(stats.keys(), stats.values()), key=lambda t : t[1])[0]

3
zip(stats.keys(), stats.values())लिखने का एक लंबा तरीका है stats.items()। एक बार जब आप उस बदलाव को कर लेते हैं, तो आपका उत्तर लगभग कई पुराने उत्तरों के समान होगा ।
तिजोरी

सहमत, मुझे पता नहीं था कि आइटम () ज़िप के समान हैं
user2399453

itemsजैसा है वैसा नहीं है zip। यह सिर्फ वही परिणाम पैदा करता है।
पॉल रूनी

0

मैंने स्वीकृत उत्तर का परीक्षण किया और @wolf का सबसे बुनियादी लूप के खिलाफ सबसे तेज़ समाधान और लूप दोनों की तुलना में तेज़ था:

import time
import operator


d = {"a"+str(i): i for i in range(1000000)}

def t1(dct):
    mx = float("-inf")
    key = None
    for k,v in dct.items():
        if v > mx:
            mx = v
            key = k
    return key

def t2(dct):
    v=list(dct.values())
    k=list(dct.keys())
    return k[v.index(max(v))]

def t3(dct):
    return max(dct.items(),key=operator.itemgetter(1))[0]

start = time.time()
for i in range(25):
    m = t1(d)
end = time.time()
print ("Iterating: "+str(end-start))

start = time.time()
for i in range(25):
    m = t2(d)
end = time.time()
print ("List creating: "+str(end-start))

start = time.time()
for i in range(25):
    m = t3(d)
end = time.time()
print ("Accepted answer: "+str(end-start))

परिणाम:

Iterating: 3.8201940059661865
List creating: 6.928712844848633
Accepted answer: 5.464320182800293

0

वैज्ञानिक अजगर उपयोगकर्ताओं के लिए, यहां पंडों का उपयोग करके एक सरल समाधान दिया गया है:

import pandas as pd
stats = {'a': 1000, 'b': 3000, 'c': 100}
series = pd.Series(stats)
series.idxmax()

>>> b

0

मामले में आपके पास एक ही मूल्य के साथ एक से अधिक कुंजी है, उदाहरण के लिए:

stats = {'a':1000, 'b':3000, 'c': 100, 'd':3000, 'e':3000}

आप अधिकतम मान के साथ सभी कुंजी के साथ एक संग्रह प्राप्त कर सकते हैं:

from collections import defaultdict
from collections import OrderedDict

groupedByValue = defaultdict(list)
for key, value in sorted(stats.items()):
    groupedByValue[value].append(key)

# {1000: ['a'], 3000: ['b', 'd', 'e'], 100: ['c']}

groupedByValue[max(groupedByValue)]
# ['b', 'd', 'e']

0

दृष्टिकोण को समझने के लिए बहुत सरल:

dict = { 'a':302, 'e':53, 'g':302, 'h':100 }
max_value_keys = [key for key in dict.keys() if dict[key] == max(dict.values())]
print(max_value_keys) # prints a list of keys with max value

आउटपुट: ['ए', 'जी']

अब आप केवल एक कुंजी चुन सकते हैं:

maximum = dict[max_value_keys[0]]
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.