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

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?

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'

max(stats, key=stats.get)

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

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 .

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.

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.

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.

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

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

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.

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

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

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

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?

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. 

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.

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

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

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

Wie wäre es mit:

 max(zip(stats.keys(), stats.values()), key=lambda t : t[1])[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

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

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

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