web-dev-qa-db-fra.com

Obtenir la clé correspondant à la valeur minimale dans un dictionnaire

Si j'ai un dictionnaire Python, comment puis-je obtenir la clé de l'entrée qui contient la valeur minimale?

Je pensais à quelque chose à voir avec la fonction min() ...

Compte tenu de l'entrée:

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

Il renverrait 321.

pythondictionaryminminimumidioms
220
tjvr

Meilleur: min(d, key=d.get) - aucune raison d'interposer une couche lambda inutile ou d'extraire des éléments ou des clés!

431
Alex Martelli

Voici une réponse qui donne en réalité la solution demandée par le PO:

>>> 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'utilisation de d.iteritems() sera plus efficace pour les dictionnaires plus volumineux.

40
Mark Rushakoff

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

10
abyx

Pour le cas où vous avez plusieurs clés minimales et que vous voulez rester 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']
6
netskink
>>> d = {320:1, 321:0, 322:3}
>>> min(d, key=lambda k: d[k]) 
321
5
Daniel Stutzbach

Si vous n'êtes pas sûr de ne pas avoir plusieurs valeurs minimales, je suggérerais:

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
"""
4
Tony Veijalainen

Pour plusieurs clés ayant la même valeur la plus basse, vous pouvez utiliser une liste de compréhension:

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]

Une version fonctionnelle équivalente:

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

Edit: ceci est une réponse à la question originale du PO concernant la clé minimale, pas la réponse minimale.

Vous pouvez obtenir les clés du dict en utilisant la fonction keys, et vous avez raison d'utiliser min pour trouver le minimum de cette liste.

3
perimosocordiae

Une autre approche pour résoudre le problème des clés multiples avec la même valeur min:

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

Utilisez min avec un itérateur (pour python 3 utilisez items au lieu de iteritems) au lieu de lambda, utilisez la variable itemgetter de, qui est plus rapide que lambda.

from operator import itemgetter
min_key, _ = min(d.iteritems(), key=itemgetter(1))
2
Antti Haapala
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]
1
aditya royal matturi

J'ai comparé les performances des trois options suivantes:

    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 )

Exemple de sortie:

#option 1
236230
0:00:14.136808

#option 2
236230
0:00:00.458026

#option 3
236230
0:00:00.824048
1
svinec

pour créer une classe ordonnable, vous devez écraser 6 fonctions spéciales, afin qu'elles soient appelées par la fonction min ()

ces méthodes sont__lt__ , __le__, __gt__, __ge__, __eq__ , __ne__ dans l'ordre, elles sont inférieures, égales ou égales, supérieures à, égales ou égales, égales, non égales . Par exemple, vous devez implémenter __lt__ comme suit:

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

alors vous pouvez utiliser la fonction min comme suit:

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

cela a fonctionné pour moi.

0
Muhammad Korra