Lấy chìa khóa với giá trị tối đa trong từ điển?

Tôi có một dictionary: khóa là chuỗi, giá trị là số nguyên.

Thí dụ:

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

Tôi muốn nhận được 'b'câu trả lời, vì đó là chìa khóa có giá trị cao hơn.

Tôi đã làm như sau, sử dụng một danh sách trung gian với các bộ dữ liệu khóa-giá trị đảo ngược:

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

Đó có phải là một cách tiếp cận tốt hơn (hoặc thậm chí thanh lịch hơn)?

Bạn có thể sử dụng operator.itemgettercho điều đó:

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

Và thay vì xây dựng một danh sách mới trong sử dụng bộ nhớ stats.iteritems(). Các keytham số cho max()chức năng là một hàm tính toán một chìa khóa được sử dụng để xác định cách quản lý mục xếp hạng.

Xin lưu ý rằng nếu bạn có một cặp giá trị khóa khác 'd': 3000 thì phương thức này sẽ chỉ trả về một trong hai mặc dù cả hai đều có giá trị tối đa.

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

Nếu sử dụng Python3:

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

max(stats, key=stats.get)

Tôi đã thử nghiệm NHIỀU biến thể và đây là cách nhanh nhất để trả về khóa của dict với giá trị tối đa:

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

Để cho bạn một ý tưởng, đây là một số phương pháp ứng cử viên:

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) 

Từ điển kiểm tra:

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}

Và kết quả kiểm tra theo 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%     --

Và theo 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%     -- 

Bạn có thể thấy đó f1là nhanh nhất trong Python 3.2 và 2.7 (hoặc, hoàn toàn hơn, keywithmaxvalở đầu bài này)

Nếu bạn chỉ cần biết một khóa có giá trị tối đa, bạn có thể thực hiện mà không cần iterkeyshoặc iteritemsbởi vì việc lặp qua từ điển trong Python là lặp lại thông qua các khóa đó.

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

BIÊN TẬP:

Từ ý kiến, @ user1274878:

Tôi mới làm quen với trăn. Bạn có thể vui lòng giải thích câu trả lời của bạn trong các bước?

Vâng...

tối đa

tối đa (lặp lại [, phím])

tối đa (arg1, arg2, * args [, key])

Trả về mục lớn nhất trong một lần lặp hoặc lớn nhất trong hai hoặc nhiều đối số.

Đối keysố tùy chọn mô tả cách so sánh các yếu tố để có được tối đa giữa chúng:

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

Các giá trị trả về sẽ được so sánh.

Dict

Python dict là một bảng băm. Khóa của dict là hàm băm của một đối tượng được khai báo là khóa. Vì lý do hiệu suất lặp đi lặp lại mặc dù một lệnh được thực hiện như là lặp qua các khóa của nó.

Do đó, chúng ta có thể sử dụng nó để loại bỏ hoạt động lấy danh sách khóa.

Khép kín

Một hàm được định nghĩa bên trong một hàm khác được gọi là hàm lồng nhau. Các hàm lồng nhau có thể truy cập các biến của phạm vi kèm theo.

Các statsbiến qua sẵn __closure__thuộc tính của lambdachức năng như một con trỏ đến giá trị của biến được định nghĩa trong phạm vi phụ huynh.

Thí dụ:

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

nếu bạn muốn tìm giá trị tối đa bằng khóa của nó, có thể follwing có thể đơn giản, không có bất kỳ chức năng liên quan nào.

max(stats, key=stats.get)

đầu ra là khóa có giá trị tối đa.

Đây là một cái nữa:

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

Hàm keychỉ đơn giản trả về giá trị nên được sử dụng để xếp hạng và max()trả về phần tử được yêu cầu ngay lập tức.

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

Nếu bạn không quan tâm đến giá trị (tôi sẽ ngạc nhiên, nhưng) bạn có thể làm:

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

Tôi thích bộ giải nén tốt hơn một chỉ mục [0] ở cuối biểu thức. Tôi không bao giờ thích khả năng đọc của biểu thức lambda rất nhiều, nhưng tìm thấy cái này tốt hơn toán tử.itemgetter (1) IMHO.

Cho rằng nhiều hơn một mục nhập của tôi có giá trị tối đa. Tôi sẽ tạo một danh sách các khóa có giá trị tối đa là giá trị của chúng.

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

Điều này sẽ cung cấp cho bạn 'b' và bất kỳ khóa tối đa nào khác.

Lưu ý: Đối với python 3 sử dụng stats.items()thay vìstats.iteritems()

Bạn có thể dùng:

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

Để trả về khóa, cặp giá trị sử dụng:

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

Để lấy khóa / giá trị tối đa của từ điển stats:

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

• Dựa trên các phím

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

• Dựa trên các giá trị

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

Tất nhiên, nếu bạn chỉ muốn lấy khóa hoặc giá trị từ kết quả, bạn có thể sử dụng lập chỉ mục tuple. Ví dụ: để lấy khóa tương ứng với giá trị tối đa:

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

Giải trình

Phương thức từ điển items()trong Python 3 trả về một đối tượng xem của từ điển. Khi đối tượng khung nhìn này được lặp đi lặp lại, bởi maxhàm, nó mang lại các mục từ điển dưới dạng bộ dữ liệu của biểu mẫu (key, value).

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

Khi bạn sử dụng lambdabiểu thức lambda x: x[1], trong mỗi lần lặp, x là một trong những bộ dữ liệu này (key, value). Vì vậy, bằng cách chọn đúng chỉ mục, bạn chọn xem bạn muốn so sánh theo khóa hay theo giá trị.

Con trăn 2

Đối với các bản phát hành Python 2.2+, cùng một mã sẽ hoạt động. Tuy nhiên, tốt hơn là sử dụng iteritems()phương pháp từ điển thay vì items()hiệu suất.

Ghi chú

• Câu trả lời này dựa trên các nhận xét về câu trả lời của Climbs_lika_Spyder .

• Mã được sử dụng đã được thử nghiệm trên Python 3.5.2 và 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')

Theo các giải pháp lặp qua các bình luận trong câu trả lời đã chọn ...

Trong Python 3:

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

Trong Python 2:

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

Tôi đến đây để tìm cách trả lại mydict.keys()dựa trên giá trị của mydict.values(). Thay vì chỉ trả về một khóa, tôi đang tìm cách trả về số x giá trị hàng đầu .

Giải pháp này đơn giản hơn so với sử dụng max()hàm và bạn có thể dễ dàng thay đổi số lượng giá trị được trả về:

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

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

Nếu bạn muốn khóa xếp hạng cao nhất duy nhất, chỉ cần sử dụng chỉ mục:

x[0]
['b']

Nếu bạn muốn hai khóa xếp hạng cao nhất hàng đầu, chỉ cần sử dụng danh sách cắt:

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

Tôi không hài lòng với bất kỳ câu trả lời nào. maxluôn chọn khóa đầu tiên với giá trị tối đa. Từ điển có thể có nhiều khóa với giá trị đó.

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

Đăng câu trả lời này trong trường hợp nó giúp ai đó ra ngoài. Xem bài viết dưới đây

Python chọn tối đa trong trường hợp hòa?

Với collections.Counterbạn có thể làm

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

Nếu thích hợp, bạn có thể chỉ cần bắt đầu với một khoảng trống collections.Countervà thêm vào nó

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

Hàng đợi heap là một giải pháp tổng quát cho phép bạn trích xuất các khóa n hàng đầu theo thứ tự giá trị:

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'

Lưu ý dict.__getitem__là phương pháp được gọi bằng đường cú pháp dict[]. Trái ngược với dict.getnó, nó sẽ trở lại KeyErrornếu không tìm thấy khóa, điều này ở đây không thể xảy ra.

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

+1 cho giải pháp đơn giản nhất của @Aric Coady .
Và cũng là một cách để chọn ngẫu nhiên một trong các khóa có giá trị tối đa trong từ điển:

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

Làm thế nào về:

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

Tôi đã thử nghiệm câu trả lời được chấp nhận VÀ giải pháp nhanh nhất của @ thewolf đối với một vòng lặp rất cơ bản và vòng lặp nhanh hơn cả hai:

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

các kết quả:

Iterating: 3.8201940059661865
List creating: 6.928712844848633
Accepted answer: 5.464320182800293

Đối với người dùng python khoa học, đây là một giải pháp đơn giản sử dụng Pandas:

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

>>> b

Trong trường hợp bạn có nhiều hơn một khóa có cùng giá trị, ví dụ:

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

Bạn có thể nhận được một bộ sưu tập với tất cả các khóa có giá trị tối đa như sau:

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

Cách tiếp cận đơn giản hơn nhiều:

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

Đầu ra: ['a', 'g']

Bây giờ bạn chỉ có thể chọn một khóa:

maximum = dict[max_value_keys[0]]