python – Get the key corresponding to the minimum value within a dictionary

The Question :

332 people think this question is useful

If I have a Python dictionary, how do I get the key to the entry which contains the minimum value?

I was thinking about something to do with the min() function…

Given the input:

{320:1, 321:0, 322:3}

It would return 321.

The Question Comments :
  • Data structure awareness day: if you only ever query (or remove) the minimum element, consider using a priority queue or heap.

The Answer 1

661 people think this answer is useful

Best: min(d, key=d.get) — no reason to interpose a useless lambda indirection layer or extract items or keys!

The Answer 2

53 people think this answer is useful

Here’s an answer that actually gives the solution the OP asked for:

>>> d = {320:1, 321:0, 322:3}
>>> d.items()
[(320, 1), (321, 0), (322, 3)]
>>> # find the minimum by comparing the second element of each tuple
>>> min(d.items(), key=lambda x: x[1]) 
(321, 0)

Using d.iteritems() will be more efficient for larger dictionaries, however.

The Answer 3

16 people think this answer is useful

For multiple keys which have equal lowest value, you can use a list comprehension:

d = {320:1, 321:0, 322:3, 323:0}

minval = min(d.values())
res = [k for k, v in d.items() if v==minval]

[321, 323]

An equivalent functional version:

res = list(filter(lambda x: d[x]==minval, d))

The Answer 4

12 people think this answer is useful

min(d.items(), key=lambda x: x[1])[0]

The Answer 5

7 people think this answer is useful
>>> d = {320:1, 321:0, 322:3}
>>> min(d, key=lambda k: d[k]) 

The Answer 6

6 people think this answer is useful

For the case where you have multiple minimal keys and want to keep it simple

def minimums(some_dict):
    positions = [] # output variable
    min_value = float("inf")
    for k, v in some_dict.items():
        if v == min_value:
        if v < min_value:
            min_value = v
            positions = [] # output variable

    return positions

minimums({'a':1, 'b':2, 'c':-1, 'd':0, 'e':-1})

['e', 'c']

The Answer 7

4 people think this answer is useful

Edit: this is an answer to the OP’s original question about the minimal key, not the minimal answer.

You can get the keys of the dict using the keys function, and you’re right about using min to find the minimum of that list.

The Answer 8

4 people think this answer is useful

If you are not sure that you have not multiple minimum values, I would suggest:

d = {320:1, 321:0, 322:3, 323:0}
print ', '.join(str(key) for min_value in (min(d.values()),) for key in d if d[key]==min_value)

321, 323

The Answer 9

3 people think this answer is useful

Another approach to addressing the issue of multiple keys with the same min value:

>>> dd = {320:1, 321:0, 322:3, 323:0}
>>> from itertools import groupby
>>> from operator import itemgetter
>>> print [v for k,v in groupby(sorted((v,k) for k,v in dd.iteritems()), key=itemgetter(0)).next()[1]]
[321, 323]

The Answer 10

2 people think this answer is useful

Use min with an iterator (for python 3 use items instead of iteritems); instead of lambda use the itemgetter from operator, which is faster than lambda.

from operator import itemgetter
min_key, _ = min(d.iteritems(), key=itemgetter(1))

The Answer 11

1 people think this answer is useful
value = min(d.values())
for k in d.keys(): 
    if d[k] == value:
        print k,d[k]

The Answer 12

1 people think this answer is useful

I compared how the following three options perform:

    import random, datetime

myDict = {}
for i in range( 10000000 ):
    myDict[ i ] = random.randint( 0, 10000000 )


start =

sorted = []
for i in myDict:
    sorted.append( ( i, myDict[ i ] ) )
sorted.sort( key = lambda x: x[1] )
print( sorted[0][0] )

end =
print( end - start )


start =

myDict_values = list( myDict.values() )
myDict_keys = list( myDict.keys() )
min_value = min( myDict_values )
print( myDict_keys[ myDict_values.index( min_value ) ] )

end =
print( end - start )


start =

print( min( myDict, key=myDict.get ) )

end =
print( end - start )

Sample output:

#option 1

#option 2

#option 3

The Answer 13

0 people think this answer is useful

to create an orderable class you have to override 6 special functions, so that it would be called by the min() function

these methods are__lt__ , __le__, __gt__, __ge__, __eq__ , __ne__ in order they are less than, less than or equal, greater than, greater than or equal, equal, not equal. for example you should implement __lt__ as follows:

def __lt__(self, other):
  return self.comparable_value < other.comparable_value

then you can use the min function as follows:

minValue = min(yourList, key=(lambda k: yourList[k]))

this worked for me.

The Answer 14

0 people think this answer is useful
min(zip(d.values(), d.keys()))[1]

Use the zip function to create an iterator of tuples containing values and keys. Then wrap it with a min function which takes the minimum based on the first key. This returns a tuple containing (value, key) pair. The index of [1] is used to get the corresponding key

The Answer 15

-1 people think this answer is useful
# python 
d={320:1, 321:0, 322:3}
reduce(lambda x,y: x if d[x]<=d[y] else y, d.iterkeys())

The Answer 16

-8 people think this answer is useful

Is this what you are looking for?

d = dict()

print d[min(d.keys())]

Prints ‘fourteen’

Add a Comment