#### [SOLVED] Getting key with maximum value in dictionary?

By ricafeal

I have a `dictionary`: keys are strings, values are integers.

Example:

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

I'd like to get `'b'` as an answer, since it's the key with a higher value.

I did the following, using an intermediate list with reversed key-value tuples:

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

Is that one the better (or even more elegant) approach?

#### @jpp 2018-11-01 11:05:26

A heap queue is a generalised solution which allows you to extract the top n keys ordered by value:

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

Note `dict.__getitem__` is the method called by the syntactic sugar `dict[]`. As opposed to `dict.get`, it will return `KeyError` if a key is not found, which here cannot occur.

#### @ron g 2018-09-12 09:43:56

I got here looking for how to return `mydict.keys()` based on the value of `mydict.values()`. Instead of just the one key returned, I was looking to return the top x number of values.

This solution is simpler than using the `max()` function and you can easily change the number of values returned:

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

x = sorted(stats, key=(lambda key:stats[key]), reverse=True)
['b', 'a', 'c']
``````

If you want the single highest ranking key, just use the index:

``````x[0]
['b']
``````

If you want the top two highest ranking keys, just use list slicing:

``````x[:2]
['b', 'a']
``````

#### @astroluv 2018-10-15 23:49:27

I got the same question as yours.! Did you find the answer to that? @rong

#### @leo022 2018-08-23 04:08:56

Example:

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

if you wanna find the max value with its key, maybe follwing could be simple, without any relevant functions.

``````max(stats, key=stats.get)
``````

the output is the key which has the max value.

#### @leafonsword 2019-02-16 06:14:40

Your solution is clearest!

#### @Ta946 2019-03-09 06:08:08

this solution tested faster than max(stats, key=lambda key: stats[key])

#### @Climbs_lika_Spyder 2014-05-02 13:07:23

Given that more than one entry my have the max value. I would make a list of the keys that have the max value as their value.

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

This will give you 'b' and any other max key as well.

Note: For python 3 use `stats.items()` instead of `stats.iteritems()`

#### @gboffi 2014-12-02 22:57:53

Your solution is OK but computes the maximum value as many times as there are items in the dict. If computing `max` were expensive (e.g., a LONG dictionary) I'd recommend `[key for m in [max(stats.values())] for key,val in stats.iteritems() if val == m]` if you want an one-liner, otherwise compute `m = ...` beforehand.

#### @Susa 2018-08-04 16:41:57

Just a short note: For python 3 use stats.items() instead of stats.iteritems().

#### @priya khokher 2018-05-04 06:50:19

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

#### @unbeknown 2008-11-06 10:58:45

You can use `operator.itemgetter` for that:

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

And instead of building a new list in memory use `stats.iteritems()`. The `key` parameter to the `max()` function is a function that computes a key that is used to determine how to rank items.

Please note that if you were to have another key-value pair 'd': 3000 that this method will only return one of the two even though they both have the maximum value.

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

If using Python3:

``````>>> max(stats.items(), key=operator.itemgetter(1))[0]
'b'
``````

#### @Moe 2008-11-07 15:05:43

Note that this will only work for python2.5 and later, before that max didn't have the key keyword.

#### @Lucretiel 2012-12-16 07:22:52

Even cleaner, I think= `max(stats.iterkeys(), key=(lambda key: stats[key]))`

#### @Samveen 2013-01-03 11:29:07

Please add the info that this only works on Python 2.5 or newer.

#### @pocketfullofcheese 2013-03-01 05:45:38

@Lucretiel's answer is nicer (no need to import operator). For those of you copy-pasting, he misspelled lambda (not lamda)

#### @BenDundee 2014-01-23 22:32:00

Why not just use `key=lambda x: x[1]`?

#### @watsonic 2015-05-05 01:58:42

in python 3 @Lucretiel's (correctly spelled) solution fails. it should be: max(stats.keys(), key=(lambda k: stats[k])) since keys() now does what iterkeys() used to do automatically.

#### @Lucretiel 2015-05-05 21:56:39

Rigth you are. Interestingly, a solution that's exactly as memory efficient and works in both Python 2 and 3 is: `max(stats, key=lambda key: stats[key])`

#### @Aymon Fournier 2015-09-14 15:23:34

what if you want to return several equivalent max keys

#### @tomasyany 2015-09-28 21:17:09

@Lucretiel And what about `max(stats, key=stats.get)`? I found it here: stackoverflow.com/questions/12540817/… and it gave me good results so far.

#### @Lucretiel 2015-09-29 17:59:57

@AymonFournier: That's a little trickier. I'd start with `sorted(stats, key=lambda k: stats[k], reverse=True)`. From there I'd either do an `itertools.groupby` or handroll some kind of generator. @tomasyany That's fine, and avoids the lambda if you're opposed to lambdas for some reason (you're certainly not the only one). Personally, I find it a bit less clear; I like the explicitness of the lambda.

#### @Lucretiel 2015-09-29 18:05:08

@AymonFournier Here's an O(n) solution in Python 3: `max_val = max(stats.values()); keys = (k for k, v in stats.items() if v == max_val)`

#### @Gaurav Kumar 2016-01-11 14:50:53

@Lucretiel I am using python 2.7 and this solution don't seems to work there. map = {'a':3, 'b':3, 'c':3, 'd':3}. p =max(map.keys(), key=(lambda item:map[item])) . This produces an error saying: TypeError: 'builtin_function_or_method' object has no attribute 'getitem'

#### @Lucretiel 2016-02-13 00:28:37

@GauravKumar `map` is a reserved name in Python. It does appear that you are overwriting it with `map = ...`, but that error indicates you are attempting to call `map[key]` on the builtin `map` function anyway. Try again using a different variable name.

#### @Niranjan Sonachalam 2017-02-13 06:05:32

Change `stats.iteritems()` to `stats.items()` in Python3

#### @Jasha 2018-01-10 05:32:18

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

#### @Rob Rose 2018-03-29 21:15:36

This will order by the key with duplicate max values. That may or may not be desired.

#### @Woooody Amadeus 2017-05-20 17:11:08

+1 to @Aric Coady's simplest solution.
And also one way to random select one of keys with max value in the dictionary:

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

#### @Karim Sonbol 2017-12-17 11:28:09

To get the maximum key/value of the dictionary `stats`:

``````stats = {'a':1000, 'b':3000, 'c': 100}
``````
• Based on keys

```>>> max(stats.items(), key = lambda x: x[0]) ('c', 100)```

• Based on values

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

Of course, if you want to get only the key or value from the result, you can use tuple indexing. For Example, to get the key corresponding to the maximum value:

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

Explanation

The dictionary method `items()` in Python 3 returns a view object of the dictionary. When this view object is iterated over, by the `max` function, it yields the dictionary items as tuples of the form `(key, value)`.

```>>> list(stats.items()) [('c', 100), ('b', 3000), ('a', 1000)]```

When you use the `lambda` expression `lambda x: x[1]`, in each iteration, `x` is one of these tuples `(key, value)`. So, by choosing the right index, you select whether you want to compare by keys or by values.

Python 2

For Python 2.2+ releases, the same code will work. However, it is better to use `iteritems()` dictionary method instead of `items()` for performance.

Notes

#### @user3079275 2017-09-04 20:34:57

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

#### @vaultah 2017-09-04 20:38:16

`zip(stats.keys(), stats.values())` is just a longer way to write `stats.items()`. Once you make that change, your answer will be almost identical to several older answers.

#### @user3079275 2017-09-05 02:13:00

Agreed, I wasnt aware that items() is same as zip

#### @Paul Rooney 2017-10-25 00:06:05

`items` isn't the same as `zip`. It just produces the same result.

#### @I159 2016-02-07 17:31:32

If you need to know only a key with the max value you can do it without `iterkeys` or `iteritems` because iteration through dictionary in Python is iteration through it's keys.

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

EDIT:

From comments, @user1274878 :

I am new to python. Can you please explain your answer in steps?

Yep...

### max

max(iterable[, key])

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

Return the largest item in an iterable or the largest of two or more arguments.

The optional `key` argument describes how to compare elements to get maximum among them:

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

Returned values will be compared.

### Dict

Python dict is a hash table. A key of dict is a hash of an object declared as a key. Due to performance reasons iteration though a dict implemented as iteration through it's keys.

Therefore we can use it to rid operation of obtaining a keys list.

### Closure

A function defined inside another function is called a nested function. Nested functions can access variables of the enclosing scope.

The `stats` variable available through `__closure__` attribute of the `lambda` function as a pointer to the value of the variable defined in the parent scope.

#### @user1274878 2017-03-30 08:40:42

@I159: I am new to python. Can you please explain your answer in steps

#### @citizen2077 2017-07-11 12:50:02

I tested the accepted answer AND @thewolf's fastest solution against a very basic loop and the loop was faster than both:

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

results:

``````Iterating: 3.8201940059661865
List creating: 6.928712844848633
``````

#### @ukrutt 2016-02-23 18:58:38

With `collections.Counter` you could do

``````>>> import collections
>>> stats = {'a':1000, 'b':3000, 'c': 100}
>>> stats = collections.Counter(stats)
>>> stats.most_common(1)
[('b', 3000)]
``````

If appropriate, you could simply start with an empty `collections.Counter` and add to it

``````>>> stats = collections.Counter()
>>> stats['a'] += 1
:
etc.
``````

#### @Erika Sawajiri 2013-06-20 15:32:51

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

#### @Tim Ottinger 2008-11-07 14:41:33

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

If you don't care about value (I'd be surprised, but) you can do:

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

I like the tuple unpacking better than a [0] subscript at the end of the expression. I never like the readability of lambda expressions very much, but find this one better than the operator.itemgetter(1) IMHO.

#### @jfs 2008-11-11 21:50:30

`_` could be used instead of `ignored`.

#### @jamylak 2013-04-11 05:15:32

@J.F.Sebastian I agree `ignored` looks pretty ugly, but some people are against using `_` for several reasons. I think the first snippet is fine even if you ignore the value

#### @Shubham S. Naik 2017-12-30 05:56:38

why x[1] is used in key, value = max(stats.iteritems(), key=lambda x:x[1]) ?

#### @cyber-math 2018-12-06 21:55:31

That is very neat solution...It took a lot time to find this..

#### @watsonic 2015-05-05 02:03:11

Per the iterated solutions via comments in the selected answer...

In Python 3:

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

In Python 2:

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

#### @patapouf_ai 2015-05-28 15:43:05

Your solution for Python 3 also works for Python 2.7.

#### @patapouf_ai 2015-05-28 15:43:38

I'm not sure why you add a separate solution for Python 2 ...

#### @watsonic 2015-06-03 22:47:08

because keys() does not return an iterator in python 2 and hence takes a performance hit

#### @unbeknown 2008-11-06 11:28:56

Here is another one:

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

The function `key` simply returns the value that should be used for ranking and `max()` returns the demanded element right away.

#### @tzot 2008-11-06 13:07:19

.iterkeys is not needed in your answer (it's the default when iterating a dict). However, note that the .iteritems method fetches both key and value in one step, so there is no need for an extra getitem per key as needed with .iterkeys.

#### @Leopd 2013-04-25 23:23:59

This is a great answer because it is very clear what's going on and is thus easy to extend to other situations.

#### @the wolf 2012-09-09 23:30:37

I have tested MANY variants, and this is the fastest way to return the key of dict with the max value:

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

To give you an idea, here are some candidate methods:

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

The test dictionary:

``````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}
``````

And the test results under 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%     --
``````

And under 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%     --
``````

You can see that `f1` is the fastest under Python 3.2 and 2.7 (or, more completely, `keywithmaxval` at the top of this post)

#### @Tom Rose 2012-11-21 13:51:41

Wow, that was a thorough answer. I didn't see your suggested method in your list of test functions? Is that f1?

#### @WolframH 2012-11-21 21:47:37

This seems fishy. `f7` is like `f1`, just not giving a name to an intermediate object. `f7` should be (very slightly) faster than `f1`, not much slower. And that's what I get: `>>> 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`

#### @Joop 2014-09-17 08:55:40

agree f1 is like f7. Did test with ipython %timeit and both came with same performance on my machine on python 2.7. Testing: f1 - 18 µs per loop Testing: f2 - 33.7 µs per loop Testing: f3b - 50 µs per loop Testing: f4b - 30.7 µs per loop Testing: f5 - 28 µs per loop Testing: f6 - 23 µs per loop Testing: f7 - 18 µs per loop Testing: f8 - 43.9 µs per loop Testing: f4 - 2.16 ms per loop Testing: f3 - 2.29 ms per loop

#### @Nikos Alexandris 2015-03-25 15:41:11

f1 is also applicable wherever max(d, key) is not available.

#### @Dimath 2015-04-01 13:28:57

I thought dict is unsorted, couldn't d.keys and d.values theoretically be ordered differently?

#### @Lucretiel 2015-09-29 18:08:14

The list-copy solutions are smelly to me. How's the performance on a dict with thousands or millions of entries?

#### @Nick_F 2016-12-18 04:15:24

@the_wolf, I understand that tuples are faster than lists in Python (this is one of their advantages)

#### @john ktejik 2017-11-25 03:44:34

incredible. You give credence to all StackOverflow posters everywhere.

#### @Neo 2018-05-13 05:32:41

@Dimath you are right. That's what happening to me.

#### @Donald Allen 2018-11-12 02:40:02

doesn't matter. they're all O(nlogn)

#### @rosstex 2019-01-03 08:34:18

@DonaldAllen But some are O(n) :)

#### @A. Coady 2008-11-11 06:24:30

``````max(stats, key=stats.get)
``````

#### @CrackSmoker9000 2015-02-25 21:29:01

if you really wanted to do it this way you could do `stats[max(stats, key=stats.get)]`

#### @A. Coady 2015-03-16 23:28:23

@scottmrogowski, ss. It provides the key with the maximum value, as asked. The max value would be simply max(stats.values()).

#### @ihatecache 2015-11-21 16:29:36

This should be the answer as it is the simplest and was exactly what the OP asked for.

#### @oba2311 2017-04-03 13:09:19

@Coady what if there is a tie between two keys (with the same value)? I want to get them both, but I get only one.

#### @A. Coady 2017-04-04 00:37:06

@oba2311 `max_value = max(stats.values()); {key for key, value in stats.items() if value == max_value}`

#### @user3245268 2018-09-30 18:07:34

Perfect answer! I did not understand @CrackSmoker9000's remark as to why this is incorrect

#### @VolArt 2019-01-21 15:24:12

Nice true python.

#### @ricafeal 2008-11-06 11:04:28

Thanks, very elegant, I didn't remember that max allows a "key" parameter.

BTW, to get the right answer ('b') it has to be:

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

#### @unbeknown 2008-11-06 11:24:30

Right, max() returns the key/value pair.

### [SOLVED] Check if a given key already exists in a dictionary

• 2009-10-21 19:05:09
• Mohan Gulati
• 2724442 View
• 2583 Score
• Tags:   python dictionary

### [SOLVED] Add new keys to a dictionary?

• 2009-06-21 22:07:39
• lfaraone
• 2815913 View
• 2171 Score
• Tags:   python dictionary

### [SOLVED] What is the best way to iterate over a dictionary?

• 2008-09-26 18:20:06
• Jake Stewart
• 1312967 View
• 2199 Score
• Tags:   c# dictionary loops

### [SOLVED] What is the maximum length of a URL in different browsers?

• 2009-01-06 16:14:30
• Sander Versluys
• 1085311 View
• 4397 Score