使用列表上的 max()/min() 获取返回的最大或最小项的索引

Question

我正在使用Python的 max 和 min 极小极大算法的列表上的函数，我需要返回值的索引 max() 或者 min(). 。换句话说，我需要知道哪个动作产生了最大（在第一个玩家的回合）或最小（第二个玩家）值。

for i in range(9):
    newBoard = currentBoard.newBoardWithMove([i / 3, i % 3], player)

    if newBoard:
        temp = minMax(newBoard, depth + 1, not isMinLevel)  
        values.append(temp)

if isMinLevel:
    return min(values)
else:
    return max(values)

我需要能够返回最小值或最大值的实际索引，而不仅仅是值。

Answer 1

if isMinLevel:
    return values.index(min(values))
else:
    return values.index(max(values))

Answer 2

假设你有一个清单 values = [3,6,1,5], ，并且需要最小元素的索引，即 index_min = 2 在这种情况下。

避免解决方案 itemgetter() 其他答案中提出，并使用

index_min = min(xrange(len(values)), key=values.__getitem__)

因为它不需要 import operator 也不使用 enumerate, ，并且它总是比使用的解决方案更快（下面的基准） itemgetter().

如果您正在处理 numpy 数组或者负担得起 numpy 作为依赖项，还可以考虑使用

import numpy as np
index_min = np.argmin(values)

即使您将其应用于纯 Python 列表，如果满足以下条件，这也会比第一个解决方案更快：

• 它比几个元素大（在我的机器上大约 2**4 个元素）
• 您可以负担从纯列表到 numpy 大批

正如该基准测试所指出的：

我已经使用 python 2.7 在我的机器上针对上述两个解决方案运行了基准测试（蓝色：纯Python，第一个解决方案）（红色，numpy解决方案）以及基于的标准解决方案 itemgetter() （黑色，参考溶液）。与 python 3.5 相同的基准测试表明，这些方法与上面介绍的 python 2.7 情况完全相同

Answer 3

您可以找到在同一时间的最小/最大指标和价值，如果你枚举列表中的项目，但在列表的原始值执行最小/最大。像这样：

import operator
min_index, min_value = min(enumerate(values), key=operator.itemgetter(1))
max_index, max_value = max(enumerate(values), key=operator.itemgetter(1))

此方式列表将只为分钟（或最大）。一旦遍历

Answer 4

如果你想找到最大的号码列表中的索引（这似乎是你的情况下），那么我建议你使用numpy的：

import numpy as np
ind = np.argmax(mylist)

Answer 5

可能是一个简单的解决方案将是把值的阵列分成的值，指数对的数组，并采取最大/的那分钟。这将使具有最大/最小最大/最小索引（即对由第一比较第一元件，然后比较所述第二元件如果第一那些是相同的比较）。需要注意的是，没有必要实际创建阵列，因为最小/最大允许发电机作为输入。

values = [3,4,5]
(m,i) = max((v,i) for i,v in enumerate(values))
print (m,i) #(5, 2)

Answer 6

list=[1.1412, 4.3453, 5.8709, 0.1314]
list.index(min(list))

会给你最小的第一索引。

Answer 7

我也有兴趣在此和比较一些使用 perfplot （宠物的项目的建议的解决方案的矿）。

原来， numpy的的argmin ，

numpy.argmin(x)

是足够大的列表最快方法中，即使从输入list到numpy.array的隐式转换。

---

代码，用于生成剧情：

import numpy
import operator
import perfplot


def min_enumerate(a):
    return min(enumerate(a), key=lambda x: x[1])[0]


def min_enumerate_itemgetter(a):
    min_index, min_value = min(enumerate(a), key=operator.itemgetter(1))
    return min_index


def getitem(a):
    return min(range(len(a)), key=a.__getitem__)


def np_argmin(a):
    return numpy.argmin(a)


perfplot.show(
    setup=lambda n: numpy.random.rand(n).tolist(),
    kernels=[
        min_enumerate,
        min_enumerate_itemgetter,
        getitem,
        np_argmin,
        ],
    n_range=[2**k for k in range(15)],
    logx=True,
    logy=True,
    )

Answer 8

使用一个numpy的阵列和argmax（）函数

 a=np.array([1,2,3])
 b=np.argmax(a)
 print(b) #2

Answer 9

在你得到最大的价值，试试这个：

max_val = max(list)
index_max = list.index(max_val)

比很多的选择更加简单。

Answer 10

我觉得做的最好的事情是列表转换为numpy array，利用此功能：

a = np.array(list)
idx = np.argmax(a)

Answer 11

我觉得上面的答案解决您的问题，但我想我会分享，让你的最小值和所有指数最低出现在的方法。

minval = min(mylist)
ind = [i for i, v in enumerate(mylist) if v == minval]

这经过两次名单，但仍是相当快的。然而，它是比找到的最小的第一次遇到的索引稍微慢一些。所以，如果你只需要极小的一个，使用马特·安德森的的解决方案，如果你需要他们所有的，使用此。

Answer 12

使用numpy的模块的功能numpy.where

import numpy as n
x = n.array((3,3,4,7,4,56,65,1))

有关最小值的索引：

idx = n.where(x==x.min())[0]

有关最大值的指数：

idx = n.where(x==x.max())[0]

在事实上，该功能更强大。你可以提出各种布尔运算 为3和60之间的值指数：

idx = n.where((x>3)&(x<60))[0]
idx
array([2, 3, 4, 5])
x[idx]
array([ 4,  7,  4, 56])

Answer 13

此使用内置在enumerate()和max()功能和key功能的可选max()参数和一个简单的lambda表达式仅仅是可能的：

theList = [1, 5, 10]
maxIndex, maxValue = max(enumerate(theList), key=lambda v: v[1])
# => (2, 10)

在该文档为 max() 它说，key参数预计函数与 list.sort() 功能。还请参阅排序如何的。

它适用于min()相同。顺便说一句，它返回第一最大/最小值。

Answer 14

只要你知道如何使用Lambda和“关键”的说法，一个简单的解决方案是：

max_index = max( range( len(my_list) ), key = lambda index : my_list[ index ] )

Answer 15

假设你有一个列表，诸如：

a = [9,8,7]

在以下两种方法是相当紧凑的方式来获得具有最小元素及其索引的元组。两者取一的类似的时间来处理。我喜欢的zip方法更好，但是这是我的口味。

拉链方法

element, index = min(list(zip(a, range(len(a)))))

min(list(zip(a, range(len(a)))))
(7, 2)

timeit min(list(zip(a, range(len(a)))))
1.36 µs ± 107 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

枚举方法

index, element = min(list(enumerate(a)), key=lambda x:x[1])

min(list(enumerate(a)), key=lambda x:x[1])
(2, 7)

timeit min(list(enumerate(a)), key=lambda x:x[1])
1.45 µs ± 78.1 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

Answer 16

何必先添加索引然后反转它们？枚举（）函数是ZIP（）函数用法的一个特例。让我们用它在appropiate方式：

my_indexed_list = zip(my_list, range(len(my_list)))

min_value, min_index = min(my_indexed_list)
max_value, max_index = max(my_indexed_list)

Answer 17

只是一个小除了已经取得的说。 values.index(min(values))似乎返回分钟的最小索引。以下得到最大指数：

    values.reverse()
    (values.index(min(values)) + len(values) - 1) % len(values)
    values.reverse()

最后一行可以被省略，如果在适当位置反转的副作用并不重要。

要通过所有出现迭代

    indices = []
    i = -1
    for _ in range(values.count(min(values))):
      i = values[i + 1:].index(min(values)) + i + 1
      indices.append(i)

有关简洁起见。这可能是一个更好的主意来缓存外循环min(values), values.count(min)。

Answer 18

在列表中找到与最小值的指标的简单方法，如果你不希望导入额外的模块：

min_value = min(values)
indexes_with_min_value = [i for i in range(0,len(values)) if values[i] == min_value]

然后，例如，选择第一个：

choosen = indexes_with_min_value[0]

Answer 19

这么简单：

stuff = [2, 4, 8, 15, 11]

index = stuff.index(max(stuff))

Answer 20

没有足够的高代表在现有的答案进行评论。

但是，对于 https://stackoverflow.com/a/11825864/3920439 答案

此处理整数，但对于浮标阵列（至少在python 3.6）不工作 这将提高TypeError: list indices must be integers or slices, not float

Answer 21

https://docs.python.org/3/library/functions。 HTML＃最大

如果多个项目是最大时，该函数将返回所遇到的第一个。这是与其它类型的稳定性保持工具如sorted(iterable, key=keyfunc, reverse=True)[0]一致

要得到超过只是在第一次使用的排序方法。

import operator

x = [2, 5, 7, 4, 8, 2, 6, 1, 7, 1, 8, 3, 4, 9, 3, 6, 5, 0, 9, 0]

min = False
max = True

min_val_index = sorted( list(zip(x, range(len(x)))), key = operator.itemgetter(0), reverse = min )

max_val_index = sorted( list(zip(x, range(len(x)))), key = operator.itemgetter(0), reverse = max )


min_val_index[0]
>(0, 17)

max_val_index[0]
>(9, 13)

import ittertools

max_val = max_val_index[0][0]

maxes = [n for n in itertools.takewhile(lambda x: x[0] == max_val, max_val_index)]