堆队列是一个通用的解决方案，它允许你提取按值排序的前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，这在这里是不可能发生的。

你可以使用运算符。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'

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

我测试了接受的答案和@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

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

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表达式的解决方案似乎对较小的输入执行得更好。

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

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

>>> b