Pythonic способ найти наивысшие значения (и индексы) в списке

Question

У меня есть список целых чисел, и я хочу найти максимальные и максимальные значения в списке и соответствующие им значения индексов.

У меня есть один метод, но я чувствую, что он слишком запутан!

lst = [10,6,17,99,3,1,-3,47, 99] 
max_value = (max(lst)) 
largest = 0.0 
largest_index = 0 
second_largest = 0.0 
second_largest_index = 0 
third_largest = 0 
third_largest_index = 0 
for (index,value) in enumerate (lst): 
     if value == largest_value: 
      if largest == 0.0: 
       largest = value 
       largest_index = index 
      elif largest != 0.0 and value > second_largest: 
       second_largest = value 
       second_largest_index= index 
      elif second_largest != 0.0 and value > third_largest: 
       third_largest = value 
       third_largest_index = index 
      elif third_largest != 0.0 and value > third_largest: 
       fourth_largest = value 
       fourth_largest_index = index 

     elif value > second_largest and value < largest_value: 
      second_largest = value 
      second_largest_index = index 
     elif value > third_largest and value < second_largest: 
      third_largest = value 
      third_largest_index = index 
     elif value > fourth_largest and value < third_largest: 
      fourth_largest = value 
      fourth_largest_index = index 
    indexlist = [largest_index, second_largest_index, third_largest_index, fourth_largest_index] 
return indexlist 

Поскольку список может содержать повторяющиеся значения (которые я хочу сохранить), это может быть, что четыре наибольших значений в конечном итоге «а, а, б, в». Поэтому я пытаюсь одновременно найти как максимальные значения, так и самые высокие значения второй/третьей/и т. Д.

Как я пытаюсь найти значения индекса, я не думаю, что сортировка списка поможет. Есть ли способ сохранить индекс исходного списка, чтобы он также менялся, если я сортирую список с самого высокого на самый низкий?

Редактирование для наглядности: Возможно, у меня есть [99,95, 50, 90,99] (множественные вхождения максимального значения) или [99, 70, 70, 90,50]. То, что я пытаюсь сделать, это найти самые высокие значения - потенциально, но не обязательно множественные вхождения максимального значения.

Answer 1

One (возможно, избыточного) раствора, но вполне чистым будет:

lst = [10, 6, 17, 99, 3, 1, -3, 47, 99] 
meta_lst = list(enumerate(lst)) 

, а затем сортировать по значению (который является вторым элементом)

from operators import itemgetter 
sorted_meta_lst = sorted(meta_lst, key=itemgetter(1)) 

вы будете иметь большую последовательность пара (индекс в списке, значение).

Answer 2

IIUC, вы хотите что-то вроде этого (очень быстро - не требует сортировки так работает в O(n)):

>>> lst = [10, 6, 17, 99, 3, 1, -3, 47, 99] # avoid using "list" 
>>> max_value = max(lst) # get max value 
>>> max_index = lst.index(max_value) # get its index 
>>> max_index, max_value 
(3, 99) 

И если вам нужен индекс все вхождений высокий значения:

>>> max_value = max(lst) 
>>> [i for i, j in enumerate(lst) if j == max_value] 
[3, 8] 

И в сочетании с их значениями:

>>> [(i,j) for (i, j) in enumerate(lst) if j == max_value] 
[(3, 99), (8, 99)] 

Answer 3

Создайте итерабельность кортежей значения и индекса (в этом порядке) и сортируйте их.Сортировка кортежей выполняется на первом элементе (и если они равны, на второй, и так далее):

sorted(((value, index) for index, value in enumerate(list_of_values)), reverse=True) 

В вашем примере, выход:

[(99, 8), (99, 3), (47, 7), (17, 2), (10, 0), (6, 1), (3, 4), (1, 5), (-3, 6)] 

Answer 4

A: создать новый список кортежи, которая хранит исходные показатели и значения

B: сортировать, что список от высокой к низкой

C: взять 4 наивысших элементы

D: использовать их

list_is_a_bad_name = [10,6,17,99,3,1,-3,47, 99] 
the_list_with_indexes = [(idx, i) for idx, i in enumerate(list_is_a_bad_name)] 
sorted_list = sorted(the_list_with_indexes, reverse=True, key=lambda i:i[1]) 

for i in sorted_list[:4]: 
    print("{} - {}".format(i[0], i[1])) 

Answer 5

Если вы просто хотите, чтобы найти наибольшее количество:

l = [10,6,17,99,3,1,-3,47, 99] 
max_id, max_no = max(enumerate(l), key=lambda x: x[1]) 

Для больших k чисел, вы можете использовать heapq модуль:

from heapq import nlargest 
l = [10,6,17,99,3,1,-3,47, 99] 
k = 3 
nmax = nlargest(k, enumerate(a), key=lambda x:x[1]) # returns list of (index, value) 

Answer 6

mylist = [10,6,17,99,3,1,-3,47, 99] 
maximum = max(mylist) 
print maximum, [i for i, j in enumerate(mylist) if j == maximum] 

99 [3, 8] 

работа в питоне 2,7

или

import heapq 
print heapq.nlargest(len(mylist), enumerate(mylist), key=lambda x: x[1]) 
[(3, 99), (8, 99), (7, 47), (2, 17), (0, 10), (1, 6), (4, 3), (5, 1), (6, -3)] 

работает также в питоне 2,7

Answer 7

Вы можете сделать это следующим образом: создать кортеж пара значений индексного, сортировать кортеж, используя значения, и выберите n-ые первые (или последние) значения:

mylist = [10,6,17,99,3,1,-3,47, 99] 
tup = zip(mylist, range(len(mylist))) 
sorted_list = sorted(tup, key=lambda v: v[0], reverse=True) 
print sorted_list[:4] # [(99, 3), (99, 8), (47, 7), (17, 2)] 

Answer 8

собирать индексы, как вы идете через lsit:

lst = [10,6,17,99,3,1,-3,47, 99] 
best = lst[0] 
idxlst = [0] 
for k,v in enumerate(lst[1:]): 
    if (v > best): 
     best = v 
     idxlst = [k+1] 
    elif (v == best): 
     idxlst.append(k+1)