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`

.

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

## The Question :

*332 people think this question is useful*
*The Question Comments :*
## The Answer 1

*661 people think this answer is useful*
## The Answer 2

*53 people think this answer is useful*
## The Answer 3

*16 people think this answer is useful*
## The Answer 4

*12 people think this answer is useful*
## The Answer 5

*7 people think this answer is useful*
## The Answer 6

*6 people think this answer is useful*
## The Answer 7

*4 people think this answer is useful*

## The Answer 8

*4 people think this answer is useful*
## The Answer 9

*3 people think this answer is useful*
## The Answer 10

*2 people think this answer is useful*
## The Answer 11

*1 people think this answer is useful*
## The Answer 12

*1 people think this answer is useful*
## The Answer 13

*0 people think this answer is useful*
## The Answer 14

*0 people think this answer is useful*
## The Answer 15

*-1 people think this answer is useful*
## The Answer 16

*-8 people think this answer is useful*

2021-01-17

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`

.

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

Best: `min(d, key=d.get)`

— no reason to interpose a useless `lambda`

indirection layer or extract items or keys!

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.

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

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

>>> d = {320:1, 321:0, 322:3} >>> min(d, key=lambda k: d[k]) 321

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: positions.append(k) if v < min_value: min_value = v positions = [] # output variable positions.append(k) return positions minimums({'a':1, 'b':2, 'c':-1, 'd':0, 'e':-1}) ['e', 'c']

**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.

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) """Output: 321, 323 """

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]

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

d={} d[320]=1 d[321]=0 d[322]=3 value = min(d.values()) for k in d.keys(): if d[k] == value: print k,d[k]

I compared how the following three options perform:

import random, datetime myDict = {} for i in range( 10000000 ): myDict[ i ] = random.randint( 0, 10000000 ) # OPTION 1 start = datetime.datetime.now() sorted = [] for i in myDict: sorted.append( ( i, myDict[ i ] ) ) sorted.sort( key = lambda x: x[1] ) print( sorted[0][0] ) end = datetime.datetime.now() print( end - start ) # OPTION 2 start = datetime.datetime.now() myDict_values = list( myDict.values() ) myDict_keys = list( myDict.keys() ) min_value = min( myDict_values ) print( myDict_keys[ myDict_values.index( min_value ) ] ) end = datetime.datetime.now() print( end - start ) # OPTION 3 start = datetime.datetime.now() print( min( myDict, key=myDict.get ) ) end = datetime.datetime.now() print( end - start )

Sample output:

#option 1 236230 0:00:14.136808 #option 2 236230 0:00:00.458026 #option 3 236230 0:00:00.824048

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.

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

# python d={320:1, 321:0, 322:3} reduce(lambda x,y: x if d[x]<=d[y] else y, d.iterkeys()) 321

Is this what you are looking for?

d = dict() d[15.0]='fifteen' d[14.0]='fourteen' d[14.5]='fourteenandhalf' print d[min(d.keys())]

Prints ‘fourteen’