Schlüssel mit maximalem Wert im Wörterbuch erhalten?

867

Ich habe eine dictionary: Schlüssel sind Zeichenfolgen, Werte sind ganze Zahlen.

Beispiel:

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

Ich würde gerne 'b'eine Antwort bekommen, da es der Schlüssel mit einem höheren Wert ist.

Ich habe Folgendes unter Verwendung einer Zwischenliste mit umgekehrten Schlüsselwerttupeln getan:

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

Ist das der bessere (oder noch elegantere) Ansatz?

Ricafeal
quelle
1
Ähm, was ist los mit max(stats)?
John Red
12
max(stats)verwendet die Beschriftungen als Schlüssel (es wird zurückgegeben 'c', vorausgesetzt, dies ist die maximale Beschriftung), max(stats, key=lambda key: stats[key])ist das , wonach OP gesucht hat (was zurückgibt 'b', Beschriftung mit maximalem indiziertem Wert). Ist es klarer?
Atcold

Antworten:

609

Sie können dafür verwenden operator.itemgetter:

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

Und anstatt eine neue Liste im Speicher zu erstellen stats.iteritems(). Der keyParameter für die max()Funktion ist eine Funktion, die einen Schlüssel berechnet, mit dem bestimmt wird, wie Elemente eingestuft werden.

Bitte beachten Sie, dass diese Methode nur eines der beiden zurückgibt, wenn Sie ein anderes Schlüssel-Wert-Paar 'd': 3000 haben, obwohl beide den Maximalwert haben.

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

Bei Verwendung von Python3:

>>> max(stats.items(), key=operator.itemgetter(1))[0]
'b'
Priyanka Chaudhary
quelle
242
Noch sauberer, denke ich =max(stats.iterkeys(), key=(lambda key: stats[key]))
Lucretiel
18
Warum nicht einfach benutzen key=lambda x: x[1]?
BenDundee
43
in Python 3 @ Lucretiels (richtig geschriebene) Lösung schlägt fehl. es sollte sein: max (stats.keys (), key = (lambda k: stats [k])), da keys () jetzt das tut, was iterkeys () früher automatisch tat.
Watsonic
73
Rigth du bist. Interessanterweise ist eine Lösung, die genau so speichereffizient ist und sowohl in Python 2 als auch in Python 3 funktioniert:max(stats, key=lambda key: stats[key])
Lucretiel
3
Ehrlich gesagt denke ich, dass die Kommentare die sauberere und bessere Lösung haben.
Augusto Gonzalez
1180
max(stats, key=stats.get)
A. Coady
quelle
17
Wenn Sie es wirklich so machen wollten, könnten Sie es tunstats[max(stats, key=stats.get)]
CrackSmoker9000
81
@ scottmrogowski, ss. Es liefert dem Schlüssel den angeforderten Maximalwert. Der Maximalwert wäre einfach Max (stats.values ​​()).
A. Coady
25
Dies sollte die Antwort sein, da es die einfachste ist und genau das war, wonach das OP gefragt hat.
Ihatecache
4
@Coady was ist, wenn zwischen zwei Schlüsseln (mit demselben Wert) ein Gleichstand besteht? Ich möchte beide bekommen, aber ich bekomme nur einen.
oba2311
10
@ oba2311max_value = max(stats.values()); {key for key, value in stats.items() if value == max_value}
A. Coady
208

Ich habe VIELE Varianten getestet, und dies ist der schnellste Weg, um den Diktatschlüssel mit dem Maximalwert zurückzugeben:

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

Um Ihnen eine Vorstellung zu geben, sind hier einige Kandidatenmethoden aufgeführt:

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) 

Das Testwörterbuch:

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}

Und die Testergebnisse unter 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%     --

Und unter 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%     -- 

Sie können sehen, dass dies f1unter Python 3.2 und 2.7 am schnellsten ist (oder ganz keywithmaxvaloben in diesem Beitrag).

der Wolf
quelle
12
Das scheint faul zu sein. f7ist so f1, als würde man einem Zwischenobjekt keinen Namen geben. f7sollte (sehr leicht) schneller sein als f1, nicht viel langsamer. Und das bekomme ich:>>> 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
Stellen Sie Monica
1
stimme zu, dass f1 wie f7 ist. Habe mit ipython% timeit getestet und beide haben auf meinem Computer unter Python 2.7 die gleiche Leistung erzielt. Testen: f1 - 18 µs pro Schleife Testen: f2 - 33,7 µs pro Schleife Testen: f3b - 50 µs pro Schleife Testen: f4b - 30,7 µs pro Schleife Testen: f5 - 28 µs pro Schleife Testen: f6 - 23 µs pro Schleife Testen: f7 - 18 µs pro Schleife Test: f8 - 43,9 µs pro Schleife Test: f4 - 2,16 ms pro Schleife Test: f3 - 2,29 ms pro Schleife
Joop
f1 gilt auch dort, wo max (d, key) nicht verfügbar ist.
Nikos Alexandris
5
Ich dachte, Dikt ist unsortiert, könnten d.keys und d.values ​​theoretisch nicht anders geordnet werden?
Dimath
1
Die List-Copy-Lösungen stinken mir. Wie ist die Leistung bei einem Diktat mit Tausenden oder Millionen von Einträgen?
Lucretiel
63

Wenn Sie nur einen Schlüssel mit dem Maximalwert kennen müssen, können Sie darauf verzichten iterkeysoder iteritemsweil die Iteration durch das Wörterbuch in Python eine Iteration durch die Schlüssel ist.

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

BEARBEITEN:

Aus Kommentaren, @ user1274878:

Ich bin neu in Python. Können Sie bitte Ihre Antwort in Schritten erklären?

Ja...

max

max (iterable [, key])

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

Gibt das größte Element in einem iterablen oder das größte von zwei oder mehr Argumenten zurück.

Das optionale keyArgument beschreibt, wie Elemente verglichen werden, um das Maximum zwischen ihnen zu erzielen:

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

Zurückgegebene Werte werden verglichen.

Dikt

Python Dict ist eine Hash-Tabelle. Ein Diktatschlüssel ist ein Hash eines als Schlüssel deklarierten Objekts. Aus Leistungsgründen Iteration durch ein Diktat als Iteration durch seine Schlüssel implementiert.

Daher können wir es verwenden, um den Vorgang des Erhaltens einer Schlüsselliste zu befreien.

Schließung

Eine in einer anderen Funktion definierte Funktion wird als verschachtelte Funktion bezeichnet. Verschachtelte Funktionen können auf Variablen des umschließenden Bereichs zugreifen.

Die statsVariable, die über das __closure__Attribut der lambdaFunktion als Zeiger auf den Wert der im übergeordneten Bereich definierten Variablen verfügbar ist .

I159
quelle
1
@ I159: Ich bin neu in Python. Können Sie bitte Ihre Antwort in Schritten erklären
user1274878
57

Beispiel:

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

Wenn Sie den Maximalwert mit seiner Taste ermitteln möchten, ist das Folgen möglicherweise einfach und ohne relevante Funktionen.

max(stats, key=stats.get)

Die Ausgabe ist der Schlüssel mit dem Maximalwert.

leo022
quelle
Diese Lösung wurde schneller als maximal getestet (Statistik, Schlüssel = Lambda-Schlüssel: Statistik [Schlüssel])
Ta946
46

Hier ist noch einer:

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

Die Funktion gibt keyeinfach den Wert zurück, der für das Ranking verwendet werden soll, und max()gibt das angeforderte Element sofort zurück.

user994998
quelle
10
.iterkeys wird in Ihrer Antwort nicht benötigt (dies ist die Standardeinstellung beim Iterieren eines Diktats). Beachten Sie jedoch, dass die .iteritems-Methode sowohl Schlüssel als auch Wert in einem Schritt abruft, sodass bei .iterkeys kein zusätzliches getitem pro Schlüssel erforderlich ist.
Tzot
Dies ist eine großartige Antwort, da sehr klar ist, was vor sich geht, und daher leicht auf andere Situationen ausgedehnt werden kann.
Leopd
in der Python3-Version:max(stats, key=lambda k: stats[k])
HeyJude
40
key, value = max(stats.iteritems(), key=lambda x:x[1])

Wenn Ihnen der Wert egal ist (ich wäre überrascht, aber), können Sie Folgendes tun:

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

Ich mag das Entpacken des Tupels besser als einen [0] Index am Ende des Ausdrucks. Ich mag die Lesbarkeit von Lambda-Ausdrücken nie sehr, finde sie aber besser als den operator.itemgetter (1) IMHO.

Tim Ottinger
quelle
9
_könnte anstelle von verwendet werden ignored.
JFS
1
@JFSebastian Ich stimme zu, ignoredsieht ziemlich hässlich aus, aber einige Leute sind _aus mehreren Gründen dagegen. Ich denke, das erste Snippet ist in Ordnung, auch wenn Sie den Wert ignorieren
Jamylak
30

Da mehr als ein Eintrag den Maximalwert hat. Ich würde eine Liste der Schlüssel erstellen, deren Wert den Maximalwert hat.

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

Dies gibt Ihnen auch 'b' und jeden anderen Max-Schlüssel.

Hinweis: Verwenden Sie für Python 3 stats.items()anstelle vonstats.iteritems()

Climbs_lika_Spyder
quelle
9
Ihre Lösung ist in Ordnung, berechnet jedoch den Maximalwert so oft, wie Elemente im Diktat enthalten sind. Wenn das Rechnen maxteuer wäre (z. B. ein langes Wörterbuch), würde ich empfehlen, [key for m in [max(stats.values())] for key,val in stats.iteritems() if val == m]wenn Sie einen Einzeiler möchten, andernfalls m = ...vorher berechnen .
Gboffi
4
Nur eine kurze Anmerkung: Verwenden Sie für Python 3 stats.items () anstelle von stats.iteritems ().
Susa
21

Sie können verwenden:

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

Um den Schlüssel zurückzugeben, verwenden Sie das Wertepaar:

max(d.items(), key = lambda k : k[1])
pk786
quelle
7
Dies sollte die akzeptierte Antwort sein, es ist viel einfacher als die Verwendung von Operator
Sigmatics
19

So erhalten Sie den maximalen Schlüssel / Wert des Wörterbuchs stats:

stats = {'a':1000, 'b':3000, 'c': 100}
  • Basierend auf Schlüsseln

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

  • Basierend auf Werten

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

Wenn Sie nur den Schlüssel oder Wert aus dem Ergebnis erhalten möchten, können Sie natürlich die Tupelindizierung verwenden. Zum Beispiel, um den Schlüssel zu erhalten, der dem Maximalwert entspricht:

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

Erläuterung

Die Wörterbuchmethode items()in Python 3 gibt ein Ansichtsobjekt des Wörterbuchs zurück. Wenn dieses Ansichtsobjekt von der maxFunktion durchlaufen wird, werden die Wörterbuchelemente als Tupel des Formulars ausgegeben (key, value).

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

Wenn Sie den lambdaAusdruck verwenden lambda x: x[1], ist in jeder Iteration x eines dieser Tupel (key, value). Wenn Sie also den richtigen Index auswählen, wählen Sie aus, ob Sie nach Schlüsseln oder nach Werten vergleichen möchten.

Python 2

Für Python 2.2+ -Versionen funktioniert derselbe Code. Es ist jedoch besser, die iteritems()Wörterbuchmethode anstelle von zu verwendenitems() Leistung zu verwenden.

Anmerkungen

  • Diese Antwort basiert auf den Kommentaren zur Antwort von Climbs_lika_Spyder .

  • Der verwendete Code wurde unter Python 3.5.2 und Python 2.7.10 getestet.

Karim Sonbol
quelle
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')
Priya Khokher
quelle
10

Gemäß den iterierten Lösungen über Kommentare in der ausgewählten Antwort ...

In Python 3:

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

In Python 2:

max(stats.iterkeys(), key=(lambda k: stats[k]))
Watsonic
quelle
Ihre Lösung für Python 3 funktioniert auch für Python 2.7.
Patapouf_ai
4
weil keys () keinen Iterator in Python 2
zurückgibt
10

Ich bin hierher gekommen, um zu suchen, wie ich mydict.keys()basierend auf dem Wert von zurückkehren kann mydict.values(). Anstatt nur den einen Schlüssel zurückzugeben, wollte ich das oberste x zurückgeben Anzahl von Werten zurückgeben.

Diese Lösung ist einfacher als die Verwendung der max()Funktion und Sie können die Anzahl der zurückgegebenen Werte leicht ändern:

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

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

Wenn Sie den einzigen Schlüssel mit dem höchsten Rang möchten, verwenden Sie einfach den Index:

x[0]
['b']

Wenn Sie die beiden obersten Schlüssel mit dem höchsten Rang möchten, verwenden Sie einfach das Listen-Slicing:

x[:2]
['b', 'a']
donrondadon
quelle
Dies ist eine sehr ineffiziente Lösung. Das Sortieren des Diktats führt zu einer Laufzeit von n log (n), da Sie sich mit einer Reihe von Werten befassen, die nicht das Maximum sind. Die Verwendung der Max-Funktion führt zu einer Laufzeit von nur n, was viel schneller ist.
Peter Graham
1
@PeterGraham verwendet so ziemlich jede Lösung hier (einschließlich der akzeptierten Antwort) max(). Es ist klar, dass es das schnellste ist. Ich dachte, ich würde eine andere Lösung mit dem Vorteil des Schneidens anbieten, was für mich damals nützlicher war
donrondadon
8

Mit keiner dieser Antworten war ich zufrieden. maxwählt immer den ersten Schlüssel mit dem Maximalwert. Das Wörterbuch kann mehrere Schlüssel mit diesem Wert haben.

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

Veröffentlichen Sie diese Antwort, falls sie jemandem hilft. Siehe den folgenden SO-Beitrag

Welches Maximum wählt Python bei einem Unentschieden?

kslote1
quelle
7

Mit collections.Counterkönnte man machen

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

Gegebenenfalls können Sie einfach mit einem Leerzeichen beginnen collections.Counterund es ergänzen

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

Eine Heap-Warteschlange ist eine verallgemeinerte Lösung, mit der Sie die nach Wert geordneten obersten n Schlüssel extrahieren können:

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'

Hinweis dict.__getitem__ist die Methode, die vom syntaktischen Zucker aufgerufen wird dict[]. Im Gegensatz dazu dict.getwird es zurückgegeben, KeyErrorwenn kein Schlüssel gefunden wird, was hier nicht vorkommen kann.

jpp
quelle
4

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

Jasha
quelle
1
Dies wird nach dem Schlüssel mit doppelten Maximalwerten sortiert. Das kann erwünscht sein oder nicht.
Rob Rose
2

+1 auf @Aric Coadys einfachste Lösung.
Und auch eine Möglichkeit, zufällig einen der Schlüssel mit maximalem Wert im Wörterbuch auszuwählen:

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])
Woooody Amadeus
quelle
1
Counter = 0
for word in stats.keys():
    if stats[word]> counter:
        Counter = stats [word]
print Counter
Erika Sawajiri
quelle
1

Wie wäre es mit:

 max(zip(stats.keys(), stats.values()), key=lambda t : t[1])[0]
user2399453
quelle
3
zip(stats.keys(), stats.values())ist nur ein längerer Weg zu schreiben stats.items(). Sobald Sie diese Änderung vorgenommen haben, ist Ihre Antwort fast identisch mit mehreren älteren Antworten.
Vaultah
Einverstanden war mir nicht bewusst, dass items () dasselbe ist wie zip
identisch user2399453
itemsist nicht dasselbe wie zip. Es wird nur das gleiche Ergebnis erzielt.
Paul Rooney
0

Ich habe die akzeptierte Antwort AND @ thewolfs schnellste Lösung gegen eine sehr einfache Schleife getestet und die Schleife war schneller als beide:

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

Ergebnisse:

Iterating: 3.8201940059661865
List creating: 6.928712844848633
Accepted answer: 5.464320182800293
Ragardner
quelle
0

Für Benutzer von wissenschaftlichen Pythons ist hier eine einfache Lösung mit Pandas:

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

>>> b
wkzhu
quelle
0

In dem Fall, dass Sie mehr als einen Schlüssel mit demselben Wert haben, zum Beispiel:

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

Sie können eine Sammlung mit allen Schlüsseln mit maximalem Wert wie folgt erhalten:

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']
Ignacio Alorre
quelle
0

Viel einfacher zu verstehender Ansatz:

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

Ausgabe: ['a', 'g']

Jetzt können Sie nur noch einen Schlüssel auswählen:

maximum = dict[max_value_keys[0]]
Ali Sajjad
quelle