ශබ්ද කෝෂයේ උපරිම අගය සහිත යතුර ලබා ගන්නේද?

Question 1

මට ඇත්තේ dictionary: යතුරු නූල්, අගයන් පූර්ණ සංඛ්‍යා වේ.

උදාහරණයක්:

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

'b'ඉහළ අගයක් ඇති යතුර බැවින් පිළිතුරක් ලෙස ලබා ගැනීමට මම කැමතියි .

ප්‍රතිලෝම යතුරු අගයන් සහිත අතරමැදි ලැයිස්තුවක් භාවිතා කරමින් මම පහත සඳහන් දේ කළෙමි:

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

එය වඩා හොඳ (හෝ ඊටත් වඩා අලංකාර) ප්‍රවේශයක්ද?

Question 2

ඒ සඳහා ඔබට භාවිතා කළ හැකිය operator.itemgetter:

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

මතක භාවිතයේ නව ලැයිස්තුවක් තැනීම වෙනුවට stats.iteritems(). මෙම keyකිරීමට පරාමිතිය max()කාර්යය නිලය භාණ්ඩ ආකාරය තීරණය කිරීම සඳහා භාවිත කරනු ලබන බව ප්රධාන ගණනය බව ශ්රිතයක් වේ.

3000 මෙම ක්රමය පමණක් නැවත බව: ඔබ තවත් ප්රධාන-අගය යුගල 'd' ඇති කිරීමට නම් ඒ බව කරුණාකර මතක තබා එක් පිළිබඳ දෙකක් ඔවුන් දෙදෙනාම උපරිම වටිනාකමක් තිබිය වුවත්.

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

Python3 භාවිතා කරන්නේ නම්:

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

Question 3

max(stats, key=stats.get)

Question 4

මම බොහෝ ප්‍රභේද අත්හදා බලා ඇති අතර, උපරිම අගය සමඟ ඩික්ට් යතුර ආපසු ලබා දීමට වේගවත්ම ක්‍රමය මෙයයි:

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

ඔබට අදහසක් ලබා දීමට, අපේක්ෂක ක්‍රම කිහිපයක් මෙන්න:

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)

පරීක්ෂණ ශබ්ද කෝෂය:

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}

පයිතන් 3.2 යටතේ පරීක්ෂණ ප්‍රති results ල:

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

සහ පයිතන් 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%     --

f1පයිතන් 3.2 සහ 2.7 යටතේ වේගවත්ම බව ඔබට දැක ගත හැකිය (හෝ, වඩාත් හොඳින්, keywithmaxvalමෙම තනතුරේ ඉහළින්ම)

Question 5

ඔබට උපරිම අගය සහිත යතුරක් පමණක් දැන ගැනීමට අවශ්‍ය නම් ඔබට එය නොමැතිව කළ හැකිය iterkeysහෝ iteritemsපයිතන්හි ශබ්ද කෝෂය හරහා නැවත ක්‍රියා කිරීම එහි යතුරු හරහා නැවත යෙදීම වේ.

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

සංස්කරණය කරන්න:

අදහස් වලින්, @ user1274878:

මම පයිතන්ට අලුත්. කරුණාකර ඔබේ පිළිතුර පියවරෙන් පියවර පැහැදිලි කළ හැකිද?

ඔව් ...

උපරිම

උපරිම (iterable [, key])

උපරිම (arg1, arg2, * args [, key])

විශාලතම අයිතමය නැවත සැකසිය හැකි හෝ විශාලතම තර්ක දෙකකින් හෝ වැඩි ගණනකින් ආපසු එවන්න.

විකල්ප keyතර්කය මඟින් ඒවා අතර උපරිමය ලබා ගැනීම සඳහා මූලද්‍රව්‍ය සංසන්දනය කරන්නේ කෙසේද යන්න විස්තර කරයි:

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

ආපසු ලබා දුන් අගයන් සැසඳෙනු ඇත.

ඩික්

පයිතන් ඩික් යනු හැෂ් වගුවකි. ඩික්ට් යතුර යනු යතුරක් ලෙස ප්‍රකාශයට පත් කරන ලද වස්තුවක හැෂ් ය. කාර්ය සාධන හේතූන් මත පුනරාවර්තනය වුවද එහි යතුරු හරහා පුනරාවර්තනය ලෙස නියෝගයක් ක්‍රියාත්මක වේ.

එබැවින් යතුරු ලැයිස්තුවක් ලබා ගැනීමේ ක්‍රියාවලියෙන් මිදීමට අපට එය භාවිතා කළ හැකිය.

වසා දැමීම

වෙනත් ශ්‍රිතයක් තුළ අර්ථ දක්වා ඇති ශ්‍රිතයක් කැදැලි ශ්‍රිතයක් ලෙස හැඳින්වේ. කැදැලි කාර්යයන් මඟින් සංවෘත විෂය පථයේ විචල්‍යයන්ට ප්‍රවේශ විය හැකිය.

මෙම statsඔස්සේ ලබා ගත හැකි විචල්ය __closure__පිළිබඳ විශේෂණය lambdaමව් විෂය පථය අර්ථ දක්වා ඇති විචල්ය අගය කිරීමට අවධානය යොමුකළ ලෙස කි්රයාත්මක වේ.

Question 6

උදාහරණයක්:

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

ඔබට එහි යතුර සමඟ උපරිම අගය සොයා ගැනීමට අවශ්‍ය නම්, සමහර විට අදාළ කාර්යයන් නොමැතිව අනුගමනය කිරීම සරල විය හැකිය.

max(stats, key=stats.get)

ප්‍රතිදානය යනු උපරිම අගය ඇති යතුරයි.

Question 7

මෙන්න තවත් එකක්:

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

ශ්‍රිතය keyහුදෙක් ශ්‍රේණිගත කිරීම සඳහා භාවිතා කළ යුතු අගය max()ආපසු ලබා දෙන අතර ඉල්ලූ මූලද්‍රව්‍යය වහාම ලබා දෙයි.

Question 8

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

ඔබ වටිනාකම ගැන තැකීමක් නොකරන්නේ නම් (මා පුදුම වනු ඇත, නමුත්) ඔබට කළ හැකිය:

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

ප්‍රකාශනය අවසානයේ [0] ග්‍රාහකයකට වඩා ටුපල් ඉවත් කිරීමට මම කැමතියි. ලැම්බඩා ප්‍රකාශන කියවීමේ හැකියාවට මා කිසි විටෙකත් කැමති නැත, නමුත් මෙය ක්‍රියාකරුට වඩා හොඳය. Itemgetter (1) IMHO.

Question 9

එක් ප්‍රවේශයකට වඩා වැඩි ගණනක මගේ උපරිම අගය ඇත. යතුරු වල වටිනාකම ලෙස උපරිම අගය ඇති යතුරු ලැයිස්තුවක් මම සාදමි.

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

මෙය ඔබට 'b' සහ වෙනත් ඕනෑම උපරිම යතුරක් ලබා දෙනු ඇත.

සටහන: stats.items()වෙනුවට පයිතන් 3 භාවිතය සඳහාstats.iteritems()

Question 10

ඔයාට පාවිච්චි කරන්න පුළුවන්:

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

යතුර ආපසු ලබා දීම සඳහා, අගය යුගල භාවිතය:

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

Question 11

ශබ්ද කෝෂයේ උපරිම යතුර / අගය ලබා ගැනීම සඳහා stats:

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

යතුරු මත පදනම්ව

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

සාරධර්ම මත පදනම්ව

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

ඇත්ත වශයෙන්ම, ඔබට ප්‍රති result ලයෙන් යතුර හෝ අගය පමණක් ලබා ගැනීමට අවශ්‍ය නම්, ඔබට ටුපල් සුචිගත කිරීම භාවිතා කළ හැකිය. උදාහරණයක් ලෙස, උපරිම අගයට අනුරූප යතුර ලබා ගැනීම සඳහා:

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

පැහැදිලි කිරීම

items()පයිතන් 3 හි ඇති ශබ්ද කෝෂ ක්‍රමය මඟින් ශබ්ද කෝෂයේ දර්ශන වස්තුවක් ලබා දෙයි. මෙම දර්ශන වස්තුව maxශ්‍රිතය අනුව නැවත ක්‍රියාවට නංවන විට , එය ශබ්ද කෝෂයේ අයිතම ආකෘති පත්රයේ tuples ලෙස ලබා දෙයි (key, value).

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

ඔබ lambdaප්‍රකාශනය භාවිතා කරන විට lambda x: x[1], එක් එක් නැවතීමේ දී, x මෙම ටුපල් වලින් එකකි(key, value) . එබැවින්, නිවැරදි දර්ශකය තේරීමෙන්, යතුරු හෝ අගයන් අනුව සැසඳිය යුතුද යන්න ඔබ තෝරා ගනී.

පයිතන් 2

පයිතන් 2.2+ නිකුතු සඳහා, එකම කේතය ක්‍රියා කරයි. කෙසේ වෙතත්, කාර්ය සාධනය iteritems()වෙනුවට ශබ්ද කෝෂ ක්‍රමය භාවිතා කිරීම වඩා හොඳය items().

සටහන්

මෙම පිළිතුර පදනම් වී ඇත්තේ Climbs_lika_Spyder ගේ පිළිතුර පිළිබඳ අදහස් මත ය .
භාවිතා කළ කේතය පයිතන් 3.5.2 සහ පයිතන් 2.7.10 හි පරීක්ෂා කරන ලදී.

Question 12

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

Question 13

mydict.keys()වටිනාකම මත පදනම්ව ආපසු පැමිණෙන්නේ කෙසේදැයි සොයමින් මම මෙහි ආවෙමි mydict.values(). එක් යතුරක් ආපසු ලබා දෙනවා වෙනුවට, මම බලා සිටියේ ඉහළ x ය අගයන් ය.

මෙම විසඳුම max()ශ්‍රිතය භාවිතා කිරීමට වඩා සරල වන අතර ඔබට ආපසු ලබා දුන් අගයන් ගණන පහසුවෙන් වෙනස් කළ හැකිය:

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

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

ඔබට ඉහළම ශ්‍රේණිගත කිරීමේ යතුරක් අවශ්‍ය නම්, දර්ශකය භාවිතා කරන්න:

x[0]
['b']

ඔබට ඉහළම ශ්‍රේණිගත කිරීමේ යතුරු දෙක අවශ්‍ය නම්, ලැයිස්තු කැපීම භාවිතා කරන්න:

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

Question 14

තෝරාගත් පිළිතුරෙහි අදහස් දැක්වීම් හරහා නැවත සැකසූ විසඳුම් අනුව ...

පයිතන් 3 හි:

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

පයිතන් 2 හි:

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

Question 15

මෙම කිසිදු පිළිතුරකින් මා සෑහීමකට පත් නොවීය. maxසෑම විටම උපරිම අගය සහිත පළමු යතුර තෝරා ගනී. ශබ්දකෝෂයට එම අගය සහිත යතුරු කිහිපයක් තිබිය හැකිය.

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

යමෙකුට උදව් කිරීමට හැකි නම් මෙම පිළිතුර පළ කිරීම. පහත SO සටහන බලන්න

ටයි පටියකදී පයිතන් තෝරා ගන්නා උපරිමය කුමක්ද?

Question 16

සමග collections.Counterඔබට කළ හැකි

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

සුදුසු නම්, ඔබට හිස්ව ආරම්භ collections.Counterකර එයට එකතු කළ හැකිය

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

Question 17

ගොඩවල් පෝලිම් යනු සාමාන්‍යකරණය කළ විසඳුමක් වන අතර එමඟින් අගය අනුව ඇණවුම් කළ ඉහළ n යතුරු උකහා ගැනීමට ඔබට ඉඩ සලසයි :

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'

සටහන dict.__getitem__යනු සින්ටැක්ටික් සීනි මගින් හඳුන්වන ක්‍රමයයි dict[]. ඊට ප්‍රතිවිරුද්ධව dict.get, KeyErrorයතුරක් සොයාගත නොහැකි නම් එය නැවත පැමිණේ , මෙහි සිදුවිය නොහැක.

Question 18

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

Question 19

+1 සිට @ ඇරික් කෝඩිගේ සරලම විසඳුම.
අහඹු ලෙස එක් ක්‍රමයක් ශබ්ද කෝෂයේ උපරිම අගය සහිත යතුරු එකක් තෝරන්න:

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

Question 20

ප්‍රවේශය තේරුම් ගැනීමට වඩා සරල ය:

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

ප්‍රතිදානය: ['a', 'g']

දැන් ඔබට තෝරා ගත හැක්කේ එක් යතුරක් පමණි:

maximum = dict[max_value_keys[0]]

Question 21

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

Question 22

කොහොමද:

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

Question 23

මම පිළිගත් පිළිතුර පරීක්ෂා කළ අතර @ වුල්ෆ්ගේ මූලික විසඳුමට එරෙහිව වේගවත්ම විසඳුම ලබා දුන් අතර ලූපය දෙකටම වඩා වේගවත් විය:

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

ප්රතිපල:

Iterating: 3.8201940059661865
List creating: 6.928712844848633
Accepted answer: 5.464320182800293

Question 24

විද්‍යාත්මක පයිතන් භාවිතා කරන්නන් සඳහා, පැන්ඩාස් භාවිතා කරන සරල විසඳුමක් මෙන්න:

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

>>> b

Question 25

ඔබට එකම අගය සහිත යතුරකට වඩා තිබේ නම්, උදාහරණයක් ලෙස:

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

පහත දැක්වෙන පරිදි උපරිම අගය සහිත සියලුම යතුරු සමඟ එකතුවක් ඔබට ලබා ගත හැකිය:

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

Question 26

max(stats, key=stats.get) if stats else None

සංඛ්‍යාලේඛන හිස් ශබ්ද කෝෂයක් විය හැකි max(stats, key=stats.get)අතර එම තත්වය තුළ එය බිඳී යනු ඇත.