获取字典中最大值的键？

你可以使用operator.itemgetter：

import operatorstats = {'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'

这里是另一个：

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

函数key简单地返回应该用于排名的值，max()立即返回所需的元素。

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

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

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

与表达式末尾的[0]下标相比，我更喜欢元组解包。我从不喜欢lambda表达式的易读性，但发现这个比operator.itemgetter（1）IMHO更好。

max(stats, key=stats.get)

我已经测试了很多变体，这是返回最大值的字典键的最快方法：

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 lambdam = 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 comprehensionm = 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     f1f4       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     f1f3       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）

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

鉴于不止一个条目我有最大值。我将列出具有最大值作为其值的键。

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

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

在Python 3中：

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

在Python 2中：

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

如果你只需要知道一个具有最大值的键，你可以在没有iterkeys或iteritems的情况下做到这一点，因为Python中的字典迭代就是通过它的键迭代。

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

编辑：

来自评论，@user1274878：

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

嗯…

最大值

max（可迭代的[， key]）

max（art1， art2，*args[， key]）最大值

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

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

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

将比较返回的值。

快译通

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

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

结束

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

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

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.

+1到@陈志立的最简单解决方案。
还有一种随机选择字典中最大值的键的方法：

stats = {'a':1000, 'b':3000, 'c': 100, 'd':3000}
import randommaxV = max(stats.values())# Choice is one of the keys with max valuechoice = random.choice([key for key, value in stats.items() if value == maxV])

我对一个非常基本的循环测试了接受的答案和@theWolf的最快解决方案，循环比两者都快：

import timeimport operator

d = {"a"+str(i): i for i in range(1000000)}
def t1(dct):mx = float("-inf")key = Nonefor k,v in dct.items():if v > mx:mx = vkey = kreturn 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.8201940059661865List creating: 6.928712844848633Accepted answer: 5.464320182800293

不如：

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

要获取字典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）

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

>>max（stats.items）， key=lambda x： x[1]）[0]`b'

补充说明

Python 3中的字典方法#0返回字典的查看对象。当这个视图对象被max函数迭代时，它会将字典项作为(key, value)形式的元组生成。

>>list（stats.items）[（'c'，100），（'b'，3000），（'a'，1000）]

当您使用#0表达式lambda x: x[1]时，在每次迭代中，x都是这些元组(key, value)之一。因此，通过选择正确的索引，您可以选择是要按键还是按值进行比较。

python2

对于Python 2.2+版本，相同的代码也可以工作。但是，为了性能，最好使用#0字典方法而不是#1。

备注

• 这一答复是基于对Climbs_lika_Spyder答复的评论。

• 使用的代码在Python 3.5.2和Python 2.7.10上进行了测试。

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

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

示例：

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

如果你想找到它的键的最大值，也许跟随可以很简单，没有任何相关的函数。

max(stats, key=stats.get)

输出是具有最大值的键。

我在这里寻找如何根据mydict.values()的值返回mydict.keys()。而不仅仅是返回一个键，我希望返回前2个值。

此解决方案比使用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键：

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，这在这里是不可能发生的。

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

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

发布这个答案，以防它帮助某人。请参阅下面的文章

在平局的情况下，Python选择哪个最大值？

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

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

你可以得到一个集合，其中包含所有具有最大值的键，如下所示：

from collections import defaultdictfrom 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']

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

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

您可以使用：

max(d, key=d.get)# which is equivalent tomax(d, key=lambda k: d.get(k))

要返回键值对，请使用：

max(d.items(), key=lambda k: k[1])

更容易理解的方法：

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

max(stats, key=stats.get, default=None)

如果stats可以是一个空字典，则仅使用max(stats, key=stats.get)将引发ValueError。

只要None不是字典中可能的键，这个答案就可以安全使用。

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

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

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

>>> b

试试这个：

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

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

import timestats = {"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) 3100Max Key with Lambda [ b ] Time taken (ns) 1782

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

只是为了添加一个情况，您想选择某些键而不是所有键：

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