¿Obtener clave con el máximo valor en el diccionario?


867

Tengo un dictionary: las claves son cadenas, los valores son enteros.

Ejemplo:

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

Me gustaría obtener 'b'una respuesta, ya que es la clave con un valor más alto.

Hice lo siguiente, usando una lista intermedia con tuplas de clave-valor invertidas:

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

¿Es ese el mejor enfoque (o incluso más elegante)?


1
¿Qué tiene de malo max(stats)?
John Red

12
max(stats)usará las etiquetas como claves (devolverá 'c', dado que esa es la etiqueta máxima), max(stats, key=lambda key: stats[key])es lo que OP buscó después (lo que devolverá 'b', etiqueta de valor indexado máximo). ¿Está más claro?
Atcold

Respuestas:


609

Puedes usar operator.itemgetterpara eso:

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

Y en lugar de construir una nueva lista en el uso de la memoria stats.iteritems(). El keyparámetro de la max()función es una función que calcula una clave que se utiliza para determinar cómo clasificar los elementos.

Tenga en cuenta que si tuviera otro par clave-valor 'd': 3000, este método solo devolverá uno de los dos , aunque ambos tengan el valor máximo.

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

Si usa Python3:

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

242
Incluso más limpio, creo =max(stats.iterkeys(), key=(lambda key: stats[key]))
Lucretiel

18
¿Por qué no solo usar key=lambda x: x[1]?
BenDundee

43
en python 3 la solución de Lucretiel (deletreada correctamente) falla. debería ser: max (stats.keys (), key = (lambda k: stats [k])) ya que las teclas () ahora hacen lo que iterkeys () solía hacer automáticamente.
Watsonic

73
Rigth eres. Curiosamente, una solución que es exactamente igual de eficiente en memoria y que funciona tanto en Python 2 como en 3 es:max(stats, key=lambda key: stats[key])
Lucretiel

3
Sinceramente, creo que los comentarios tienen la solución más limpia y mejor.
Augusto González

1180
max(stats, key=stats.get)

17
si realmente quisieras hacerlo de esta manera, podrías hacerlostats[max(stats, key=stats.get)]
CrackSmoker9000

81
@scottmrogowski, ss. Proporciona a la clave el valor máximo, tal como se solicita. El valor máximo sería simplemente max (stats.values ​​()).
A. Coady

25
Esta debería ser la respuesta, ya que es la más simple y fue exactamente lo que solicitó el OP.
ihatecache

44
@Coady, ¿qué pasa si hay un empate entre dos teclas (con el mismo valor)? Quiero conseguirlos a los dos, pero solo consigo uno.
oba2311

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

208

He probado MUCHAS variantes, y esta es la forma más rápida de devolver la clave de dict con el valor máximo:

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

Para darle una idea, aquí hay algunos métodos candidatos:

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) 

El diccionario de prueba:

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}

Y los resultados de la prueba en 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%     --

Y bajo 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%     -- 

Puede ver que f1es el más rápido en Python 3.2 y 2.7 (o, más completamente, keywithmaxvalen la parte superior de esta publicación)


12
Esto parece sospechoso. f7es como f1, simplemente no dar un nombre a un objeto intermedio. f7debería ser (muy ligeramente) más rápido que f1, no mucho más lento. Y eso es lo que obtengo:>>> 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
Restablecer a Mónica el

1
De acuerdo, f1 es como f7. Probé con ipython% timeit y ambos vinieron con el mismo rendimiento en mi máquina en python 2.7. Prueba: f1 - 18 µs por ciclo Prueba: f2 - 33.7 µs por ciclo Prueba: f3b - 50 µs por ciclo Prueba: f4b - 30.7 µs por ciclo Prueba: f5 - 28 µs por ciclo Prueba: f6 - 23 µs por ciclo Prueba: f7 - 18 µs por ciclo Prueba: f8 - 43.9 µs por ciclo Prueba: f4 - 2.16 ms por ciclo Prueba: f3 - 2.29 ms por ciclo
Joop

f1 también es aplicable donde max (d, clave) no está disponible.
Nikos Alexandris

55
Pensé que dict no está ordenado, ¿no podrían d.keys y d.values ​​teóricamente ordenarse de manera diferente?
Dimath 01 de

1
Las soluciones de copia de la lista son malolientes para mí. ¿Cómo es el rendimiento en un dict con miles o millones de entradas?
Lucretiel

63

Si necesita conocer solo una clave con el valor máximo, puede hacerlo sin iterkeyso iteritemsporque la iteración a través del diccionario en Python es la iteración a través de sus claves.

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

EDITAR:

De los comentarios, @ user1274878:

Soy nuevo en python. ¿Puede explicar su respuesta en pasos?

Sí...

max

max (iterable [, clave])

max (arg1, arg2, * args [, clave])

Devuelve el elemento más grande en un iterable o el más grande de dos o más argumentos.

El keyargumento opcional describe cómo comparar elementos para obtener el máximo entre ellos:

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

Los valores devueltos serán comparados.

Dict

Python dict es una tabla hash. Una clave de dict es un hash de un objeto declarado como clave. Debido a razones de rendimiento, iteración a través de un dict implementado como iteración a través de sus claves.

Por lo tanto, podemos usarlo para eliminar la operación de obtener una lista de claves.

Cierre

Una función definida dentro de otra función se llama función anidada. Las funciones anidadas pueden acceder a variables del ámbito de inclusión.

La statsvariable disponible a través del __closure__atributo de la lambdafunción como puntero al valor de la variable definida en el ámbito primario.


1
@ I159: soy nuevo en Python. Puede usted por favor explique su respuesta en los pasos
user1274878

57

Ejemplo:

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

Si desea encontrar el valor máximo con su clave, tal vez seguir podría ser simple, sin ninguna función relevante.

max(stats, key=stats.get)

La salida es la clave que tiene el valor máximo.


esta solución se probó más rápido que el máximo (stats, key = lambda key: stats [key])
Ta946

46

Aquí hay otro:

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

La función keysimplemente devuelve el valor que debe usarse para la clasificación y max()devuelve el elemento solicitado de inmediato.


10
.iterkeys no es necesario en su respuesta (es el valor predeterminado al iterar un dict). Sin embargo, tenga en cuenta que el método .iteritems obtiene tanto la clave como el valor en un solo paso, por lo que no es necesario un getitem adicional por clave según sea necesario con .iterkeys.
Tzot

Esta es una gran respuesta porque es muy claro lo que está sucediendo y, por lo tanto, es fácil de extender a otras situaciones.
Leopd

en versión python3:max(stats, key=lambda k: stats[k])
HeyJude

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

Si no te importa el valor (me sorprendería, pero) puedes hacer:

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

Me gusta desempacar la tupla mejor que un subíndice [0] al final de la expresión. Nunca me gusta mucho la legibilidad de las expresiones lambda, pero encuentro esta mejor que la operator.itemgetter (1) en mi humilde opinión.


99
_podría usarse en lugar de ignored.
jfs

1
@JFSebastian Estoy de acuerdo en que se ignoredve bastante feo, pero algunas personas están en contra de usarlo _por varias razones. Creo que el primer fragmento está bien incluso si ignoras el valor
jamylak

30

Dado que más de una entrada puede tener el valor máximo. Haría una lista de las claves que tienen el valor máximo como su valor.

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

Esto le dará 'b' y cualquier otra clave máxima también.

Nota: para uso de Python 3 en stats.items()lugar destats.iteritems()


99
Su solución está bien, pero calcula el valor máximo tantas veces como haya elementos en el dict. Si la computación maxfuera costosa (p. Ej., Un diccionario LARGO), le recomendaría [key for m in [max(stats.values())] for key,val in stats.iteritems() if val == m]si desea una línea, de lo contrario, calcule de m = ...antemano.
gboffi

44
Solo una breve nota: para python 3, utilice stats.items () en lugar de stats.iteritems ().
Susa

21

Puedes usar:

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

Para devolver la clave, use el par de valores:

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

77
Esta debería ser la respuesta aceptada, es mucho más simple que usar el operador
Sigmatics

19

Para obtener la clave / valor máximo del diccionario stats:

stats = {'a':1000, 'b':3000, 'c': 100}
  • Basado en claves

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

  • Basado en valores

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

Por supuesto, si desea obtener solo la clave o el valor del resultado, puede usar la indexación de tuplas. Por ejemplo, para obtener la clave correspondiente al valor máximo:

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

Explicación

El método del diccionario items()en Python 3 devuelve un objeto de vista del diccionario. Cuando este objeto de vista se repite, la maxfunción genera los elementos del diccionario como tuplas del formulario (key, value).

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

Cuando usa la lambdaexpresión lambda x: x[1], en cada iteración, x es una de estas tuplas(key, value) . Entonces, al elegir el índice correcto, selecciona si desea comparar por claves o por valores.

Python 2

Para las versiones de Python 2.2+, el mismo código funcionará. Sin embargo, es mejor usar el iteritems()método de diccionario en lugar deitems() para el rendimiento.

Notas


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

Por las soluciones iteradas a través de comentarios en la respuesta seleccionada ...

En Python 3:

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

En Python 2:

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

Su solución para Python 3 también funciona para Python 2.7.
patapouf_ai

44
porque keys () no devuelve un iterador en python 2 y, por lo tanto, recibe un golpe de rendimiento
watsonic

10

Llegué aquí buscando cómo regresar en mydict.keys()función del valor de mydict.values(). En lugar de solo la clave devuelta, estaba buscando devolver el número x superior de valores.

Esta solución es más simple que usar la max()función y puede cambiar fácilmente la cantidad de valores devueltos:

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

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

Si desea la clave de clasificación más alta, solo use el índice:

x[0]
['b']

Si desea las dos mejores claves de clasificación más alta, solo use el corte de lista:

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

Esta es una solución muy ineficiente. Ordenar el dict incurrirá en un tiempo de ejecución de n log (n) porque te estás preocupando por un conjunto de valores que no son los máximos. El uso de la función max generará un tiempo de ejecución de solo n, que es mucho más rápido.
Peter Graham

1
@PeterGraham utiliza prácticamente todas las soluciones aquí (incluida la respuesta aceptada) max(). Está claro que es el más rápido. Pensé que ofrecería una solución diferente con el beneficio de cortar, que fue más útil para mí en ese momento
donrondadon

8

No estaba satisfecho con ninguna de estas respuestas. maxsiempre elige la primera clave con el valor máximo. El diccionario podría tener varias claves con ese valor.

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

Publicar esta respuesta en caso de que ayude a alguien. Vea la siguiente publicación SO

¿Qué máximo elige Python en caso de empate?


7

Con collections.Counterusted podria hacer

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

Si es apropiado, simplemente puede comenzar con un vacío collections.Countery agregarle

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

5

Una cola de almacenamiento dinámico es una solución generalizada que le permite extraer las n teclas principales ordenadas por valor:

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'

Nota dict.__getitem__es el método llamado por el azúcar sintáctico dict[]. A diferencia de dict.get, regresará KeyErrorsi no se encuentra una clave, que aquí no puede ocurrir.


4

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


1
Esto ordenará por la clave con valores máximos duplicados. Eso puede o no ser deseado.
Rob Rose

2

+1 a la solución más simple de @Aric Coady .
Y también una forma de seleccionar al azar una de las teclas con valor máximo en el diccionario:

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

Qué tal si:

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

3
zip(stats.keys(), stats.values())es solo una forma más larga de escribir stats.items(). Una vez que realice ese cambio, su respuesta será casi idéntica a varias respuestas anteriores.
vaultah

De acuerdo, no sabía que items () es igual que zip
user2399453

itemsNo es lo mismo que zip. Simplemente produce el mismo resultado.
Paul Rooney

0

Probé la respuesta aceptada Y la solución más rápida de @thewolf contra un bucle muy básico y el bucle fue más rápido que ambos:

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

resultados:

Iterating: 3.8201940059661865
List creating: 6.928712844848633
Accepted answer: 5.464320182800293

0

Para los usuarios científicos de Python, aquí hay una solución simple usando Pandas:

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

>>> b

0

En el caso de que tenga más de una clave con el mismo valor, por ejemplo:

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

Puede obtener una colección con todas las claves con el valor máximo de la siguiente manera:

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

Enfoque mucho más simple de entender:

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

Salida: ['a', 'g']

Ahora puede elegir solo una clave:

maximum = dict[max_value_keys[0]]
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.