Dostajesz klucz z maksymalną wartością w słowniku?

866

Mam dictionary: klucze są ciągami, wartości są liczbami całkowitymi.

Przykład:

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

Chciałbym uzyskać 'b'odpowiedź, ponieważ jest to klucz o wyższej wartości.

Wykonałem następujące czynności, używając listy pośredniej z odwróconymi krotkami klucz-wartość:

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

Czy to jest lepsze (a nawet bardziej eleganckie) podejście?

Ricafeal
źródło
1
Co jest nie tak max(stats)?
John Red,
12
max(stats)użyje etykiet jako kluczy (zwróci 'c', pod warunkiem , że jest to maksymalna etykieta), max(stats, key=lambda key: stats[key])to jest to , co było po OP (co zwróci 'b', etykieta o maksymalnej wartości indeksowanej). Czy to jest jaśniejsze?
Atcold

Odpowiedzi:

609

Możesz użyć operator.itemgetterdo tego:

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

I zamiast budowania nowej listy w użyciu pamięci stats.iteritems(). keyParametr do max()funkcji jest funkcja, która oblicza klucz, który jest używany do określenia, w jaki sposób przedmioty rangi.

Pamiętaj, że jeśli miałbyś mieć inną parę klucz-wartość „d”: 3000, ta metoda zwróci tylko jedną z dwóch, mimo że obie mają maksymalną wartość.

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

Jeśli używasz Python3:

>>> max(stats.items(), key=operator.itemgetter(1))[0]
'b'
Priyanka Chaudhary
źródło
242
Myślę, że nawet czystsze =max(stats.iterkeys(), key=(lambda key: stats[key]))
Lucretiel,
18
Dlaczego nie po prostu użyć key=lambda x: x[1]?
BenDundee
43
w python 3 @ Lucretiel rozwiązanie (poprawnie pisane) kończy się niepowodzeniem. powinno to być: max (stats.keys (), key = (lambda k: stats [k])), ponieważ keys () robi teraz to, co robił iterkeys () automatycznie.
watsonic
73
Rigth jesteś. Co ciekawe, rozwiązaniem, które jest równie wydajne pod względem pamięci i działa zarówno w Pythonie 2, jak i 3, jest:max(stats, key=lambda key: stats[key])
Lucretiel
3
Szczerze mówiąc, myślę, że komentarze mają czystsze i lepsze rozwiązanie.
Augusto Gonzalez,
1177
max(stats, key=stats.get)
A. Coady
źródło
17
jeśli naprawdę chcesz to zrobić w ten sposób, możesz to zrobićstats[max(stats, key=stats.get)]
CrackSmoker9000
81
@scottmrogowski, ss. Zapewnia kluczowi maksymalną wartość, zgodnie z zapytaniem. Maksymalna wartość to po prostu max (stats.values ​​()).
A. Coady
25
To powinna być odpowiedź, ponieważ jest najprostsza i była dokładnie tym, o co poprosił PO.
ihatecache
4
@ Załaduj co zrobić, jeśli istnieje remis między dwoma kluczami (o tej samej wartości)? Chcę je zdobyć, ale dostaję tylko jedną.
oba2311
10
@ oba2311max_value = max(stats.values()); {key for key, value in stats.items() if value == max_value}
A. Coady
208

Przetestowałem WIELE wariantów i jest to najszybszy sposób na zwrócenie klucza dykta z maksymalną wartością:

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

Aby dać Ci pomysł, oto kilka metod kandydujących:

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) 

Słownik testowy:

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}

A wyniki testu w Pythonie 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%     --

I w Pythonie 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%     -- 

Możesz zobaczyć, że f1jest to najszybszy w Pythonie 3.2 i 2.7 (lub, bardziej szczegółowo, keywithmaxvalna początku tego postu)

Wilk
źródło
12
To wydaje się podejrzane. f7to f1po prostu nie nadawanie nazwy obiektowi pośredniemu. f7powinien być (bardzo nieznacznie) szybszy niż f1, nie znacznie wolniejszy. I to właśnie otrzymuję:>>> 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
Przywróć Monikę
1
zgadzam się, że f1 jest jak f7. Wykonałem test z ipython% timeit i oba uzyskały taką samą wydajność na moim komputerze w Pythonie 2.7. Testowanie: f1 - 18 µs na pętlę Testowanie: f2 - 33,7 µs na pętlę Testowanie: f3b - 50 µs na pętlę Testowanie: f4b - 30,7 µs na pętlę Testowanie: f5 - 28 µs na pętlę Testowanie: f6 - 23 µs na pętlę Testowanie: f7 - 18 µs na pętlę Testowanie: f8 - 43,9 µs na pętlę Testowanie: f4 - 2,16 ms na pętlę Testowanie: f3 - 2,29 ms na pętlę
Joop
f1 ma również zastosowanie wszędzie tam, gdzie maks. (d, klawisz) nie jest dostępne.
Nikos Alexandris,
5
Myślałem, że dyktowanie jest nieposortowane, czy d. Klucze i wartości d. Teoretycznie można zamówić inaczej?
Dimath,
1
Rozwiązania do kopiowania listy są dla mnie śmierdzące. Jak ocenia się wykonanie nagrania z tysiącami lub milionami wpisów?
Lucretiel
63

Jeśli potrzebujesz znać tylko klucz o maksymalnej wartości, możesz to zrobić bez niego iterkeyslub iteritemsponieważ iteracja przez słownik w Pythonie jest iteracją przez jego klucze.

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

EDYTOWAĆ:

Z komentarzy, @ user1274878:

Jestem nowy w Pythonie. Czy możesz wyjaśnić krok po kroku swoją odpowiedź?

Tak...

max

max (iterowalny [, klucz])

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

Zwraca największy element w iterowalnym lub największy z dwóch lub więcej argumentów.

Opcjonalny keyargument opisuje, jak porównywać elementy, aby uzyskać maksimum między nimi:

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

Zwrócone wartości zostaną porównane.

Dict

Python dict to tablica skrótów. Kluczem słownika jest skrót obiektu zadeklarowanego jako klucz. Ze względu na wydajność iteracja jest wykonywana za pomocą klucza.

Dlatego możemy go użyć do pozbycia się operacji uzyskiwania listy kluczy.

Zamknięcie

Funkcja zdefiniowana w innej funkcji nazywa się funkcją zagnieżdżoną. Funkcje zagnieżdżone mogą uzyskiwać dostęp do zmiennych obejmującego zakres.

statsZmienny dostępny przez __closure__atrybut lambdafunkcji jako wskaźnik do wartości zmiennej określonej w zakresie macierzystego.

I159
źródło
1
@ I159: Jestem nowy w Pythonie. Czy możesz wyjaśnić krok po kroku swoją odpowiedź
użytkownik1274878,
57

Przykład:

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

jeśli chcesz znaleźć wartość maksymalną za pomocą klucza, być może śledzenie może być proste, bez żadnych istotnych funkcji.

max(stats, key=stats.get)

wyjście jest kluczem o maksymalnej wartości.

leo022
źródło
rozwiązanie przetestowane szybciej niż maksimum (statystyki, klucz = klucz lambda: statystyki [klucz])
Ta946
46

Oto kolejny:

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

Funkcja keypo prostu zwraca wartość, która powinna być użyta do rankingu i max()natychmiast zwraca żądany element.

użytkownik994998
źródło
10
.iterkeys nie jest potrzebny w twojej odpowiedzi (jest to domyślna opcja podczas iteracji nagrania). Należy jednak pamiętać, że metoda .iteritems pobiera zarówno klucz, jak i wartość w jednym kroku, więc nie ma potrzeby dodatkowego getitem na klucz w razie potrzeby z .iterkeys.
tzot
To świetna odpowiedź, ponieważ jest bardzo jasne, co się dzieje, i dlatego łatwo ją rozszerzyć na inne sytuacje.
Leopd
w wersji python3:max(stats, key=lambda k: stats[k])
HeyJude
40
key, value = max(stats.iteritems(), key=lambda x:x[1])

Jeśli nie zależy ci na wartości (byłbym zaskoczony, ale) możesz:

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

Podoba mi się rozpakowywanie krotki lepiej niż indeks [0] na końcu wyrażenia. Nigdy nie bardzo lubię czytelność wyrażeń lambda, ale uważam, że jest ona lepsza niż operator.itemgetter (1) IMHO.

Tim Ottinger
źródło
9
_można użyć zamiast ignored.
jfs,
1
@JFSebastian Zgadzam się, ignoredwygląda dość brzydko, ale niektórzy ludzie są przeciwni używaniu _z kilku powodów. Myślę, że pierwszy fragment
kodu
30

Biorąc pod uwagę, że więcej niż jeden wpis mój ma wartość maksymalną. Zrobiłbym listę kluczy, które mają maksymalną wartość jako swoją wartość.

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

To da ci „b”, a także dowolny inny maksymalny klawisz.

Uwaga: W przypadku Python 3 użyj stats.items()zamiaststats.iteritems()

Climbs_lika_Spyder
źródło
9
Twoje rozwiązanie jest OK, ale oblicza maksymalną wartość tyle razy, ile jest pozycji w dykcie. Jeśli obliczenia maxbyły drogie (np. Słownik LONG), polecam, [key for m in [max(stats.values())] for key,val in stats.iteritems() if val == m]jeśli chcesz mieć jedną linijkę, w przeciwnym razie oblicz m = ...wcześniej.
gboffi
4
Krótka uwaga: w Pythonie 3 użyj stats.items () zamiast stats.iteritems ().
Susa
21

Możesz użyć:

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

Aby zwrócić klucz, użyj pary wartości:

max(d.items(), key = lambda k : k[1])
pk786
źródło
7
To powinna być zaakceptowana odpowiedź, jest to o wiele prostsze niż używanie operatora
Sigmatics
19

Aby uzyskać maksymalną wartość klucza / wartości słownika stats:

stats = {'a':1000, 'b':3000, 'c': 100}
  • Na podstawie kluczy

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

  • Na podstawie wartości

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

Oczywiście, jeśli chcesz uzyskać tylko klucz lub wartość z wyniku, możesz użyć indeksowania krotek. Na przykład, aby uzyskać klucz odpowiadający maksymalnej wartości:

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

Wyjaśnienie

Metoda słownikowa items()w Pythonie 3 zwraca obiekt widoku słownika. Gdy obiekt widoku jest iterowany, maxfunkcja zwraca elementy słownika w postaci krotek formularza (key, value).

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

Kiedy używasz lambdawyrażenia lambda x: x[1], w każdej iteracji x jest jedną z tych krotek (key, value). Tak więc, wybierając odpowiedni indeks, decydujesz, czy chcesz porównać według kluczy, czy według wartości.

Python 2

W wersjach Python 2.2+ ten sam kod będzie działał. Lepiej jednak użyć iteritems()metody słownikowej zamiast items()wydajności.

Notatki

Karim Sonbol
źródło
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
źródło
10

Według iterowanych rozwiązań za pomocą komentarzy w wybranej odpowiedzi ...

W Pythonie 3:

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

W Python 2:

max(stats.iterkeys(), key=(lambda k: stats[k]))
watsonic
źródło
Twoje rozwiązanie dla Python 3 działa również dla Python 2.7.
patapouf_ai
4
ponieważ keys () nie zwraca iteratora w pythonie 2, a zatem wykonuje hit wydajnościowy
watsonic
10

Przybyłem tutaj, szukając sposobu zwrotu w mydict.keys()oparciu o wartość mydict.values(). Zamiast zwrócić tylko jeden klucz, chciałem zwrócić górny x liczbę wartości.

To rozwiązanie jest prostsze niż użycie max()funkcji i możesz łatwo zmienić liczbę zwracanych wartości:

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

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

Jeśli chcesz mieć pojedynczy klucz o najwyższej pozycji, po prostu użyj indeksu:

x[0]
['b']

Jeśli chcesz uzyskać dwa najwyższe klucze w rankingu, po prostu użyj wycinania listy:

x[:2]
['b', 'a']
donrondadon
źródło
To bardzo nieefektywne rozwiązanie. Sortowanie dykta spowoduje uruchomienie n log (n), ponieważ masz na myśli szereg wartości, które nie są maksymalne. Użycie funkcji max spowoduje, że środowisko uruchomieniowe będzie mieć tylko n, co jest znacznie szybsze.
Peter Graham
1
@PeterGraham używa prawie każdego rozwiązania (w tym przyjętej odpowiedzi) max(). Jest jasne, że jest najszybszy. Pomyślałem, że zaoferuję inne rozwiązanie z korzyścią krojenia, które wtedy było mi bardziej przydatne
donrondadon
8

Nie byłem zadowolony z żadnej z tych odpowiedzi. maxzawsze wybiera pierwszy klucz o maksymalnej wartości. Słownik może mieć wiele kluczy o tej wartości.

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

Opublikowanie tej odpowiedzi na wypadek, gdyby pomogło komuś. Zobacz poniższy post SO

Jakie maksimum wybiera Python w przypadku remisu?

kslote1
źródło
7

Z collections.Countertobą możesz zrobić

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

W razie potrzeby możesz po prostu zacząć od pustego collections.Counteri dodać do niego

>>> stats = collections.Counter()
>>> stats['a'] += 1
:
etc. 
ukrutt
źródło
5

Kolejka sterty jest uogólnionym rozwiązaniem, które pozwala wyodrębnić n głównych kluczy uporządkowanych według wartości:

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'

Uwaga dict.__getitem__to metoda wywoływana przez cukier syntaktyczny dict[]. W przeciwieństwie do dict.getzwróci, KeyErrorjeśli klucz nie zostanie znaleziony, co tutaj nie może wystąpić.

jpp
źródło
4

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

Jasha
źródło
1
Porządkuje to według klucza ze zduplikowanymi wartościami maksymalnymi. To może, ale nie musi być pożądane.
Rob Rose
2

+1 do najprostszego rozwiązania @Arica Coady .
A także jeden ze sposobów losowego wyboru jednego z kluczy o maksymalnej wartości w słowniku:

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
źródło
1
Counter = 0
for word in stats.keys():
    if stats[word]> counter:
        Counter = stats [word]
print Counter
Erika Sawajiri
źródło
1

Co powiesz na:

 max(zip(stats.keys(), stats.values()), key=lambda t : t[1])[0]
użytkownik2399453
źródło
3
zip(stats.keys(), stats.values())to po prostu dłuższy sposób na pisanie stats.items(). Po wprowadzeniu tej zmiany odpowiedź będzie prawie identyczna z kilkoma starszymi odpowiedziami.
vaultah
Zgadzam się, nie wiedziałem, że item () jest taki sam jak zip
user2399453
itemsto nie to samo co zip. Po prostu daje ten sam wynik.
Paul Rooney,
0

Przetestowałem zaakceptowaną odpowiedź ORAZ najszybsze rozwiązanie wilka na bardzo podstawowej pętli, a pętla była szybsza niż obie:

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

wyniki:

Iterating: 3.8201940059661865
List creating: 6.928712844848633
Accepted answer: 5.464320182800293
ragardner
źródło
0

Dla użytkowników naukowych pythonów, oto proste rozwiązanie wykorzystujące Pandy:

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

>>> b
wkzhu
źródło
0

W przypadku, gdy masz więcej niż jeden klucz o tej samej wartości, na przykład:

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

Możesz uzyskać kolekcję ze wszystkimi kluczami o maksymalnej wartości, jak poniżej:

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
źródło
0

Znacznie prostsze do zrozumienia podejście:

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

Wyjście: [„a”, „g”]

Teraz możesz wybrać tylko jeden klucz:

maximum = dict[max_value_keys[0]]
Ali Sajjad
źródło