Mendapatkan kunci dengan nilai maksimum dalam kamus?

Saya punya dictionary: kunci adalah string, nilai adalah bilangan bulat.

Contoh:

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

Saya ingin mendapat 'b'jawaban, karena itu kuncinya dengan nilai yang lebih tinggi.

Saya melakukan hal berikut, menggunakan daftar perantara dengan tupel nilai kunci terbalik:

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

Apakah itu pendekatan yang lebih baik (atau bahkan lebih elegan)?

Anda dapat menggunakannya operator.itemgetteruntuk itu:

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

Dan bukannya membangun daftar baru dalam penggunaan memori stats.iteritems(). The keyparameter ke max()fungsi adalah fungsi yang menghitung kunci yang digunakan untuk menentukan bagaimana peringkat item.

Harap dicatat bahwa jika Anda memiliki pasangan nilai kunci lain 'd': 3000 bahwa metode ini hanya akan mengembalikan salah satu dari keduanya meskipun keduanya memiliki nilai maksimum.

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

Jika menggunakan Python3:

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

max(stats, key=stats.get)

Saya telah menguji varian BANYAK, dan ini adalah cara tercepat untuk mengembalikan kunci dict dengan nilai maks:

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

Untuk memberi Anda ide, berikut adalah beberapa metode kandidat:

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) 

Kamus uji:

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}

Dan hasil tes di bawah 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%     --

Dan di bawah 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%     -- 

Anda dapat melihat bahwa f1ini adalah yang tercepat di bawah Python 3.2 dan 2.7 (atau, lebih lengkap, keywithmaxvaldi bagian atas posting ini)

Jika Anda hanya perlu mengetahui kunci dengan nilai maksimal, Anda dapat melakukannya tanpa iterkeysatau iteritemskarena iterasi melalui kamus di Python adalah iterasi melalui kunci itu.

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

EDIT:

Dari komentar, @ user1274878:

Saya baru mengenal python. Bisakah Anda jelaskan jawaban Anda dalam langkah-langkah?

Ya...

maks

maks (iterable [, key])

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

Mengembalikan item terbesar dalam iterable atau argumen terbesar dari dua atau lebih.

keyArgumen opsional menjelaskan cara membandingkan elemen untuk mendapatkan maksimum di antara mereka:

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

Nilai yang dikembalikan akan dibandingkan.

Diktik

Python dict adalah tabel hash. Kunci dikt adalah hash dari objek yang dideklarasikan sebagai kunci. Karena alasan kinerja iterasi meskipun diktat diterapkan sebagai iterasi melalui kunci itu.

Oleh karena itu kita dapat menggunakannya untuk menghilangkan operasi mendapatkan daftar kunci.

Penutupan

Fungsi yang didefinisikan di dalam fungsi lain disebut fungsi bersarang. Fungsi bersarang dapat mengakses variabel dari lingkup terlampir.

The statsvariabel tersedia melalui __closure__atribut dari lambdafungsi sebagai pointer dengan nilai variabel yang didefinisikan dalam lingkup induk.

Contoh:

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

jika Anda ingin menemukan nilai maksimal dengan kuncinya, mungkin follwing bisa sederhana, tanpa fungsi yang relevan.

max(stats, key=stats.get)

output adalah kunci yang memiliki nilai maksimal.

Ini satu lagi:

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

Fungsi ini keyhanya mengembalikan nilai yang harus digunakan untuk peringkat dan max()mengembalikan elemen yang diminta segera.

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

Jika Anda tidak peduli dengan nilai (saya akan terkejut, tetapi) Anda dapat melakukannya:

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

Saya suka tuple membongkar lebih baik daripada subscript [0] di akhir ekspresi. Saya tidak pernah suka keterbacaan ekspresi lambda sangat banyak, tetapi menemukan ini lebih baik daripada operator.itemgetter (1) IMHO.

Mengingat bahwa lebih dari satu entri saya memiliki nilai maksimal. Saya akan membuat daftar kunci yang memiliki nilai maks sebagai nilainya.

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

Ini akan memberi Anda 'b' dan kunci maks lainnya juga.

Catatan: Untuk python 3 gunakan stats.items()sebagai gantistats.iteritems()

Kamu bisa menggunakan:

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

Untuk mengembalikan kunci, gunakan pasangan nilai:

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

Untuk mendapatkan kunci / nilai maksimum kamus stats:

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

• Berdasarkan kunci

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

• Berdasarkan nilai-nilai

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

Tentu saja, jika Anda hanya ingin mendapatkan kunci atau nilai dari hasilnya, Anda dapat menggunakan pengindeksan tuple. Misalnya, untuk mendapatkan kunci yang sesuai dengan nilai maksimum:

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

Penjelasan

Metode kamus items()di Python 3 mengembalikan objek tampilan kamus. Ketika objek tampilan ini diulang, dengan maxfungsi, itu menghasilkan item kamus sebagai tupel formulir (key, value).

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

Saat Anda menggunakan lambdaekspresi lambda x: x[1], di setiap iterasi, x adalah salah satu dari tupel ini (key, value). Jadi, dengan memilih indeks yang tepat, Anda memilih apakah Anda ingin membandingkan dengan kunci atau dengan nilai.

Python 2

Untuk rilis Python 2.2+, kode yang sama akan berfungsi. Namun, lebih baik menggunakan iteritems()metode kamus daripada items()untuk kinerja.

Catatan

• Jawaban ini didasarkan pada komentar pada jawaban Climbs_lika_Spyder .

• Kode yang digunakan diuji pada Python 3.5.2 dan Python 2.7.10.

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

Per solusi yang diulang melalui komentar di jawaban yang dipilih ...

Dengan Python 3:

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

Dengan Python 2:

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

Saya sampai di sini mencari cara mengembalikan mydict.keys()berdasarkan nilai mydict.values(). Alih-alih hanya satu kunci yang dikembalikan, saya mencari untuk mengembalikan x atas jumlah nilai .

Solusi ini lebih sederhana daripada menggunakan max()fungsi dan Anda dapat dengan mudah mengubah jumlah nilai yang dikembalikan:

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

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

Jika Anda ingin kunci peringkat tertinggi tunggal, cukup gunakan indeks:

x[0]
['b']

Jika Anda ingin dua kunci peringkat teratas, cukup gunakan pemotongan daftar:

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

Saya tidak puas dengan jawaban ini. maxselalu mengambil kunci pertama dengan nilai maksimal. Kamus dapat memiliki beberapa kunci dengan nilai itu.

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

Posting jawaban ini jika itu membantu seseorang. Lihat posting SO di bawah ini

Maksimum manakah yang dipilih oleh Python untuk dasi?

Dengan collections.CounterAnda bisa melakukannya

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

Jika sesuai, Anda bisa mulai dengan yang kosong collections.Counterdan menambahkannya

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

Heap queue adalah solusi umum yang memungkinkan Anda untuk mengekstrak kunci n atas yang diurutkan berdasarkan nilai:

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'

Catatan dict.__getitem__adalah metode yang disebut oleh gula sintaksis dict[]. Berbeda dengan dict.get, itu akan kembali KeyErrorjika kunci tidak ditemukan, yang di sini tidak dapat terjadi.

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

+1 ke @Aric Coady solusi paling sederhana.
Dan juga satu cara untuk secara acak memilih salah satu kunci dengan nilai maksimal dalam kamus:

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

Bagaimana tentang:

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

Saya menguji jawaban yang diterima DAN @ solusi manusia serigala terhadap loop yang sangat dasar dan loop lebih cepat dari keduanya:

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

hasil:

Iterating: 3.8201940059661865
List creating: 6.928712844848633
Accepted answer: 5.464320182800293

Untuk pengguna python ilmiah, berikut adalah solusi sederhana menggunakan Pandas:

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

>>> b

Jika Anda memiliki lebih dari satu kunci dengan nilai yang sama, misalnya:

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

Anda bisa mendapatkan koleksi dengan semua kunci dengan nilai maksimal sebagai berikut:

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

Jauh lebih sederhana untuk memahami pendekatan:

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

Keluaran: ['a', 'g']

Sekarang Anda hanya dapat memilih satu kunci:

maximum = dict[max_value_keys[0]]