Ottieni la chiave corrispondente al valore minimo all'interno di un dizionario

Se ho un dizionario Python, come posso ottenere la chiave per la voce che contiene il valore minimo?

Stavo pensando a qualcosa a che fare con la min()funzione ...

Dato l'input:

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

Sarebbe tornato 321.

Meglio: min(d, key=d.get)- nessun motivo per interporre uno lambdastrato indiretto inutile o estrarre elementi o chiavi!

Ecco una risposta che fornisce effettivamente la soluzione richiesta dall'OP:

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

L'uso d.iteritems()sarà più efficiente per dizionari più grandi, tuttavia.

Per più chiavi che hanno lo stesso valore più basso, è possibile utilizzare una comprensione dell'elenco:

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]

Una versione funzionale equivalente:

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

Nel caso in cui tu abbia più chiavi minime e desideri mantenerlo semplice

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

Se non sei sicuro di non avere più valori minimi, suggerirei:

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

Modifica: questa è una risposta alla domanda originale dell'OP sulla chiave minima, non sulla risposta minima.

Puoi ottenere i tasti del dict usando la keysfunzione e hai ragione su come usare minper trovare il minimo di quell'elenco.

Un altro approccio per affrontare il problema di più chiavi con lo stesso valore minimo:

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

Usa mincon un iteratore (per python 3 usa itemsinvece di iteritems); invece di lambda usa l' itemgetteroperatore from, che è più veloce di 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]

Ho confrontato le seguenti tre opzioni:

    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 )

Uscita campione:

#option 1
236230
0:00:14.136808

#option 2
236230
0:00:00.458026

#option 3
236230
0:00:00.824048

per creare una classe ordinabile devi sovrascrivere 6 funzioni speciali, in modo che venga chiamato dalla funzione min ()

questi metodi sono __lt__ , __le__, __gt__, __ge__, __eq__ , __ne__in ordine minore, minore o uguale, maggiore di, maggiore o uguale, uguale, non uguale. ad esempio è necessario implementare __lt__come segue:

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

quindi è possibile utilizzare la funzione min come segue:

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

questo ha funzionato per me.

min(zip(d.values(), d.keys()))[1]

Utilizzare la funzione zip per creare un iteratore di tuple contenente valori e chiavi. Quindi avvolgilo con una funzione min che richiede il minimo in base al primo tasto. Ciò restituisce una tupla contenente una coppia (valore, chiave). L'indice di [1] viene utilizzato per ottenere la chiave corrispondente

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

E 'questo quello che stai cercando?

d = dict()
d[15.0]='fifteen'
d[14.0]='fourteen'
d[14.5]='fourteenandhalf'

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

Stampe 'quattordici'