我有一个dictionary：键是字符串，值是整数。
例子：
1stats = {'a':1000, 'b':3000, 'c': 100}
我想得到'b'作为答案，因为它是具有更高值的键。
我使用一个带有反转键值元组的中间列表执行了以下操作：
1
2inverse = [(value, key) for key, value in stats.items()]
print max(inverse)[1]
这是更好(甚至更优雅)的方法吗？
@杰德加上埃多克斯1〔0〕似乎反驳了你所说的话。enumerate(stats)只是按存储顺序列出字典键。
@Druckles你是完全正确的，我记不得你曾经有过这样的误解。废话注释已删除。
呃，max(stats)出了什么问题？
max(stats)将使用标签作为键(它将返回'c'，因为这是最大标签)，max(stats, key=lambda key: stats[key])是op的后面(它将返回'b'，最大索引值的标签)。有更清楚的吗？
1max(stats, key=stats.get)
如果你真的想这样做的话，你可以这样做。
@斯科特·罗戈夫斯基，SS.它按要求为键提供最大值。最大值将只是max(stats.values())。
这应该是答案，因为这是最简单的，也是OP要求的。
@考迪，如果两个键(具有相同的值)之间有联系怎么办？我想两个都买，但我只买一个。
@oba2311-max_value = max(stats.values()); {key for key, value in stats.items() if value == max_value}。
完美答案！我不理解@cracksmoker9000关于这是不正确的原因的评论
不错的Python。
您可以使用operator.itemgetter进行以下操作：
1
2
3import operator
stats = {'a':1000, 'b':3000, 'c': 100}
max(stats.iteritems(), key=operator.itemgetter(1))[0]
而不是在内存中构建一个新的列表，而是使用stats.iteritems()。max()函数的key参数是一个函数，用于计算用于确定如何对项目排序的键。
请注意，如果要使用另一个键值对"d"：3000，则此方法将只返回这两个键值对中的一个，即使它们都具有最大值。
1
2
3
4>>> import operator
>>> stats = {'a':1000, 'b':3000, 'c': 100, 'd':3000}
>>> max(stats.iteritems(), key=operator.itemgetter(1))[0]
'b'
如果使用python3：
1
2>>> max(stats.items(), key=operator.itemgetter(1))[0]
'b'
请注意，这只适用于python2.5及更高版本，在此之前，max没有关键字。
更干净，我想=max(stats.iterkeys(), key=(lambda key: stats[key]))。
请添加信息，说明它仅适用于python 2.5或更新版本。
@Lucretiel的答案更好(不需要导入操作员)。对于那些复制粘贴的人，他拼错了lambda(而不是lamda)
为什么不直接使用key=lambda x: x[1]？
在python 3@lucretiel(拼写正确)中，解决方案失败。它应该是：max(stats.keys()，key=(lambda k:stats[k])，因为keys()现在可以自动执行iterkeys()所做的操作。
你就是这样。有趣的是，在python 2和python 3中同样有效的内存效率解决方案是：max(stats, key=lambda key: stats[key])。
如果你想返回几个等价的max键怎么办？
@Lucretiel和max(stats, key=stats.get)怎么样？我在这里找到了它：stackoverflow.com/questions/12540817/&hellip；，到目前为止它给了我很好的结果。
@艾蒙福涅：这有点棘手。我先从sorted(stats, key=lambda k: stats[k], reverse=True)开始。从那里我要么做一个itertools.groupby，要么用手摇某种发电机。@TomasyAny很好，如果你出于某种原因反对lambda s(你肯定不是唯一的一个)，就避免使用lambda。就我个人而言，我觉得不太清楚；我喜欢lambda的直言不讳。
@AymonFournier这里有一个Python3中的O(N)解决方案：max_val = max(stats.values()); keys = (k for k, v in stats.items() if v == max_val)
@Lucretiel我使用的是python 2.7，这个解决方案在那里似乎不起作用。map='a'：3，'b'：3，'c'：3，'d'：3。p=max(map.keys()，key=(lambda项：map[项])。这会产生一个错误，说明：typeerror:"builtin_function_or_method"对象没有属性"getitem"
@gauravkumar map是python中的保留名称。似乎您正在用map = ...覆盖它，但该错误表明您无论如何都试图在内置map函数上调用map[key]。请使用其他变量名重试。
在python3中将stats.iteritems()改为stats.items()。
我已经测试了许多变体，这是用max值返回dict键的最快方法：
1
2
3
4
5
6def 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))]
为了给你一个想法，这里有一些候选方法：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42def 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)
测试字典：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28d1={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下的测试结果：
1
2
3
4
5
6
7
8
9
10
11rate/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下：
1
2
3
4
5
6
7
8
9
10
11rate/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% --
您可以看到，在python 3.2和2.7下，f1是最快的(或者更完整地说，在本文的顶部是keywithmaxval)。
哇，回答得很彻底。我在测试函数列表中没有看到您建议的方法？那是F1吗？
这看起来可疑。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每循环测试：F7-18；S每循环测试：F8-43.9；S每循环测试：F7-18 35181；S每循环测试：F8-18 35181；S每循环测试：F8-43.9；S每循环测试：F8-43.9 f4-2.16 ms/回路测试：f3-2.29 ms/Lo运算
当max(d，key)不可用时，f1也适用。
我认为dict是未排序的，D.keys和D.values理论上不能按不同的顺序排序吗？
列表复制解决方案对我来说很难闻。上千条或上百万条口述的表现如何？
@我知道tuple比python中的list快(这是它们的优势之一)
简直不可思议。你信任所有的StackOverflow海报。
@迪马特，你说得对。我就是这样。
没关系。他们都是O(非签名)
@但有些是O(N)：)
如果您只需要知道一个具有max值的键，那么您可以不使用iterkeys或iteritems，因为在python中通过字典迭代就是通过它的键进行迭代。
1max_key = max(stats, key=lambda k: stats[k])
编辑：
从评论中，@user1274878：
I am new to python. Can you please explain your answer in steps?
是的。。。最大值
max(iterable[, key])
max(arg1, arg2, *args[, key])
Return the largest item in an iterable or the largest of two or more arguments.
可选的key参数描述了如何比较元素以获得最大值：
1lambda : return
将比较返回值。双关语
python dict是一个哈希表。dict的键是声明为键的对象的哈希。由于性能原因，虽然dict是通过它的键作为迭代实现的。
因此，我们可以使用它来消除获取密钥列表的操作。关闭
A function defined inside another function is called a nested function. Nested functions can access variables of the enclosing scope.
通过lambda函数的__closure__属性提供的stats变量，作为指向父范围中定义的变量值的指针。
@我是Python的新手。你能分步解释一下你的答案吗
这是另一个：
1
2stats = {'a':1000, 'b':3000, 'c': 100}
max(stats.iterkeys(), key=lambda k: stats[k])
函数key只返回用于排名的值，max()立即返回所需元素。
.iterkeys不需要出现在您的答案中(它是迭代dict时的默认值)。但是，请注意，.iteritems方法在一个步骤中同时获取键和值，因此不需要根据需要使用.iterkeys为每个键额外获取getitem。
这是一个很好的答案，因为它非常清楚发生了什么，因此很容易扩展到其他情况。
1key, value = max(stats.iteritems(), key=lambda x:x[1])
如果你不在乎价值(我会很惊讶，但是)，你可以：
1key, _ = max(stats.iteritems(), key=lambda x:x[1])
比起表达式末尾的[0]下标，我更喜欢元组解包。我从来都不太喜欢lambda表达式的可读性，但发现它比operator.itemgetter(1)imho更好。
可以用_代替ignored。
@J.F.Sebastian我同意ignored看起来很难看，但有些人出于几个原因反对使用_。我认为第一个片段是好的，即使你忽略了它的值
为什么在key中使用x[1]，value=max(stats.iteritems()，key=lambda x:x[1])？
这是一个非常好的解决方案…找到这个花了很多时间。
考虑到不止一个条目，我有最大值。我将列出以max值作为其值的键。
1
2
3>>> 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"和任何其他max键。
注：对于python 3，使用stats.items()而不是stats.iteritems()
您的解决方案是可以的，但计算最大值的次数与字典中的项目相同。如果计算max很昂贵(例如，一本长字典)，如果您需要一行程序，我建议使用[key for m in [max(stats.values())] for key,val in stats.iteritems() if val == m]，否则提前计算m = ...。
简而言之：对于python 3，使用stats.items()而不是stats.iteritems()。
例子：
1stats = {'a':1000, 'b':3000, 'c': 100}
如果您想用它的键找到最大值，那么下面的操作可能很简单，没有任何相关的函数。
1max(stats, key=stats.get)
输出是具有最大值的键。
你的解决方案是最清楚的！
此解决方案的测试速度快于max(stats，key=lambda key:stats[key])
要获取字典EDOCX1的最大键/值(0)：
1stats = {'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'
解释
python 3中的dictionary方法items()返回dictionary的视图对象。当这个视图对象被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()来实现性能。
笔记
这个答案是基于对攀岩的评论，就像Spyder的答案。
使用的代码在python 3.5.2和python 2.7.10上进行了测试。
根据所选答案中的注释迭代解决方案…
在Python 3中：
1max(stats.keys(), key=(lambda k: stats[k]))
在Python 2中：
1max(stats.iterkeys(), key=(lambda k: stats[k]))
您的python 3解决方案也适用于python 2.7。
我不知道为什么要为python 2添加单独的解决方案…
因为keys()不返回python 2中的迭代器，因此会影响性能
1
2
3
4
5
6
7d = {'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')
用collections.Counter你可以
1
2
3
4
5>>> import collections
>>> stats = {'a':1000, 'b':3000, 'c': 100}
>>> stats = collections.Counter(stats)
>>> stats.most_common(1)
[('b', 3000)]
如果合适的话，您可以从一个空的collections.Counter开始并添加到它上面。
1
2
3
4>>> stats = collections.Counter()
>>> stats['a'] += 1
:
etc.
我到这里来是想看看如何根据mydict.values()的价值返回mydict.keys()。不是只返回一个键，而是返回值的前x个数字。
此解决方案比使用max()函数简单，您可以轻松更改返回的值的数目：
1
2
3
4stats = {'a':1000, 'b':3000, 'c': 100}
x = sorted(stats, key=(lambda key:stats[key]), reverse=True)
['b', 'a', 'c']
如果您想要一个最高级别的密钥，只需使用索引：
1
2x[0]
['b']
如果您想要排名前两位的密钥，只需使用列表切片：
1
2x[:2]
['b', 'a']
我有和你一样的问题。！你找到答案了吗？戎
谢谢，非常优雅，我不记得Max允许"key"参数。
顺便说一句，要得到正确的答案("b")，必须是：
1
2
3import operator
stats = {'a':1000, 'b':3000, 'c': 100}
max(stats.iteritems(), key=operator.itemgetter(1))[0]
对，max()返回键/值对。
max((value, key) for key, value in stats.items())[1]
这将按具有重复最大值的键排序。可能需要，也可能不需要。
+1到@aric coady最简单的解决方案。还有一种随机选择字典中最大值的键的方法：
1
2
3
4
5
6stats = {'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
2
3
4
5Counter = 0
for word in stats.keys():
if stats[word]> counter:
Counter = stats [word]
print Counter
堆队列是一种通用的解决方案，它允许您提取按值排序的前n个键：
1
2
3
4
5
6
7
8from 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，而在这里无法找到密钥。
我用一个非常基本的循环测试了公认的答案和@thewolf最快的解决方案，循环速度比两者都快：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40import 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))
结果：
1
2
3Iterating: 3.8201940059661865
List creating: 6.928712844848633
Accepted answer: 5.464320182800293
怎么样：
1max(zip(stats.keys(), stats.values()), key=lambda t : t[1])[0]
zip(stats.keys(), stats.values())只是编写stats.items()的一个较长的方法。一旦你做出了改变，你的答案将几乎与几个老答案相同。
同意，我不知道items()与zip相同
items与zip不同。它只会产生相同的结果。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
