在字典中获取最大值的键？答案

【问题标题】：Getting key with maximum value in dictionary?在字典中获取最大值的键？
【发布时间】：2010-09-21 01:29:55
【问题描述】：

我有一个dictionary：键是字符串，值是整数。

例子：

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

我想得到'b' 作为答案，因为它是具有更高价值的键。

我使用带有反向键值元组的中间列表进行了以下操作：

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

这是更好（甚至更优雅）的方法吗？

【问题讨论】：

呃，max(stats)怎么了？
max(stats) 将使用标签作为键（它将返回 'c'，因为这是最大标签），max(stats, key=lambda key: stats[key]) 是 OP 所追求的（它将返回 'b'，标签最大索引值）。是不是更清楚了？

标签： python dictionary max

【解决方案1】：

您可以为此使用operator.itemgetter：

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

而不是在内存中建立一个新的列表使用stats.iteritems()。 max() 函数的 key 参数是一个计算用于确定如何对项目进行排名的键的函数。

请注意，如果您有另一个键值对 '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'

【讨论】：

更干净，我认为= max(stats.iterkeys(), key=(lambda key: stats[key]))
为什么不直接使用key=lambda x: x[1]？
在 python 3 中 @Lucretiel 的（拼写正确）解决方案失败。它应该是： max(stats.keys(), key=(lambda k: stats[k])) 因为 keys() 现在可以自动完成 iterkeys() 过去的工作。
没错。有趣的是，在 Python 2 和 3 中都可以使用的内存效率完全一样的解决方案是：max(stats, key=lambda key: stats[key])
老实说，我认为 cmets 有更清洁和更好的解决方案。

【解决方案2】：

这是另一个：

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

函数key 只返回应该用于排名的值，max() 立即返回需要的元素。

【讨论】：

.iterkeys 在您的答案中不需要（它是迭代字典时的默认值）。但是，请注意 .iteritems 方法在一个步骤中同时获取键和值，因此不需要 .iterkeys 所需的每个键额外的 getitem。
这是一个很好的答案，因为它非常清楚发生了什么，因此很容易扩展到其他情况。
在python3版本中：max(stats, key=lambda k: stats[k])

【解决方案3】：

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

如果你不关心价值（我会感到惊讶，但是）你可以这样做：

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

与表达式末尾的 [0] 下标相比，我更喜欢元组解包。我从不太喜欢 lambda 表达式的可读性，但发现它比 operator.itemgetter(1) 恕我直言。

【讨论】：

_ 可以用来代替ignored。
@J.F.Sebastian 我同意ignored 看起来很丑，但有些人反对使用_ 有几个原因。我认为第一个 sn-p 很好，即使你忽略了这个值

【解决方案4】：

max(stats, key=stats.get)

【讨论】：

如果你真的想这样做，你可以这样做stats[max(stats, key=stats.get)]
@scottmrogowski，ss。根据要求，它为密钥提供最大值。最大值就是 max(stats.values())。
这应该是答案，因为它是最简单的，并且正是 OP 所要求的。
@Coady 如果两个键（具有相同的值）之间存在关联怎么办？我想两个都买，但我只买了一个。
@oba2311 max_value = max(stats.values()); {key for key, value in stats.items() if value == max_value}

【解决方案5】：

我已经测试了许多变体，这是返回具有最大值的 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）

【讨论】：

这看起来很可疑。 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
同意 f1 就像 f7。使用 ipython %timeit 进行了测试，两者在我的机器上的 python 2.7 上都具有相同的性能。测试：f1 - 18 µs 每圈测试：f2 - 33.7 µs 每圈测试：f3b - 50 µs 每圈测试：f4b - 30.7 µs 每圈测试：f5 - 28 µs 每圈测试：f6 - 23 µs 每圈测试： f7 - 每个循环 18 µs 测试：f8 - 每个循环 43.9 µs 测试：f4 - 每个循环 2.16 ms 测试：f3 - 每个循环 2.29 ms
f1 也适用于 max(d, key) 不可用的地方。
我认为 dict 是未排序的，d.keys 和 d.values 理论上不能按不同的顺序排列吗？
列表复制解决方案对我来说很臭。具有数千或数百万个条目的 dict 的性能如何？

【解决方案6】：

Counter = 0
for word in stats.keys():
    if stats[word]> counter:
        Counter = stats [word]
print Counter

【讨论】：

【解决方案7】：

鉴于不止一个条目我有最大值。我会列出以最大值为值的键。

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

【讨论】：

您的解决方案没问题，但计算最大值的次数与字典中的项目数一样多。如果计算 max 很昂贵（例如，一个 LONG 字典），如果你想要一个单行，我会推荐 [key for m in [max(stats.values())] for key,val in stats.iteritems() if val == m]，否则请预先计算 m = ...。
简短说明：对于 python 3，使用 stats.items() 而不是 stats.iteritems()。

【解决方案8】：

通过所选答案中的 cmets 迭代解决方案...

在 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。
因为 keys() 在 python 2 中不返回迭代器，因此会影响性能

【解决方案9】：

如果您只需要知道具有最大值的键，则可以不使用 iterkeys 或 iteritems，因为在 Python 中通过字典进行迭代就是通过它的键进行迭代。

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

编辑：

来自 cmets，@user1274878：

我是 python 新手。你能分步骤解释你的答案吗？

是的……

最大

max(iterable[, key])

max(arg1, arg2, *args[, key])

返回可迭代项中的最大项或两个或多个参数中的最大项。

可选的key 参数描述了如何比较元素以获得它们之间的最大值：

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

将比较返回的值。

字典

Python dict 是一个哈希表。 dict 的键是声明为键的对象的哈希。由于性能原因，迭代虽然 dict 实现为通过它的键进行迭代。

因此我们可以用它来摆脱获取keys列表的操作。

关闭

在另一个函数中定义的函数称为嵌套函数。嵌套函数可以访问封闭范围的变量。

stats 变量可通过lambda 函数的__closure__ 属性作为指向父作用域中定义的变量值的指针。

【讨论】：

@I159：我是 python 新手。你能分步解释你的答案吗

【解决方案10】：

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.

【讨论】：

【解决方案11】：

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

【讨论】：

【解决方案12】：

我针对一个非常基本的循环测试了接受的答案和@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

【讨论】：

【解决方案13】：

怎么样：

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

【讨论】：

zip(stats.keys(), stats.values()) 只是写stats.items() 的更长的方式。做出更改后，您的答案将与几个较早的答案几乎相同。
同意，我不知道 items() 与 zip 相同
items 与 zip 不同。它只是产生相同的结果。

【解决方案14】：

获取字典stats的最大key/value：

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)

当然，如果你只想从结果中获取键或值，你可以使用元组索引。比如获取最大值对应的key：

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

说明

Python 3 中的字典方法items() 返回字典的view object。当这个视图对象被 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's answer 上的 cmets。
使用的代码在 Python 3.5.2 和 Python 2.7.10 上进行了测试。

【讨论】：

【解决方案15】：

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

【讨论】：

这将按具有重复最大值的键排序。这可能需要也可能不需要。

【解决方案16】：

d = {'A': 4,'B':10}

min_v = min(zip(d.values(), d.keys()))
# min_v is (4,'A')

max_v = max(zip(d.values(), d.keys()))
# max_v is (10,'B')

【讨论】：

【解决方案17】：

例子：

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

如果你想用它的键找到最大值，也许以下可能很简单，没有任何相关的功能。

max(stats, key=stats.get)

输出是具有最大值的键。

【讨论】：

这个解决方案的测试速度比 max(stats, key=lambda key: stats[key]) 快

【解决方案18】：

我到这里来寻找如何根据mydict.values() 的值返回mydict.keys()。我希望返回前 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 log (n) 的运行时间，因为您关心的是一堆不是最大值的值。使用 max 函数将导致运行时间仅为 n，这要快得多。
@PeterGraham 几乎这里的每个解决方案（包括接受的答案）都使用max()。很明显这是最快的。我想我会提供一个具有切片优势的不同解决方案，这在当时对我更有用

【解决方案19】：

堆队列是一种通用解决方案，它允许您提取按值排序的前 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，这在此处不会发生。

【讨论】：

【解决方案20】：

我对这些答案都不满意。 max 总是选择具有最大值的第一个键。字典可以有多个具有该值的键。

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

发布此答案以防万一。请参阅下面的 SO 帖子

Which maximum does Python pick in the case of a tie?

【讨论】：

此解决方案返回所有具有最大值的键。 max(stats, key=stats.get) 只返回它找到的第一个键。

【解决方案21】：

如果您有多个具有相同值的键，例如：

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

【讨论】：

好点！这个解决方案要简单得多：stackoverflow.com/a/47861776/10836415

【解决方案22】：

对于科学 python 用户，这里有一个使用 Pandas 的简单解决方案：

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

>>> b

【讨论】：

【解决方案23】：

你可以使用：

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

【讨论】：

这应该是公认的答案，比使用运算符简单得多
这个时间复杂度是多少？
迄今为止最好的答案：为了解释，d.items() 创建了一个元组，而 lambda 函数使用元组的值作为要评估的对象，而不是键。
这是所有列出的最佳/最简单的答案。

【解决方案24】：

更容易理解的方法：

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

输出： ['a', 'g']

现在你只能选择一个键：

maximum = mydict[max_value_keys[0]]

【讨论】：

【解决方案25】：

max(stats, key=stats.get) if stats else None

stats 可能是一个空字典，因此在这种情况下仅使用 max(stats, key=stats.get) 会中断。

【讨论】：

很棒的答案！我能想象到的最简单的事情。
知道时间复杂度是多少吗？
@RaGe 时间复杂度为 O(n)

【解决方案26】：

如果 stats 为空，可以在找到值键之前检查条件，例如，

stats = {'a':1000, 'b':3000, 'c': 100}
max_key = None
if bool(stats):
   max_key = max(stats, key=stats.get)
print(max_key)

这可以先检查字典是否为空，然后处理。

>>> b

【讨论】：

【解决方案27】：

试试这个：

sorted(dict_name, key=dict_name.__getitem__, reverse=True)[0]

【讨论】：

【解决方案28】：

以下是从给定字典中提取具有最大值的键的两种简单方法

import time
stats = {
   "a" : 1000,
   "b" : 3000,
   "c" : 90,
   "d" : 74,
   "e" : 72,
 }

start_time = time.time_ns()
max_key = max(stats, key = stats.get)
print("Max Key [", max_key, "]Time taken (ns)", time.time_ns() - start_time)

start_time = time.time_ns()
max_key = max(stats, key=lambda key: stats[key])
print("Max Key with Lambda[", max_key, "]Time taken (ns)", time.time_ns() - start_time)

输出

Max Key [ b ] Time taken (ns) 3100
Max Key with Lambda [ b ] Time taken (ns) 1782

使用 Lambda 表达式的解决方案似乎对于较小的输入表现更好。

【讨论】：