我有一个字典,其中键是字符串,值是整数。

stats = {'a': 1, 'b': 3000, 'c': 0}

如何获得具有最大值的键?在这种情况下,它是'b'。


有没有比使用带有反向键值元组的中间列表更好的方法?

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

当前回答

堆队列是一个通用的解决方案,它允许你提取按值排序的前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相反。如果没有找到键,它将返回KeyError,这在这里是不可能发生的。

其他回答

只是添加一个你想要选择某些键而不是所有键的情况:

stats = {'a':1000, 'b':3000, 'c': 100, 'd':3000, 'e':3000}
keys_to_search = ["a", "b", "c"]

max([k for k in keys_to_search], key=lambda x: stats[x])```

根据所选答案中的注释迭代解决方案…

在Python 3中:

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

在Python 2中:

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

你可以使用:

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

试试这个:

sorted(dict_name, key=dict_name.__getitem__, reverse=True)[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