如何在 Python 中获取已排序数组的索引

Question

我有一个数字列表：

myList = [1, 2, 3, 100, 5]

现在如果我对该列表进行排序以获得[1, 2, 3, 5, 100]。 我想要的是元素的索引 按排序顺序排列的原始列表，即[0, 1, 2, 4, 3] --- ala MATLAB 的 sort 函数同时返回 价值和指数。

Answer 1

s = [2, 3, 1, 4, 5]
print([sorted(s, reverse=False).index(val) for val in s]) 

它甚至适用于具有重复元素的列表。

Answer 2

我用perfplot（我的一个项目）对这些进行了快速的性能检查，发现除了推荐其他任何东西都很难

np.argsort(x)

（注意对数刻度）：

---

重现情节的代码：

import perfplot
import numpy as np


def sorted_enumerate(seq):
    return [i for (v, i) in sorted((v, i) for (i, v) in enumerate(seq))]


def sorted_enumerate_key(seq):
    return [x for x, y in sorted(enumerate(seq), key=lambda x: x[1])]


def sorted_range(seq):
    return sorted(range(len(seq)), key=seq.__getitem__)


b = perfplot.bench(
    setup=np.random.rand,
    kernels=[sorted_enumerate, sorted_enumerate_key, sorted_range, np.argsort],
    n_range=[2 ** k for k in range(15)],
    xlabel="len(x)",
)
b.save("out.png")

Answer 3

首先将您的列表转换为：

myList = [1, 2, 3, 100, 5]

为列表项添加索引

myList = [[0, 1], [1, 2], [2, 3], [3, 100], [4, 5]]

下一个：

sorted(myList, key=lambda k:k[1])

结果：

[[0, 1], [1, 2], [2, 3], [4, 5], [3, 100]]

Answer 4

为此目的使用 Numpy 包的最简单方法：

import numpy
s = numpy.array([2, 3, 1, 4, 5])
sort_index = numpy.argsort(s)
print(sort_index)

但是如果你想要你的代码应该使用 baisc python 代码：

s = [2, 3, 1, 4, 5]
li=[]
  
for i in range(len(s)):
      li.append([s[i],i])
li.sort()
sort_index = []
  
for x in li:
      sort_index.append(x[1])
  
print(sort_index)

Answer 5

代码：

s = [2, 3, 1, 4, 5]
li = []

for i in range(len(s)):
    li.append([s[i], i])
li.sort()
sort_index = []

for x in li:
    sort_index.append(x[1])

print(sort_index)

试试这个，它对我有用，干杯！

Answer 6

基本上你需要做一个argsort，你需要什么实现取决于你是想使用外部库（例如NumPy）还是你想保持纯Python而不依赖。

你需要问自己的问题是：你想要的

• 对数组/列表进行排序的索引
• 元素在排序数组/列表中的索引

不幸的是，问题中的示例并未明确说明所需的内容，因为两者都会给出相同的结果：

>>> arr = np.array([1, 2, 3, 100, 5])

>>> np.argsort(np.argsort(arr))
array([0, 1, 2, 4, 3], dtype=int64)

>>> np.argsort(arr)
array([0, 1, 2, 4, 3], dtype=int64)

选择argsort 实现

如果您可以使用 NumPy，您可以简单地使用函数 numpy.argsort 或方法 numpy.ndarray.argsort。

其他一些答案中已经提到了没有 NumPy 的实现，所以我将根据the benchmark answer here 回顾一下最快的解决方案

def argsort(l):
    return sorted(range(len(l)), key=l.__getitem__)

获取对数组/列表进行排序的索引

要获得对数组/列表进行排序的索引，您只需在数组或列表上调用argsort。我在这里使用 NumPy 版本，但 Python 实现应该给出相同的结果

>>> arr = np.array([3, 1, 2, 4])
>>> np.argsort(arr)
array([1, 2, 0, 3], dtype=int64)

结果包含获取排序数组所需的索引。

由于排序后的数组将是[1, 2, 3, 4]，因此 argsorted 数组包含原始中这些元素的索引。

• 最小值是1，它位于原始索引1，因此结果的第一个元素是1。
• 2 在原始索引中位于索引2，因此结果的第二个元素是2。
• 3 在原始索引中位于索引0，因此结果的第三个元素是0。
• 最大值4，它在原始索引中的索引3，所以结果的最后一个元素是3。

获取元素在排序数组/列表中的索引

在这种情况下，您需要申请argsort 两次：

>>> arr = np.array([3, 1, 2, 4])
>>> np.argsort(np.argsort(arr))
array([2, 0, 1, 3], dtype=int64)

在这种情况下：

• 原始的第一个元素是3，这是第三大值，因此它在排序后的数组/列表中具有索引2，因此第一个元素是2。
• 原始的第二个元素是1，这是最小值，因此它在排序后的数组/列表中有索引0，所以第二个元素是0。
• 原始的第三个元素是2，这是第二小的值，因此它在排序后的数组/列表中有索引1，所以第三个元素是1。
• 原始的第四个元素是4，这是最大值，所以它在排序的数组/列表中会有索引3，所以最后一个元素是3。

Answer 7

我们将创建另一个从 0 到 n-1 的索引数组 然后将其压缩到原数组中，然后根据原值排序

ar = [1,2,3,4,5]
new_ar = list(zip(ar,[i for i in range(len(ar))]))
new_ar.sort()

`

Answer 8

其他答案是错误的。

运行argsort 一次不是解决方案。 例如以下代码：

import numpy as np
x = [3,1,2]
np.argsort(x)

产生array([1, 2, 0], dtype=int64)，这不是我们想要的。

答案应该是运行argsort两次：

import numpy as np
x = [3,1,2]
np.argsort(np.argsort(x))

按预期提供array([2, 0, 1], dtype=int64)。

Answer 9

myList = [1, 2, 3, 100, 5]    
sorted(range(len(myList)),key=myList.__getitem__)

[0, 1, 2, 4, 3]

Answer 10

将 numpy 导入为 np

FOR 索引

S=[11,2,44,55,66,0,10,3,33]

r=np.argsort(S)

[output]=array([5, 1, 7, 6, 0, 8, 2, 3, 4])

argsort 按排序顺序返回 S 的索引

为了价值

np.sort(S)

[output]=array([ 0,  2,  3, 10, 11, 33, 44, 55, 66])

Answer 11

如果你不想使用 numpy，

sorted(range(len(seq)), key=seq.__getitem__)

最快，如 here 所示。

Answer 12

如果您使用的是 numpy，则可以使用 argsort() 函数：

>>> import numpy
>>> numpy.argsort(myList)
array([0, 1, 2, 4, 3])

http://docs.scipy.org/doc/numpy/reference/generated/numpy.argsort.html

这将返回对数组或列表进行排序的参数。

Answer 13

用enumerate 和itemgetter 更新答案：

sorted(enumerate(a), key=lambda x: x[1])
# [(0, 1), (1, 2), (2, 3), (4, 5), (3, 100)]

将列表压缩在一起：元组中的第一个元素是索引，第二个是值（然后使用元组的第二个值x[1]对其进行排序，x 是元组）

或者使用来自operatormodule`的itemgetter：

from operator import itemgetter
sorted(enumerate(a), key=itemgetter(1))

Answer 14

enumerate 的答案很好，但我个人不喜欢用于按值排序的 lambda。以下只是反转索引和值，并对其进行排序。所以它会首先按值排序，然后按索引。

sorted((e,i) for i,e in enumerate(myList))

Answer 15

类似下一个：

>>> myList = [1, 2, 3, 100, 5]
>>> [i[0] for i in sorted(enumerate(myList), key=lambda x:x[1])]
[0, 1, 2, 4, 3]

enumerate(myList) 给你一个包含 (index, value) 元组的列表：

[(0, 1), (1, 2), (2, 3), (3, 100), (4, 5)]

通过将列表传递给 sorted 并指定一个函数来提取排序键（每个元组的第二个元素；这就是 lambda 的用途。最后，每个 的原始索引对列表进行排序sorted 元素是使用[i[0] for i in ...] 列表解析提取的。