Obtenir une clé avec une valeur maximale dans le dictionnaire?


867

j'ai un dictionary : les clés sont des chaînes, les valeurs sont des entiers.

Exemple:

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

J'aimerais obtenir 'b'une réponse, car c'est la clé avec une valeur plus élevée.

J'ai fait ce qui suit, en utilisant une liste intermédiaire avec des tuples de valeur-clé inversés:

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

Est-ce la meilleure approche (ou même plus élégante)?


1
Qu'est-ce qui ne va pas max(stats)?
John Red

12
max(stats)utilisera les étiquettes comme clés (il renverra 'c', étant donné que c'est l'étiquette maximale), max(stats, key=lambda key: stats[key])est ce qu'OP était après (qui renverra 'b', étiquette de la valeur indexée maximale). Est-ce plus clair?
Atcold

Réponses:


609

Vous pouvez utiliser operator.itemgetterpour cela:

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

Et au lieu de construire une nouvelle liste dans l'utilisation de la mémoire stats.iteritems(). Le keyparamètre de la max()fonction est une fonction qui calcule une clé utilisée pour déterminer comment classer les éléments.

Veuillez noter que si vous deviez avoir une autre paire clé-valeur 'd': 3000, cette méthode ne retournera que l' une des deux même si elles ont toutes les deux la valeur maximale.

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

Si vous utilisez Python3:

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

242
Encore plus propre, je pense =max(stats.iterkeys(), key=(lambda key: stats[key]))
Lucretiel

18
Pourquoi ne pas simplement utiliser key=lambda x: x[1]?
BenDundee

43
en python 3 @ la solution de Lucretiel (correctement orthographiée) échoue. il devrait être: max (stats.keys (), key = (lambda k: stats [k])) puisque keys () fait maintenant ce que iterkeys () faisait automatiquement auparavant.
watsonic

73
Rigth vous êtes. Fait intéressant, une solution qui est exactement aussi efficace en mémoire et fonctionne à la fois en Python 2 et 3 est:max(stats, key=lambda key: stats[key])
Lucretiel

3
Honnêtement, je pense que les commentaires ont la solution la plus propre et la meilleure.
Augusto Gonzalez

1180
max(stats, key=stats.get)

17
si vous vouliez vraiment le faire de cette façon, vous pourriez le fairestats[max(stats, key=stats.get)]
CrackSmoker9000

81
@scottmrogowski, ss. Il fournit la clé avec la valeur maximale, comme demandé. La valeur maximale serait simplement max (stats.values ​​()).
A. Coady

25
Cela devrait être la réponse car c'est la plus simple et c'était exactement ce que le PO demandait.
ihatecache

4
@Coady et s'il y a une égalité entre deux clés (avec la même valeur)? Je veux les avoir tous les deux, mais je n'en ai qu'un.
oba2311

10
@ oba2311max_value = max(stats.values()); {key for key, value in stats.items() if value == max_value}
A. Coady

208

J'ai testé de nombreuses variantes, et c'est le moyen le plus rapide de renvoyer la clé de dict avec la valeur maximale:

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

Pour vous donner une idée, voici quelques méthodes candidates:

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) 

Le dictionnaire de test:

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}

Et les résultats des tests sous 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%     --

Et sous 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%     -- 

Vous pouvez voir que f1c'est le plus rapide sous Python 3.2 et 2.7 (ou, plus complètement, keywithmaxvalen haut de cet article)


12
Cela semble louche. f7est commef1 ne pas donner de nom à un objet intermédiaire. f7devrait être (très légèrement) plus rapide que f1, pas beaucoup plus lent. Et c'est ce que je reçois:>>> 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
Rétablir Monica

1
d'accord f1 est comme f7. A testé avec ipython% timeit et les deux sont venus avec les mêmes performances sur ma machine sur python 2.7. Test: f1 - 18 µs par boucle Test: f2 - 33,7 µs par boucle Test: f3b - 50 µs par boucle Test: f4b - 30,7 µs par boucle Test: f5 - 28 µs par boucle Test: f6 - 23 µs par boucle Test: f7 - 18 µs par boucle Test: f8 - 43,9 µs par boucle Test: f4 - 2,16 ms par boucle Test: f3 - 2,29 ms par boucle
Joop

f1 est également applicable partout où max (d, clé) n'est pas disponible.
Nikos Alexandris

5
Je pensais que dict n'était pas trié, les valeurs d.keys et d.values ​​ne pouvaient-elles pas théoriquement être ordonnées différemment?
Dimath

1
Les solutions de copie de liste me sentent mal. Quelle est la performance sur un dict avec des milliers ou des millions d'entrées?
Lucretiel

63

Si vous avez besoin de connaître uniquement une clé avec la valeur maximale, vous pouvez le faire sans iterkeysou iteritemsparce que l'itération via le dictionnaire en Python est l'itération via ses clés.

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

ÉDITER:

À partir des commentaires, @ user1274878:

Je suis nouveau sur python. Pouvez-vous expliquer votre réponse par étapes?

Oui...

max

max (itérable [, clé])

max (arg1, arg2, * args [, clé])

Renvoie le plus grand élément dans un itérable ou le plus grand de deux ou plusieurs arguments.

L' keyargument facultatif décrit comment comparer les éléments pour obtenir un maximum parmi eux:

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

Les valeurs retournées seront comparées.

Dict

Python dict est une table de hachage. Une clé de dict est le hachage d'un objet déclaré comme clé. Pour des raisons de performances, l'itération passe par un dict implémenté comme itération via ses clés.

Par conséquent, nous pouvons l'utiliser pour supprimer l'opération d'obtention d'une liste de clés.

Fermeture

Une fonction définie à l'intérieur d'une autre fonction est appelée fonction imbriquée. Les fonctions imbriquées peuvent accéder aux variables de la portée englobante.

La statsvariable disponible via l' __closure__attribut de la lambdafonction en tant que pointeur sur la valeur de la variable définie dans la portée parent.


1
@ I159: Je suis nouveau sur python. Pouvez-vous expliquer votre réponse par étapes
user1274878

57

Exemple:

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

si vous voulez trouver la valeur maximale avec sa clé, peut-être que le suivi pourrait être simple, sans aucune fonction pertinente.

max(stats, key=stats.get)

la sortie est la clé qui a la valeur max.


cette solution testée plus vite que max (stats, key = lambda key: stats [key])
Ta946

46

En voici un autre:

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

La fonction keyrenvoie simplement la valeur qui doit être utilisée pour le classement et max()renvoie immédiatement l'élément demandé.


10
.iterkeys n'est pas nécessaire dans votre réponse (c'est la valeur par défaut lors de l'itération d'un dict). Cependant, notez que la méthode .iteritems récupère à la fois la clé et la valeur en une seule étape, il n'est donc pas nécessaire d'avoir un getitem supplémentaire par clé comme nécessaire avec .iterkeys.
tzot

C'est une excellente réponse car il est très clair ce qui se passe et est donc facile à étendre à d'autres situations.
Leopd

en version python3:max(stats, key=lambda k: stats[k])
HeyJude

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

Si vous ne vous souciez pas de la valeur (je serais surpris, mais) vous pouvez le faire:

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

J'aime mieux déballer le tuple qu'un indice [0] à la fin de l'expression. Je n'aime jamais beaucoup la lisibilité des expressions lambda, mais je trouve celle-ci meilleure que celle de operator.itemgetter (1) à mon humble avis.


9
_pourrait être utilisé à la place de ignored.
jfs

1
@JFSebastian Je suis d'accord, ça a l' ignoredair plutôt moche, mais certaines personnes sont contre l'utilisation _pour plusieurs raisons. Je pense que le premier extrait est
correct

30

Étant donné que plusieurs entrées peuvent avoir la valeur maximale. Je ferais une liste des clés qui ont la valeur maximale comme valeur.

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

Cela vous donnera également «b» et toute autre clé max.

Remarque: Pour python 3, utilisez stats.items()au lieu destats.iteritems()


9
Votre solution est OK mais calcule la valeur maximale autant de fois qu'il y a d'éléments dans le dict. Si l'informatique maxétait chère (par exemple, un dictionnaire LONG), je recommanderais [key for m in [max(stats.values())] for key,val in stats.iteritems() if val == m]si vous voulez un one-liner, sinon calculez m = ...au préalable.
gboffi

4
Juste une petite note: pour python 3, utilisez stats.items () au lieu de stats.iteritems ().
Susa

21

Vous pouvez utiliser:

max(d, key = d.get) 
# which is equivalent to 
max(d, key = lambda k : d.get(k))

Pour renvoyer la clé, utilisez une paire de valeurs:

max(d.items(), key = lambda k : k[1])

7
Cela devrait être la réponse acceptée, c'est beaucoup plus simple que d'utiliser l'opérateur
Sigmatics

19

Pour obtenir la clé / valeur maximale du dictionnaire stats:

stats = {'a':1000, 'b':3000, 'c': 100}
  • Basé sur les clés

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

  • Basé sur des valeurs

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

Bien sûr, si vous souhaitez obtenir uniquement la clé ou la valeur du résultat, vous pouvez utiliser l'indexation de tuple. Par exemple, pour obtenir la clé correspondant à la valeur maximale:

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

Explication

La méthode de dictionnaire items()en Python 3 renvoie un objet de vue du dictionnaire. Lorsque cet objet de vue est itéré sur, par la maxfonction, il renvoie les éléments du dictionnaire sous forme de tuples du formulaire (key, value).

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

Lorsque vous utilisez l' lambdaexpression lambda x: x[1], dans chaque itération, x est l'un de ces tuples(key, value) . Ainsi, en choisissant le bon index, vous choisissez si vous souhaitez comparer par clés ou par valeurs.

Python 2

Pour les versions Python 2.2+, le même code fonctionnera. Cependant, il est préférable d'utiliser la iteritems()méthode du dictionnaire au lieu deitems() pour les performances.

Remarques


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

10

Par les solutions itérées via des commentaires dans la réponse sélectionnée ...

En Python 3:

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

En Python 2:

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

Votre solution pour Python 3 fonctionne également pour Python 2.7.
patapouf_ai

4
parce que keys () ne renvoie pas d'itérateur en python 2 et prend donc un coup de performance
watsonic

10

Je suis arrivé ici à la recherche d'un retour en mydict.keys()fonction de la valeur de mydict.values(). Au lieu d'une seule clé retournée, je cherchais à renvoyer le nombre x supérieur de valeurs.

Cette solution est plus simple que d'utiliser la max()fonction et vous pouvez facilement modifier le nombre de valeurs renvoyées:

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

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

Si vous voulez la clé de classement la plus élevée, utilisez simplement l'index:

x[0]
['b']

Si vous voulez les deux clés les mieux classées, utilisez simplement le découpage de liste:

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

Il s'agit d'une solution très inefficace. Le tri du dict entraînera une exécution de n log (n) car vous vous préoccupez d'un tas de valeurs qui ne sont pas maximales. L'utilisation de la fonction max entraînera un temps d'exécution de seulement n, ce qui est beaucoup plus rapide.
Peter Graham

1
@PeterGraham utilise à peu près toutes les solutions ici (y compris la réponse acceptée) max(). Il est clair que c'est le plus rapide. Je pensais que j'offrirais une solution différente avec l'avantage du tranchage, qui m'était plus utile à l'époque
donrondadon

8

Je n'ai été satisfait d'aucune de ces réponses. maxsélectionne toujours la première clé avec la valeur maximale. Le dictionnaire peut avoir plusieurs clés avec cette valeur.

def keys_with_top_values(my_dict):
    return [key  for (key, value) in my_dict.items() if value == max(my_dict.values())]

Publier cette réponse au cas où cela aiderait quelqu'un. Voir l'article SO ci-dessous

Quel maximum Python choisit-il en cas d'égalité?


7

Avec collections.Countervous pourriez faire

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

Le cas échéant, vous pouvez simplement commencer par un vide collections.Counteret y ajouter

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

5

Une file d'attente de tas est une solution généralisée qui vous permet d'extraire les n principales clés classées par valeur:

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'

Remarque dict.__getitem__est la méthode appelée par le sucre syntaxique dict[]. Contrairement à dict.get, il reviendra KeyErrorsi aucune clé n'est trouvée, ce qui ne peut pas se produire ici.


4

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


1
Cela sera ordonné par la clé avec des valeurs maximales en double. Cela peut être souhaité ou non.
Rob Rose

2

+1 à la solution la plus simple de @Aric Coady .
Et aussi une façon de sélectionner au hasard l'une des clés avec la valeur maximale dans le dictionnaire:

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

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

1

Que diriez-vous:

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

3
zip(stats.keys(), stats.values())est juste un moyen plus long d'écrire stats.items(). Une fois ce changement effectué, votre réponse sera presque identique à plusieurs réponses plus anciennes.
vaultah

D'accord, je n'étais pas au courant que les éléments () sont les mêmes que zip
user2399453

itemsn'est pas le même que zip. Il produit juste le même résultat.
Paul Rooney

0

J'ai testé la réponse acceptée ET la solution la plus rapide de @ thewolf contre une boucle très basique et la boucle était plus rapide que les deux:

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

résultats:

Iterating: 3.8201940059661865
List creating: 6.928712844848633
Accepted answer: 5.464320182800293

0

Pour les utilisateurs scientifiques de python, voici une solution simple utilisant Pandas:

import pandas as pd
stats = {'a': 1000, 'b': 3000, 'c': 100}
series = pd.Series(stats)
series.idxmax()

>>> b

0

Dans le cas où vous avez plusieurs clés avec la même valeur, par exemple:

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

Vous pouvez obtenir une collection avec toutes les clés avec une valeur maximale comme suit:

from collections import defaultdict
from collections import OrderedDict

groupedByValue = defaultdict(list)
for key, value in sorted(stats.items()):
    groupedByValue[value].append(key)

# {1000: ['a'], 3000: ['b', 'd', 'e'], 100: ['c']}

groupedByValue[max(groupedByValue)]
# ['b', 'd', 'e']

0

Approche beaucoup plus simple à comprendre:

dict = { 'a':302, 'e':53, 'g':302, 'h':100 }
max_value_keys = [key for key in dict.keys() if dict[key] == max(dict.values())]
print(max_value_keys) # prints a list of keys with max value

Sortie: ['a', 'g']

Maintenant, vous ne pouvez choisir qu'une seule clé:

maximum = dict[max_value_keys[0]]
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.