Получение ключа с максимальным значением в словаре?


868

У меня есть dictionary: ключи являются строки, значения являются целыми числами.

Пример:

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

Я бы хотел получить 'b'ответ, так как это ключ с более высоким значением.

Я сделал следующее, используя промежуточный список с обратными кортежами ключ-значение:

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

Это лучший (или даже более элегантный) подход?


1
Хм, а что не так max(stats)?
Джон Ред

13
max(stats)будет использовать метки в качестве ключей (он вернет 'c', учитывая, что это максимальная метка), max(stats, key=lambda key: stats[key])то , что было после OP (которое вернет 'b'метку максимального индексированного значения). Это понятнее?
Atcold

Ответы:


609

Вы можете использовать operator.itemgetterдля этого:

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

И вместо построения нового списка в памяти используйте stats.iteritems(). keyПараметр в max()функции является функция , которая вычисляет ключ , который используется для определения того, как ранг элементов.

Обратите внимание, что если бы у вас была другая пара ключ-значение 'd': 3000, этот метод вернет только один из двух, даже если они оба имеют максимальное значение.

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

242
Еще чище, я думаю =max(stats.iterkeys(), key=(lambda key: stats[key]))
Лукретиэль

18
Почему бы просто не использовать key=lambda x: x[1]?
BenDundee

43
в python 3 @ (правильно написанное) решение Lucretiel терпит неудачу. это должно быть: max (stats.keys (), key = (lambda k: stats [k])), поскольку keys () теперь выполняет то, что iterkeys () делал автоматически.
Уотсоник

74
Rigth вы. Интересно, что решение, которое точно так же эффективно использует память и работает как в Python 2, так и в 3:max(stats, key=lambda key: stats[key])
Lucretiel

3
Честно говоря, я думаю, что комментарии имеют более чистое и лучшее решение.
Аугусто Гонсалес

1180
max(stats, key=stats.get)

17
если бы вы действительно хотели сделать это так, как могли быstats[max(stats, key=stats.get)]
CrackSmoker9000 25.02.15

81
@scottmrogowski, сс. Это обеспечивает ключ с максимальным значением, как и просили. Максимальное значение будет просто max (stats.values ​​()).
А. Коади

25
Это должен быть ответ, так как он самый простой и был именно тем, о котором просил ФП.
ihatecache

4
@ Что делать, если между двумя ключами есть связь (с одинаковым значением)? Я хочу получить их обоих, но я получаю только один.
oba2311

10
@ oba2311max_value = max(stats.values()); {key for key, value in stats.items() if value == max_value}
A. Coady,

208

Я протестировал МНОЖЕСТВО вариантов, и это самый быстрый способ вернуть ключ dict с максимальным значением:

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}

И результаты теста под 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%     --

И под 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%     -- 

Вы можете видеть, что f1это самый быстрый под Python 3.2 и 2.7 (или, более полно, keywithmaxvalв верхней части этого поста)


12
Это кажется подозрительным. f7это как f1, просто не давая имя промежуточному объекту. f7должно быть (очень немного) быстрее f1, не намного медленнее. И вот что я получаю:>>> 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
Восстановить Монику

1
согласен, f1 похож на f7. Тестировал с ipython% timeit, и оба показали одинаковую производительность на моей машине на python 2.7. Тестирование: f1 - 18 мкс на цикл Тестирование: f2 - 33,7 мкс на цикл Тестирование: f3b - 50 мкс на цикл Тестирование: f4b - 30,7 мкс на цикл Тестирование: f5 - 28 мкс на цикл Тестирование: f6 - 23 мкс на цикл Тестирование: f7 - 18 мкс на тестирование контура: f8 - 43,9 мкс в петле тестирования: f4 - 2,16 мс в петле Тестирование: f3 - 2,29 мс в цикле
Джуп

f1 также применимо там, где max (d, клавиша) недоступно.
Никос Александрис

5
Я думал, что dict не отсортирован, нельзя ли теоретически упорядочить значения d.keys и d.values?
Dimath

1
Решения для копирования списков воняют для меня. Как продвигается на диктовке с тысячами или миллионами записей?
Лукретиэль

63

Если вам нужно знать только ключ с максимальным значением, вы можете сделать это без iterkeysили iteritemsпотому, что перебор словаря в Python - это перебор его ключей.

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

РЕДАКТИРОВАТЬ:

Из комментариев @ user1274878:

Я новичок в Python. Можете ли вы объяснить свой ответ в пошаговом режиме?

Ага...

Максимум

max (повторяемый [, ключ])

max (arg1, arg2, * args [, ключ])

Вернуть самый большой элемент в итерируемом или самый большой из двух или более аргументов.

Необязательный keyаргумент описывает, как сравнивать элементы, чтобы получить максимум среди них:

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

Возвращенные значения будут сравниваться.

Dict

Python dict - это хеш-таблица. Ключ dict - это хеш объекта, объявленного как ключ. Из-за соображений производительности итерация, хотя dict реализована как итерация по ключам.

Поэтому мы можем использовать его для избавления от операции получения списка ключей.

закрытие

Функция, определенная внутри другой функции, называется вложенной функцией. Вложенные функции могут получать доступ к переменным окружения.

statsПеременная доступна через __closure__атрибут lambdaфункции как указатель на значение переменного , определенных в родительской области.


1
@ I159: я новичок в питоне. Можете ли вы объяснить свой ответ пошагово
user1274878

57

Пример:

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

если вы хотите найти максимальное значение с помощью его ключа, возможно, последующие могут быть простыми, без каких-либо соответствующих функций.

max(stats, key=stats.get)

выход - это ключ, который имеет максимальное значение.


это решение тестировалось быстрее, чем max (статистика, ключ = лямбда-ключ: статистика [ключ])
Ta946

46

Вот еще один:

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

Функция keyпросто возвращает значение, которое следует использовать для ранжирования, и сразу же max()возвращает требуемый элемент.


10
.iterkeys не нужен в вашем ответе (он используется по умолчанию при итерации dict). Однако обратите внимание, что метод .iteritems извлекает и ключ, и значение за один шаг, поэтому нет необходимости в дополнительном getitem на ключ по мере необходимости с .iterkeys.
tzot

Это отличный ответ, потому что очень ясно, что происходит, и поэтому его легко распространить на другие ситуации.
Леопд

в Python3 версии:max(stats, key=lambda k: stats[k])
HeyJude

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

Если вас не волнует ценность (я бы удивился, но), вы можете сделать:

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

Мне нравится распаковка кортежей лучше, чем индекс [0] в конце выражения. Мне никогда не нравилась читаемость лямбда-выражений, но я нашел это лучше, чем operator.itemgetter (1) IMHO.


9
_может быть использован вместо ignored.
JFS

1
@JFSebastian Я согласен, ignoredвыглядит довольно некрасиво, но некоторые люди против использования _по нескольким причинам. Я думаю, что первый фрагмент в порядке, даже если вы игнорируете значение
jamylak

30

Учитывая, что более одной записи могут иметь максимальное значение. Я бы сделал список ключей, которые имеют максимальное значение в качестве значения.

>>> 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' и любой другой ключ макс.

Примечание: для Python 3 используйте stats.items()вместоstats.iteritems()


9
Ваше решение в порядке, но вычисляет максимальное значение столько раз, сколько есть элементов в dict. Если бы вычисления maxбыли дорогими (например, LONG-словарь), я бы порекомендовал, [key for m in [max(stats.values())] for key,val in stats.iteritems() if val == m]если вы хотите использовать одну строку, в противном случае вычисляйте m = ...заранее.
gboffi

4
Короткое замечание: для python 3 используйте stats.items () вместо stats.iteritems ().
Суза

21

Ты можешь использовать:

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

7
Это должен быть принятый ответ, он намного проще, чем использование оператора
Sigmatics

19

Чтобы получить максимальный ключ / значение словаря 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)

Конечно, если вы хотите получить только ключ или значение из результата, вы можете использовать индексирование кортежей. Например, чтобы получить ключ, соответствующий максимальному значению:

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

объяснение

Словарь метод items()в Python 3 возвращает объект представления словаря. Когда этот объект просмотра перебирается maxфункцией, он возвращает элементы словаря в виде кортежей формы (key, value).

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

Когда вы используете lambdaвыражение lambda x: x[1], в каждой итерации, x является одним из этих кортежей (key, value). Таким образом, выбирая правильный индекс, вы выбираете, хотите ли вы сравнить по ключам или по значениям.

Python 2

Для выпусков Python 2.2+ будет работать тот же код. Однако лучше использовать iteritems()словарный метод, а не items()для производительности.

Ноты

  • Этот ответ основан на комментариях к ответу Climbs_lika_Spyder .

  • Использованный код был протестирован на Python 3.5.2 и Python 2.7.10.



10

По повторным решениям через комментарии в выбранном ответе ...

В Python 3:

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

В Python 2:

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

Ваше решение для Python 3 также работает для Python 2.7.
patapouf_ai

4
поскольку keys () не возвращает итератор в python 2 и, следовательно,
снижает

10

Я попал сюда в поисках того, как вернуть mydict.keys()на основе стоимости mydict.values(). Вместо того , чтобы только один ключ вернулся, я искал , чтобы вернуть верхние й число значений.

Это решение проще, чем использование 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']

Это очень неэффективное решение. Сортировка dict повлечет за собой время выполнения n log (n), потому что вы относитесь к себе с кучей значений, которые не являются максимальными. Использование функции max приведет к времени выполнения всего n, что намного быстрее.
Питер Грэм

1
@PeterGraham в значительной степени каждое решение здесь (включая принятый ответ) использует max(). Понятно, что это самый быстрый. Я думал, что предложу другое решение с преимуществом нарезки, которое было более полезным для меня в то время
donrondadon

8

Я не был удовлетворен ни одним из этих ответов. maxвсегда выбирает первый ключ с максимальным значением. Словарь может иметь несколько ключей с этим значением.

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

Отправка этого ответа на случай, если он кому-то поможет. Смотрите ниже ТАК сообщение

Какой максимум выбирает Python в случае ничьей?


7

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

5

Очередь кучи - это обобщенное решение, которое позволяет вам извлечь верхние 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если ключ не найден, чего здесь не может быть.


4

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


1
Это будет порядок по ключу с повторяющимися максимальными значениями. Это может или не может быть желательным.
Роб Роуз

2

+1 к простейшему решению @Aric Coady .
А также один из способов случайного выбора одного из ключей с максимальным значением в словаре:

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


1

Как насчет:

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

3
zip(stats.keys(), stats.values())это просто более длинный способ написать stats.items(). Как только вы сделаете это изменение, ваш ответ будет практически идентичен нескольким более старым ответам.
прятки

Согласен, я не знал, что items () такая же, как zip
user2399453

itemsне то же самое, что zip. Это просто дает тот же результат.
Пол Руни

0

Я проверил принятый ответ и самое быстрое решение AND @ thewolf с очень простым циклом, и цикл был быстрее, чем оба:

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

0

Для научных пользователей Python вот простое решение с использованием Pandas:

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

>>> b

0

В случае если у вас есть несколько ключей с одинаковым значением, например:

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

0

Намного проще понять подход:

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]]
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.