Question

我知道如何找到第一个最高价值，但不知道其余的。请记住，我需要打印第一个第二和第三个最高值的位置。谢谢你，并试着保持简单，因为我只编码了2个月。他们也可以是联合排名

def linearSearch(Fscore_list):
    pos_list = []
    target = (max(Fscore_list))
    for i in range(len(Fscore_list)):
        if Fscore_list[i] >= target:
            pos_list.append(i)


        return pos_list

Answer 1

这将打印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 )

Answer 2

使用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]

Answer 3

将列表中的所有值添加到集合中。这将确保您只有一次值。

对集合进行排序。

找到原始列表中集合中前三个值的索引。

有意义吗？

编辑

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

修改

你仍然没有告诉我们如何处理联合赢家＆＃39;但是看看你对其他答案的回答我猜这可能是你想要做的，也许吧？如果这不是您想要的输出，请给我们一个您希望获得的输出示例。

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]

顺便说一句：如果所有的值都相同（首先等于），或者由于某些其他原因没有第三名，该怎么办？（或第二名？）。你需要保护吗？如果您这样做，我确定您可以制定适当的安全防护罩以添加到代码中。

Answer 4

Jupyter image of the code working 这个问题在我的Udemy机器学习课程中还为时过早。斯科特·亨特（Scott Hunter）在这个问题上为我提供了最大的帮助，但并未使我在该站点上获得成功。我必须自己更深入地思考问题。这是我的解决方案，因为在网上找不到其他地方-就我所了解的一切而言*：

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

因此，我们有一个数字列表。为了对数字进行排名，我们在枚举/迭代列表时对具有值的每个位置按其位置对值进行排序。然后，我们通过反转最高值。现在，我们需要一个盒子来放入我们的信息以供以后使用，因此我们构建了该盒子[]。现在，对于每个具有位置的值，将其放在框中，如果该值和位置尚未在框中，则意味着该值已在框中，但位置未在框中。我们只想要三个答案。最后告诉我变量box中的内容。 *这篇文章中的许多答案很可能会起作用。

Answer 5

如果值重复显示在列表中，您可以尝试此解决方案。

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 ...]), ..]这样的元组的排序列表。 e.g。

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

Answer 6

有一个复杂的O（n）算法，但最简单的方法是对它进行排序，即O（n * log n），然后取顶部。这里最棘手的部分是在保留索引信息的同时对数据进行排序。

from operator import itemgetter

def find_top_n_indices(data, top=3):
    indexed = enumerate(data)  # create pairs [(0, v1), (1, v2)...]
    sorted_data = sorted(indexed, 
                         key=itemgetter(1),   # sort pairs by value 
                         reversed=True)       # in reversed order
    return [d[0] for d in sorted_data[:top]]  # take first N indices

data = [5, 3, 6, 3, 7, 8, 2, 7, 9, 1]
print find_top_n_indices(data)  # should be [8, 5, 4]

同样，它可以使用heapq.nlargest()完成，但您仍然需要将初始数据打包到元组中并在之后解压缩。

Answer 7

要过滤列表并按降序返回并删除重复项，请尝试使用此函数。您可以传递希望它作为关键字参数返回的降序值。

另外注意，如果关键字参数（ordered_nums_to_return）大于列表的长度，它将按降序返回整个列表。如果需要它来引发异常，可以在函数中添加一个检查。如果没有传递args，它将返回最高值，如果需要，您可以再次更改此行为。

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)

Answer 8

Input : [4, 5, 1, 2, 9] 
        N = 2
Output :  [9, 5]

Input : [81, 52, 45, 10, 3, 2, 96] 
        N = 3
Output : [81, 96, 52]

# Python program to find N largest 
# element from given list of integers 
  
l = [1000,298,3579,100,200,-45,900] 
n = 4
  
l.sort() 
print(l[-n:])

输出：

[298, 900, 1000, 3579]

Answer 9

lst = [9,7,43,2,4,7,8,9,4]

temp1 = lst 
print(temp1)
    
#First Highest value: 
print(max(temp1))
temp1.remove(max(temp1))

#output: 43

# Second Highest value:
print(max(temp1))
temp1.remove(max(temp1))

#output: 9
    
        
# Third Highest Value:
print(max(temp1))

#output: 7

Answer 10

首先将列表按降序排序：

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]

然后，您可以提取三个最大元素的索引（sorted_list的前3个元素），如下所示：

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

Answer 11

None始终被视为小于任何数字。

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

找到最高元素及其索引。将其替换为None。找到新的最高元素及其索引。这将是原始列表中的第二高。将其替换为None。找到新的最高元素，实际上是第三个元素。

可选：将找到的元素恢复到列表中。

这是O（最高元素数量*列表大小），因此如果你的“三个”增长它会缩小，但现在它是O（3n）。

如何在Python中查找列表中的第1，第2，第3最高值

11 个答案: