รับคีย์ด้วยค่าสูงสุดในพจนานุกรมหรือไม่


867

ฉันมีdictionary: คีย์คือสตริงค่าเป็นจำนวนเต็ม

ตัวอย่าง:

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

ฉันต้องการได้'b'รับคำตอบเนื่องจากเป็นกุญแจสำคัญที่มีมูลค่าสูงกว่า

ฉันทำสิ่งต่อไปนี้โดยใช้รายการระดับกลางที่มี tuples คีย์ - ค่าที่กลับรายการ:

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

นั่นเป็นวิธีที่ดีกว่า (หรือสวยงามกว่า)


1
เอ่อมีอะไรผิดปกติกับmax(stats)?
John Red

12
max(stats)จะใช้เลเบลเป็นคีย์ (มันจะคืนค่า'c'เนื่องจากเป็นเลเบลสูงสุด) max(stats, key=lambda key: stats[key])คือสิ่งที่ OP ใช้หลังจาก (ซึ่งจะส่งคืน'b'เลเบลของค่าที่ทำดัชนีสูงสุด) ชัดเจนกว่านี้ไหม?
Atcold

คำตอบ:


609

คุณสามารถใช้operator.itemgetterสำหรับ:

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

stats.iteritems()และแทนที่จะสร้างรายการใหม่ในการใช้งานหน่วยความจำ keyพารามิเตอร์กับmax()ฟังก์ชั่นเป็นฟังก์ชันที่คำนวณสำคัญที่จะใช้ในการกำหนดวิธีการที่รายการอันดับหนึ่ง

โปรดทราบว่าหากคุณต้องมีคู่คีย์ - ค่า 'd' อีก: 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'

242
แม้แต่คนที่ทำความสะอาดฉันก็คิดว่า =max(stats.iterkeys(), key=(lambda key: stats[key]))
Lucretiel

18
ทำไมไม่ใช้เพียงkey=lambda x: x[1]?
BenDundee

43
ใน python 3 @ Lucretiel ของการแก้ปัญหา (สะกดถูกต้อง) ล้มเหลว ควรเป็น: max (stats.keys (), key = (lambda k: stats [k])) เนื่องจาก keys () ตอนนี้ทำสิ่งที่ iterkeys () ใช้ทำโดยอัตโนมัติ
วัตสัน

73
คุณคือ ที่น่าสนใจ, การแก้ปัญหาที่ว่าเป็นหน่วยความจำที่มีประสิทธิภาพและใช้งานได้ทั้งในหลาม 2 และ 3 คือ:max(stats, key=lambda key: stats[key])
Lucretiel

3
สุจริตฉันคิดว่าความคิดเห็นมีวิธีที่สะอาดและดีกว่า
Augusto Gonzalez

1179
max(stats, key=stats.get)

17
หากคุณต้องการทำเช่นนี้จริงๆคุณสามารถทำได้stats[max(stats, key=stats.get)]
CrackSmoker9000

81
@scottmrogowski, ss มันให้คีย์ที่มีค่าสูงสุดตามที่ถาม ค่าสูงสุดจะเป็นเพียง max (stats.values ​​())
A. Coady

25
นี่ควรเป็นคำตอบเพราะมันง่ายที่สุดและเป็นสิ่งที่ OP ต้องการ
ihatecache

4
@Coady จะเกิดอะไรขึ้นหากมีการผูกระหว่างสองปุ่ม (ด้วยค่าเดียวกัน) ฉันต้องการได้ทั้งสองอย่าง แต่ได้เพียงอันเดียว
oba2311

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

208

ฉันได้ทดสอบชุดรูปแบบมากมายและนี่เป็นวิธีที่เร็วที่สุดในการส่งคืนคีย์ dict ด้วยค่าสูงสุด:

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}

และผลการทดสอบภายใต้ Python 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%     --

และภายใต้ Python 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เร็วที่สุดภายใต้ Python 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
Reinstate Monica

1
เห็นด้วย f1 เหมือน f7 ทำการทดสอบด้วย ipython% timeit และทั้งสองอย่างนั้นมาพร้อมกับประสิทธิภาพการทำงานเดียวกันบนเครื่องของฉันใน python 2.7 การทดสอบ: f1 - 18 pers ต่อลูปการทดสอบ: f2 - 33.7 µs ต่อลูปการทดสอบ: f3b - 50 pers ต่อลูปการทดสอบ: f4b - 30.7 µs ต่อการทดสอบลูป: f5 - 28 pers ต่อการทดสอบห่วง: f6 - 23 µs ต่อการทดสอบห่วง f7 - 18 pers ต่อการทดสอบลูป: f8 - 43.9 pers ต่อลูปการทดสอบ: f4 - 2.16 ms ต่อการทดสอบลูป: f3 - 2.29 ms ต่อลูป
Joop

f1 สามารถใช้งานได้ทุกที่ไม่สามารถใช้ max (d, key) ได้
Nikos Alexandris

5
ฉันคิดว่า dict นั้นไม่ได้เรียงลำดับ d.keys และ d.values ​​ในทางทฤษฎีไม่สามารถสั่งต่างกันได้
Dimath

1
โซลูชันรายการคัดลอกส่งกลิ่นฉัน ประสิทธิภาพของ dict ที่มีหลายพันหรือหลายล้านรายการเป็นอย่างไร
Lucretiel

63

หากคุณจำเป็นต้องรู้เพียงที่สำคัญที่มีค่าสูงสุดที่คุณสามารถทำมันได้โดยไม่ต้องiterkeysหรือiteritemsเพราะย้ำผ่านพจนานุกรมในหลามเป็นซ้ำผ่านคีย์ของมัน

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

แก้ไข:

จากความคิดเห็น @ user1274878:

ฉันยังใหม่กับงูหลาม คุณช่วยอธิบายคำตอบของคุณเป็นขั้นตอนได้ไหม?

อ๋อ ...

สูงสุด

สูงสุด (iterable [, สำคัญ])

สูงสุด (arg1, arg2, * args [, key])

ส่งคืนไอเท็มที่ใหญ่ที่สุดใน iterable หรืออาร์กิวเมนต์ตั้งแต่สองอาร์กิวเมนต์ขึ้นไป

keyอาร์กิวเมนต์ทางเลือกอธิบายวิธีเปรียบเทียบองค์ประกอบเพื่อให้ได้ประโยชน์สูงสุด

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

ค่าที่ส่งคืนจะถูกเปรียบเทียบ

Dict

Python Dict เป็นตารางแฮช คีย์ของ dict คือการแฮชของวัตถุที่ประกาศเป็นคีย์ เนื่องจากเหตุผลด้านประสิทธิภาพการทำซ้ำแม้ว่า dict นำมาใช้เป็นซ้ำผ่านมันเป็นกุญแจสำคัญ

ดังนั้นเราสามารถใช้เพื่อกำจัดการดำเนินการเพื่อรับรายการคีย์

การปิด

ฟังก์ชั่นที่กำหนดไว้ภายในฟังก์ชั่นอื่นเรียกว่าฟังก์ชั่นที่ซ้อนกัน ฟังก์ชั่นที่ซ้อนกันสามารถเข้าถึงตัวแปรของขอบเขตการปิดล้อม

statsตัวแปรผ่านใช้ได้__closure__แอตทริบิวต์ของlambdaฟังก์ชั่นเป็นตัวชี้ไปยังค่าของตัวแปรที่กำหนดไว้ในขอบเขตของผู้ปกครอง


1
@ I159: ฉันใหม่กับงูใหญ่ คุณช่วยอธิบายคำตอบของคุณเป็นขั้นตอนได้
ไหม

57

ตัวอย่าง:

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

หากคุณต้องการหาค่าสูงสุดด้วยกุญแจของมันบางที follwing อาจเป็นเรื่องง่ายโดยไม่มีฟังก์ชั่นที่เกี่ยวข้อง

max(stats, key=stats.get)

เอาท์พุทเป็นกุญแจสำคัญที่มีค่าสูงสุด


โซลูชันนี้ทดสอบเร็วกว่าสูงสุด (สถิติ, คีย์ = คีย์แลมบ์ดา: สถิติ [คีย์])
Ta946

46

นี่คืออีกหนึ่ง:

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

ฟังก์ชันkeyส่งคืนค่าที่ควรใช้สำหรับการจัดอันดับและmax()ส่งคืนองค์ประกอบที่ต้องการทันที


10
ไม่จำเป็นต้องใช้คีย์ตัวเลือกในคำตอบของคุณ อย่างไรก็ตามโปรดทราบว่าวิธีการ. ititems จะดึงทั้งคีย์และค่าในขั้นตอนเดียวดังนั้นจึงไม่จำเป็นต้องมีgetitemพิเศษต่อคีย์ตามที่ต้องการด้วย. keykey
tzot

นี่เป็นคำตอบที่ดีเพราะชัดเจนว่าเกิดอะไรขึ้นและง่ายต่อการขยายสู่สถานการณ์อื่น
Leopd

ในเวอร์ชัน 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ดูน่าเกลียด แต่บางคนไม่ใช้_ด้วยเหตุผลหลายประการ ฉันคิดว่าข้อมูลโค้ดแรกนั้นใช้ได้แม้ว่าคุณจะไม่สนใจค่า
jamylak

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

นี่จะให้ 'b' และคีย์สูงสุดอื่น ๆ

หมายเหตุ: สำหรับ python 3 ให้ใช้stats.items()แทนstats.iteritems()


9
วิธีการแก้ปัญหาของคุณก็โอเค แต่คำนวณค่าสูงสุดเท่าที่มีรายการใน dict หากการคำนวณmaxมีราคาแพง (เช่นพจนานุกรม LONG) ฉันอยากจะแนะนำ[key for m in [max(stats.values())] for key,val in stats.iteritems() if val == m]ถ้าคุณต้องการซับในตัวอื่นหรือคำนวณm = ...ล่วงหน้า
gboffi

4
เพียงแค่ข้อความสั้น ๆ : สำหรับ python 3 ให้ใช้ stats.items () แทน stats.iteritems ()
Susa

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
นี่ควรเป็นคำตอบที่ยอมรับได้ง่ายกว่าการใช้โอเปอเรเตอร์
Sigmatics

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)

แน่นอนถ้าคุณต้องการรับเฉพาะคีย์หรือค่าจากผลลัพธ์คุณสามารถใช้การจัดทำดัชนี tuple ตัวอย่างเช่นในการรับคีย์ที่สอดคล้องกับค่าสูงสุด:

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

คำอธิบาย

วิธีการพจนานุกรมitems()ใน Python 3 ส่งคืนวัตถุมุมมองของพจนานุกรม เมื่อวัตถุมุมมองนี้เป็นซ้ำมากกว่าโดยฟังก์ชั่นมันถัวเฉลี่ยรายการพจนานุกรมเป็นอันดับของแบบฟอร์มmax(key, value)

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

เมื่อคุณใช้lambdaนิพจน์lambda x: x[1]ในการทำซ้ำแต่ละครั้งx จะเป็นหนึ่งในสิ่งอันดับ(key, value)เป็นหนึ่งในสิ่งอันดับเหล่านี้ดังนั้นโดยการเลือกดัชนีที่ถูกต้องคุณจะเลือกว่าคุณต้องการเปรียบเทียบด้วยปุ่มหรือตามค่า

Python 2

สำหรับการออก Python 2.2+ รหัสเดียวกันจะใช้งานได้ อย่างไรก็ตามจะเป็นการดีกว่าหากใช้iteritems()วิธีพจนานุกรมแทนitems()เพื่อประสิทธิภาพ

หมายเหตุ

  • คำตอบนี้จะขึ้นอยู่กับความคิดเห็นในคำตอบของ Climbs_lika_Spyder

  • รหัสที่ใช้ถูกทดสอบใน Python 3.5.2 และ Python 2.7.10



10

ตามวิธีแก้ไขซ้ำผ่านความคิดเห็นในคำตอบที่เลือก ...

ใน Python 3:

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

ใน Python 2:

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

โซลูชันของคุณสำหรับ Python 3 ใช้งานได้กับ Python 2.7
patapouf_ai

4
เพราะ keys () ไม่ส่งคืนตัววนซ้ำในไพ ธ อน 2 ดังนั้นจึงให้ประสิทธิภาพการทำงานดีขึ้น
watsonic

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

นี่เป็นวิธีที่ไม่มีประสิทธิภาพมาก การเรียงลำดับ dict จะทำให้เกิดรันไทม์ของ n log (n) เนื่องจากคุณเกี่ยวข้องกับตัวเองด้วยค่าจำนวนมากที่ไม่ใช่ค่าสูงสุด การใช้ฟังก์ชั่นสูงสุดจะทำให้เกิดรันไทม์เพียงแค่ n ซึ่งเร็วกว่ามาก
ปีเตอร์เกรแฮม

1
@PeterGraham สวยมากทุกวิธีการแก้ปัญหาที่นี่ (รวมถึงคำตอบที่ได้รับการยอมรับ) max()การใช้งาน ชัดเจนว่าเป็นวิธีที่เร็วที่สุด ฉันคิดว่าฉันจะเสนอวิธีการแก้ปัญหาที่แตกต่างกับประโยชน์ของการแบ่งส่วนซึ่งเป็นประโยชน์กับฉันในเวลานั้น
donrondadon

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 ด้านล่าง

Python เลือกแบบใดในกรณีที่เท่ากัน?


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
ซึ่งจะเรียงลำดับตามคีย์พร้อมค่าสูงสุดซ้ำกัน ที่อาจหรืออาจไม่ต้องการ
Rob Rose

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()เป็นเพียงวิธีนานในการเขียน เมื่อคุณทำการเปลี่ยนแปลงคำตอบของคุณจะเหมือนกับคำตอบที่เก่ากว่าหลายคำ
vaultah

ตกลงฉันไม่ทราบว่ารายการ () เหมือนกับ zip
user2399453

itemszipไม่ได้เป็นเช่นเดียวกับ มันสร้างผลลัพธ์ที่เหมือนกัน
Paul Rooney

0

ฉันทดสอบคำตอบที่ยอมรับแล้วและ @ @ thewolf เป็นวิธีแก้ปัญหาที่เร็วที่สุดเมื่อเทียบกับการวนซ้ำพื้นฐานมากและการวนซ้ำนั้นเร็วกว่าทั้งสอง:

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

สำหรับผู้ใช้ python ทางวิทยาศาสตร์นี่เป็นวิธีง่ายๆในการใช้ Pandas:

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

เอาท์พุท: ['a', 'g']

ตอนนี้คุณสามารถเลือกได้หนึ่งคีย์เท่านั้น:

maximum = dict[max_value_keys[0]]
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.