像下面这样:

>>> 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并指定一个函数来提取排序键(每个元组的第二个元素;这就是的意义。最后，使用[i[0] for i in…列表理解。

更新的答案与枚举和项目getter:

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

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

[0, 1, 2, 4, 3]

如果你使用numpy，你有argsort()函数可用:

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

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

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

使用enumerate的答案很好，但我个人不喜欢用lambda来按值排序。下面的操作只是倒转索引和值，并对其排序。首先是按值排序，然后是按下标排序。

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

如果您不想使用numpy，

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

是最快的，如这里所示。

将numpy导入为np

对指数

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

其他答案都是错误的。

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

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

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

答案应该是运行argsort两次:

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

按预期给出数组([2,0,1]，dtype=int64)。

我用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")

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

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

`

本质上你需要做一个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的实现，因此我将根据这里的基准答案简要介绍最快的解决方案

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)

在这种情况下:

the first element of the original is 3, which is the third largest value so it would have index 2 in the sorted array/list so the first element is 2. the second element of the original is 1, which is the smallest value so it would have index 0 in the sorted array/list so the second element is 0. the third element of the original is 2, which is the second-smallest value so it would have index 1 in the sorted array/list so the third element is 1. the fourth element of the original is 4 which is the largest value so it would have index 3 in the sorted array/list so the last element is 3.

代码:

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)

试试这个，对我有用，干杯!

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

首先把你的列表转换成这样:

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

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

对于一个有重复元素的列表，它将返回不带联系的秩，例如。

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

返回

[1, 1, 0, 3, 4]

RustyRob答案的一个变体(它已经是最高性能的纯Python解决方案)，当你排序集合时可能会更好:

不是一个序列(例如，它是一个集合，并且有一个合理的理由希望索引对应于迭代器必须前进多远才能到达项目)，或者 是一个没有O(1)索引的序列(在Python包含的电池中，collections.deque是一个显著的例子)

情况#1不太可能有用，但情况#2更可能有意义。无论哪种情况，你都有两个选择:

转换为列表/元组并使用转换后的版本，或 使用基于迭代顺序分配键的技巧

这个答案为第2点提供了解决方案。请注意，它不能保证按照语言标准工作;该语言表示每个键将被计算一次，但不表示它们的计算顺序。到目前为止，在CPython(引用解释器)的每个版本中，它都是按照从头到尾的顺序预先计算的，所以这是可行的，但请注意，这并不能保证。在任何情况下，代码是:

sizediterable = ...
sorted_indices = sorted(range(len(sizediterable)), key=lambda _, it=iter(sizediterable): next(it))

All that does is provide a key function that ignores the value it's given (an index) and instead provides the next item from an iterator preconstructed from the original container (cached as a defaulted argument to allow it to function as a one-liner). As a result, for something like a large collections.deque, where using its .__getitem__ involves O(n) work (and therefore computing all the keys would involve O(n²) work), sequential iteration remains O(1), so generating the keys remains just O(n).

如果您需要使用内置类型来保证语言标准的工作，Roman的解决方案将具有与此解决方案相同的算法效率(因为它们都不依赖于索引原始容器的算法效率)。

需要明确的是，对于collections.deque的建议用例，deque必须非常大;Deques有一个相当大的常量除数用于索引，所以只有真正巨大的才会有问题。当然，出于同样的原因，如果输入比较小/便宜，排序的成本是非常小的，所以如果输入足够大，有效的排序很重要，那么它们也足够大，有效的索引也很重要。