在列表中找到最大值及其索引的Pythonic方式？

Question

如果我想找出一个列表中的最大值，我可以写max(List)，但如果我还需要最大值所在的索引呢？

我可以写类似于以下的代码：

maximum=0
for i,value in enumerate(List):
    if value>maximum:
        maximum=value
        index=i

但是这对我来说看起来很繁琐。

如果我写：

List.index(max(List))

然后它会两次迭代列表。

有更好的方法吗？

- Sunny88

---

“它会通过列表两次”是什么意思？List.index(max(List)) 对我有用。 - mwcz

它将迭代列表一次以确定最大值，然后再迭代一次以找到该值的索引。 - user395760

如果存在重复的最大值，使用list.index()不会出现问题吗？ - Logan Yang

@LoganYang 是的，可能会有两个具有相同值的项。 - Flo

如果顺序不重要，你可以像这样做：List.sort()[-1] - Flo

Answer 1

我认为被接受的答案很好，但为什么不明确地这样做呢？我觉得更多人会理解你的代码，这也符合PEP 8的规定：

max_value = max(my_list)
max_index = my_list.index(max_value)

这种方法的速度比被接受的答案快三倍：

import random
from datetime import datetime
import operator

def explicit(l):
    max_val = max(l)
    max_idx = l.index(max_val)
    return max_idx, max_val

def implicit(l):
    max_idx, max_val = max(enumerate(l), key=operator.itemgetter(1))
    return max_idx, max_val

if __name__ == "__main__":
    from timeit import Timer
    t = Timer("explicit(l)", "from __main__ import explicit, implicit; "
          "import random; import operator;"
          "l = [random.random() for _ in xrange(100)]")
    print "Explicit: %.2f usec/pass" % (1000000 * t.timeit(number=100000)/100000)

    t = Timer("implicit(l)", "from __main__ import explicit, implicit; "
          "import random; import operator;"
          "l = [random.random() for _ in xrange(100)]")
    print "Implicit: %.2f usec/pass" % (1000000 * t.timeit(number=100000)/100000)

在我的电脑上运行的结果：

Explicit: 8.07 usec/pass
Implicit: 22.86 usec/pass

其他设置：

Explicit: 6.80 usec/pass
Implicit: 19.01 usec/pass

- Escualo

---

没想到它跑得更快了。即使我把“l”替换为“l = [random.random() for _ in xrange(10000000)]+[2]”，确保最后一个元素是最大的，速度还是更快了。 - Sunny88

对于一个简单的数字列表，简单方法更快。如果你追求性能，在这种情况下我建议使用numpy.argmax()，在我的机器上它快了另外30倍。如果列表包含比纯数字更复杂的对象，则我回答中的方法可能会更快。那个方法的另一个优点是它可以用于任意迭代器，而不仅仅是列表。 - Sven Marnach

@Sven-Marnach 如果我必须先将列表转换为numpy数组，那么numpy会更快吗？对于简单的示例[0,1,0]，它会更快吗？ - tommy.carstensen

@Sven-Marnach 我刚刚检查了一下。numpy.argmax是迄今为止最慢的方法，如果数组包含字符串而不是浮点数或整数，则会给出错误的答案。 - tommy.carstensen

如果存在重复的最大值，使用list.index()会有问题吗？ - Logan Yang

@LoganYang 我不这么认为，当存在多个最大值时，max()仅返回第一个（对于Python 3保证如此），list.index()同样返回第一个。 - Chris_Rands

Answer 2

有很多选择，例如：

import operator
index, value = max(enumerate(my_list), key=operator.itemgetter(1))

- Sven Marnach

---

哦，我在其他地方见过这个，但我以为它只会返回一个值，而不是一个元组。 - Sunny88

@Sunny88：key函数仅用于决定哪个元素是最大的，元素本身不会改变。 - Sven Marnach

为何不使用 key=lambda e: e[1]，从而避免导入模块呢？ - lifebalance

使用itemgetter()更快，并且避免导入模块并不值得追求。在某些情况下，避免外部依赖可能是值得的，但从标准库导入模块并不成问题。 - Sven Marnach

Answer 3

假设列表非常大，且已经是np.array()类型，这个答案比@Escualo快33倍。我不得不降低测试次数，因为该测试涉及10000000个元素而不仅仅是100个。

import random
from datetime import datetime
import operator
import numpy as np

def explicit(l):
    max_val = max(l)
    max_idx = l.index(max_val)
    return max_idx, max_val

def implicit(l):
    max_idx, max_val = max(enumerate(l), key=operator.itemgetter(1))
    return max_idx, max_val

def npmax(l):
    max_idx = np.argmax(l)
    max_val = l[max_idx]
    return (max_idx, max_val)

if __name__ == "__main__":
    from timeit import Timer

t = Timer("npmax(l)", "from __main__ import explicit, implicit, npmax; "
      "import random; import operator; import numpy as np;"
      "l = np.array([random.random() for _ in xrange(10000000)])")
print "Npmax: %.2f msec/pass" % (1000  * t.timeit(number=10)/10 )

t = Timer("explicit(l)", "from __main__ import explicit, implicit; "
      "import random; import operator;"
      "l = [random.random() for _ in xrange(10000000)]")
print "Explicit: %.2f msec/pass" % (1000  * t.timeit(number=10)/10 )

t = Timer("implicit(l)", "from __main__ import explicit, implicit; "
      "import random; import operator;"
      "l = [random.random() for _ in xrange(10000000)]")
print "Implicit: %.2f msec/pass" % (1000  * t.timeit(number=10)/10 )

我的电脑上的结果：

Npmax: 8.78 msec/pass
Explicit: 290.01 msec/pass
Implicit: 790.27 msec/pass

- benathon

---

只是想澄清一下：速度提升仅仅是因为numpy C实现与纯Python的区别吗？还是有一种使用纯Python可以改进@Escualo答案的方法？ - max

如果想要使用Python 3.6，可以这样做：l = np.array([random.random() for _ in range(10000000)]) print(f"Npmax: {(1000 * t.timeit(number=10)/10):5.2f} msec/pass") - Piotr Siejda

这是在2.7上的。 - benathon

好的，numpy.argmax 的速度看起来很惊人，直到你让它处理一个标准的Python列表。然后速度介于显式和隐式版本之间。我猜测 np.array 不仅仅创建了一个列表，而是在其中保存了一些额外的信息 - 比如最小值和最大值（这只是一个假设）。 - Miroslaw Opoka

@MiroslawOpoka 我尝试简要检查了源代码，没有发现任何“预计算聚合”的内容（虽然我不太确定，因为代码并不简单，许多更通用的存储系统如数据库/存储格式确实记录了最小值/最大值的聚合信息）。但仅凭NumPy的内存布局以及C编译就已经可以对速度产生巨大影响。 - Joseph Stack

Answer 4

使用Python的内置库非常容易：

a = [2, 9, -10, 5, 18, 9] 
max(xrange(len(a)), key = lambda x: a[x])

这告诉max在列表[0, 1, 2, ..., len(a)]中查找最大的数字，使用自定义函数lambda x: a[x]。该函数表示0实际上是2，1实际上是9，以此类推。

- Sunil Kapil

---

在Python 3中，没有xrange，如果你想编写能够在Python 2和Python 3上运行的代码，应该使用range()。 - Chunde Huang

Answer 5

我建议一种非常简单的方法：

import numpy as np
l = [10, 22, 8, 8, 11]
print(np.argmax(l))
print(np.argmin(l))

希望有所帮助。

- Igor Manzhos

Answer 6

这将my_list转换为元组（v，i）的列表，其中v是我的列表中的每个项，i是对应的索引，然后获取具有最大值的元组以及其关联的索引：

max([(v,i) for i,v in enumerate(my_list)])

- Luis Sobrecueva

---

这样更好，因为您可以将其适应于除元组以外的其他内容。 - wieczorek1990

这个到底是怎么工作的？你能把过程分解一下吗？ - clabe45

嗨@clabe45，它将my_list转换为元组列表（v，i），其中v是my_list的每个项目，i是相应的索引，然后获取具有最大值的元组（以及其关联的索引）。 - Luis Sobrecueva

谢谢，你希望我在回答中发布吗？max函数是如何知道在计算最大值时只考虑每个元组(v)的第一个项目的？可以，max函数通过默认比较每个元组的第一个项目来确定最大值。这是因为在Python中，元组是按照其成员的顺序进行排序和比较的，并且在比较两个元组时，Python会首先比较它们的第一个项，如果它们相等，则继续比较下一个项目，直到找到不同的项目为止。因此，在使用max函数查找最大值时，默认情况下只考虑元组的第一个项目。 - clabe45

@clabe45 可能这个回复有点晚了，但对于其他像我一样现在才看到这个帖子的人，在这里：https://dev59.com/LmMl5IYBdhLWcg3wkXtx 有一个解释。不是这一行：“默认情况下，max将通过第一个索引比较项目，如果第一个索引相同，则会比较第二个索引。”所以我尝试用列表：l=[1,1,1]，然后max([(v,i) for i,v in enumerate(l)])，它给我返回的不是第一个1而是最后一个：(1,2)。希望这能解释清楚 :) - Anupam Jain

Answer 7

max([(value,index) for index,value in enumerate(your_list)]) #if maximum value is present more than once in your list then this will return index of the last occurrence

如果当前存在多个最大值并且您想获取所有索引，请使用以下代码：

max_value = max(your_list)
maxIndexList = [index for index,value in enumerate(your_list) if value==max(your_list)]

- Taohidul Islam

---

是的。我差点发布了一个答案，但后来我看到你已经用相同的逻辑在你的列表推导式一行代码中解决了。 - WalyKu

Answer 8

也许您需要一个排序后的列表呢？

试试这个：

your_list = [13, 352, 2553, 0.5, 89, 0.4]
sorted_list = sorted(your_list)
index_of_higher_value = your_list.index(sorted_list[-1])

- Mattias

---

1. 排序具有更高的时间复杂度。
2. sorted_list 没有索引，只有值，因此它无法工作。

- user1134316

Answer 9

列表推导式方法：

假设您有一个列表List = [5,2,3,8]

那么[i for i in range(len(List)) if List[i] == max(List)]将是一种Pythonic的列表推导式方法，用于查找值为“i”的位置，其中List[i] == max(List)。

对于由列表组成的数组，它可以轻松扩展，只需进行一个for循环即可。

例如，使用任意列表的列表"array"并将"index"初始化为空列表。

array = [[5, 0, 1, 1], 
[1, 0, 1, 5], 
[0, 1, 6, 0], 
[0, 4, 3, 0], 
[5, 2, 0, 0], 
[5, 0, 1, 1], 
[0, 6, 0, 1], 
[0, 1, 0, 6]]
index = []

for List in array:
    index.append([i for i in range(len(List)) if List[i] == max(List)])
index

输出：[[0], [3], [2], [1], [0], [0], [1], [3]]

- ebehr

Answer 10

我创建了一些大列表。其中一个是列表，另一个是numpy数组。

import numpy as np
import random
arrayv=np.random.randint(0,10,(100000000,1))
listv=[]
for i in range(0,100000000):
    listv.append(random.randint(0,9))

使用Jupyter Notebook的%%time函数，我可以比较各种操作的速度。

2秒：

%%time
listv.index(max(listv))

54.6 秒：

%%time
listv.index(max(arrayv))

6.71秒：

%%time
np.argmax(listv)

103毫秒：

%%time
np.argmax(arrayv)

NumPy的数组速度非常快。

- AndrewGraham