Python 如何判断多个索引何时匹配？

我有任何一组值，它们通常是相同的，我试图找到最小值的索引。但我想知道所有相同的物体

例如，我有一个数组

a=[1,2,3,4]

，为了找到最小数组的索引，我使用

a.index（min（a））

，它返回0。但是如果我有一个

a=[1,1,1,1]

数组，使用相同的东西仍然会返回0

我想知道多个索引是否匹配我正在搜索的内容以及这些索引是什么。如何执行此操作？

列表。索引（值）

返回

列表中第一次出现的
值的索引

更好的方法是使用简单的列表理解和：

其中，
v
是要搜索的值，
iterable
是支持迭代器协议的对象，例如，它可以是生成器或序列（如
list
）

对于您的特定用例，如下所示

def smallest(seq):
    m = min(seq)
    return [i for i, x in enumerate(seq) if x == m]

In [1]: import numpy as np
In [2]: def np_smallest(seq):
   ...:     return np.where(seq==seq.min())[0]

In [3]: np_smallest(np.array([1,1,1,1]))
Out[3]: array([0, 1, 2, 3])

In [4]: np_smallest(np.array([1,2,3,4]))
Out[4]: array([0])

一些例子：

In [23]: smallest([1, 2, 3, 4])
Out[23]: [0]

In [24]: smallest([1, 1, 1, 1])
Out[24]: [0, 1, 2, 3]

如果不确定
seq
是否为空，可以将
default=-1
（或其他一些值）参数传递给
min
函数（在Python 3.4+中）：

在使用较旧的Python时，请考虑使用
m=min（seq或（-1，）
（同样是任意值）。
以下是我的解决方案：

def all_smallest(seq):
    """Takes sequence, returns list of all smallest elements"""
    min_i = min(seq)
    amount = seq.count(min_i)
    ans = []
    if amount > 1:
        for n, i in enumerate(seq):
            if i == min_i:
                ans.append(n)
            if len(ans) == amount:
                return ans            
    return [seq.index(min_i)]

我认为这里的代码非常简单，没有任何解释。
使用

def smallest(seq):
    m = min(seq)
    return [i for i, x in enumerate(seq) if x == m]

In [1]: import numpy as np
In [2]: def np_smallest(seq):
   ...:     return np.where(seq==seq.min())[0]

In [3]: np_smallest(np.array([1,1,1,1]))
Out[3]: array([0, 1, 2, 3])

In [4]: np_smallest(np.array([1,2,3,4]))
Out[4]: array([0])

对于小列表，这种方法的效率比列表理解要低一些，但是如果您面对大数组，numpy可能会为您节省一些时间

In [5]: seq = np.random.randint(100, size=1000)
In [6]: %timeit np_smallest(seq)
100000 loops, best of 3: 10.1 µs per loop
In [7]: %timeit smallest(seq)
1000 loops, best of 3: 194 µs per loop

他并没有说他需要实际的指数。。。只有
.count
可能有sufficed@JoranBeasley我不这么认为。他想要所有的指数。“我试图找到最小索引的索引。但我想知道所有相同的对象。”我想你可能是对的，但是“我想知道多个索引与我正在搜索的匹配。”以及标题“如何判断多个索引何时匹配？”听起来他并不关心这些索引在哪里，只是问题文本中有不止一个minGo，而不是标题（必须合理简短）。他想知道所有的对象，而你通常通过引用知道一个对象，所以他应该知道列表中每个对象的索引。谢谢大家，这正是我想要的。我对问题进行了编辑，以使其更清楚。你只是做了与@vaultah的答案完全相同的事情，但没有列表理解，使其效率降低。如果序列中只有一个元素比列表理解更有效，那么它只会遍历所有元素一次，列表理解无论如何会做更多无用的工作，但在我的解决方案中，可以用列表理解替换for循环。它为您节省了两行代码。