Используйте max () для поиска 3 самых высоких результатов в столбце [дубликат]

Если значения могут появляться в вашем списке повторно, вы можете попробовать это решение.

def search(Fscore_list, num=3):
    l = Fscore_list
    res = dict([(v, []) for v in sorted(set(l), reverse=True)[:num]])
    for index, val in enumerate(l):
        if val in res:
            res[val].append(index)
    return sorted(res.items(), key=lambda x: x[0], reverse=True)

Сначала он найдет самые высокие значения num=3 и создаст dict с пустым list для индексов для него. Затем он перейдет по списку и для каждого из самых высоких значений (val in res) сохранит его индексы. Затем просто верните отсортированный список кортежей, например [(highest_1, [indexes ...]), ..]. например,

>>> l = [9, 7, 43, 2, 4, 7, 43, 8, 5, 8, 4]
>>> print(search(l))
[(43, [2, 6]), (9, [0]), (8, [7, 9])]

Для печати позиций выполните следующее:

>>> Fscore_list = [9, 7, 43, 2, 4, 7, 43, 8, 5, 8, 4, 43, 43, 43]
>>> result = search(Fscore_list)
>>> print("1st. %d on positions %s" % (result[0][0], result[0][1]))
1st. 43 on positions [2, 6, 11, 12, 13]
>>> print("2nd. %d on positions %s" % (result[1][0], result[1][1]))
2nd. 9 on positions [0]
>>> print("3rd. %d on positions %s" % (result[2][0], result[2][1]))
3rd. 8 on positions [7, 9]

None всегда считается меньше любого числа.

>>> None<4
True
>>> None>4
False

Найти наивысший элемент и его индекс. Замените его на None. Найдите новый наивысший элемент и его индекс. Это будет второе место в первоначальном списке. Замените его на None. Найти новый наивысший элемент, который на самом деле является третьим.

Необязательно: восстановить найденные элементы в списке.

Это O (количество наивысших элементов * размер списка) поэтому он плохо масштабируется, если ваши «три» растут, но сейчас это O (3n).

Начните с сортировки списка в порядке убывания:

my_list = [1, 2, 8, 4, 7, 6, 5, 3]
sorted_list = sorted(my_list, reverse=True)
print(sorted_list)

Выход:

[8, 7, 6, 5, 4, 3, 2, 1]

Затем вы можете извлечь индекс из трех самых больших элементов (первые 3 элемента sorted_list) следующим образом:

index_of_highest = my_list.index(sorted_list[0])
index_of_second_highest = my_list.index(sorted_list[1])
index_of_third_highest = my_list.index(sorted_list[2])

Добавьте все значения в список в набор.

Найдите индекс из трех верхних значений в наборе в исходном списке.

]

Изменить

thelist = [1, 45, 88, 1, 45, 88, 5, 2, 103, 103, 7, 8]
theset = frozenset(thelist)
theset = sorted(theset, reverse=True)

print('1st = ' + str(theset[0]) + ' at ' + str(thelist.index(theset[0])))
print('2nd = ' + str(theset[1]) + ' at ' + str(thelist.index(theset[1])))
print('3rd = ' + str(theset[2]) + ' at ' + str(thelist.index(theset[2])))

Изменить

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

thelist = [1, 45, 88, 1, 45, 88, 5, 2, 103, 103, 7, 8]
theset = frozenset(thelist)
theset = sorted(theset, reverse=True)
thedict = {}
for j in range(3):
    positions = [i for i, x in enumerate(thelist) if x == theset[j]]
    thedict[theset[j]] = positions

print('1st = ' + str(theset[0]) + ' at ' + str(thedict.get(theset[0])))
print('2nd = ' + str(theset[1]) + ' at ' + str(thedict.get(theset[1])))
print('3rd = ' + str(theset[2]) + ' at ' + str(thedict.get(theset[2])))

Выход

1st = 103 at [8, 9]
2nd = 88 at [2, 5]
3rd = 45 at [1, 4]

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

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

Также обратите внимание, если аргумент ключевого слова (ordered_nums_to_return) больше длины списка, он вернет целое список в порядке убывания. если вам нужно, чтобы создать исключение, вы можете добавить проверку функции. Если аргументы не переданы, он вернет наивысшее значение, снова вы можете изменить это поведение, если вам нужно.

list_of_nums = [2, 4, 23, 7, 4, 1]


def find_highest_values(list_to_search, ordered_nums_to_return=None):
    if ordered_nums_to_return:
        return sorted(set(list_to_search), reverse=True)[0:ordered_nums_to_return]
    return [sorted(list_to_search, reverse=True)[0]]

print find_highest_values(list_of_nums, ordered_nums_to_return=4)

Используйте heapq.nlargest :

>>> import heapq
>>> [i
...     for x, i
...     in heapq.nlargest(
...         3,
...         ((x, i) for i, x in enumerate((0,5,8,7,2,4,3,9,1))))]
[7, 2, 3]

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

lst = [9,7,43,2,4,7,8,5,4]
print( sorted( [(x,i) for (i,x) in enumerate(lst)], reverse=True )[:3] )

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

lst = [9,7,43,2,4,7,8,5,4]
ranks = sorted( [(x,i) for (i,x) in enumerate(lst)], reverse=True )
values = []
posns = []
for x,i in ranks:
    if x not in values:
        values.append( x )
        posns.append( i )
        if len(values) == 3:
            break
print zip( values, posns )