Question

我有一个整数列表，例如：

my_list = [5, 2, 4, 9]

我想要一个列表，其中包含每个元素在列表中出现的位置。所以在上面的例子中，我想要这个结果：

>>> sorted(my_list)
[2, 4, 5, 9]

>>> magnitude(my_list)
[2, 0, 1, 3]

...因为排序后：

5最终处于2
2最终处于0
4最终处于1
9最终处于3

我该怎么做？

Answer 1

In [8]: L = [5,2,4,9]

In [9]: LL = sorted(L)

In [10]: LL
Out[10]: [2, 4, 5, 9]

In [11]: sorted(enumerate(LL), key=lambda t: L.index(t[1]))
Out[11]: [(2, 5), (0, 2), (1, 4), (3, 9)]

In [12]: [s[0] for s in sorted(enumerate(LL), key=lambda t: L.index(t[1]))]
Out[12]: [2, 0, 1, 3]

Answer 2

我们可以通过对序列的枚举进行排序来获得解决方案的一半 - 例如：

>>> from operator import itemgetter
>>> second_item = itemgetter(1)
>>> my_list = [5, 2, 4, 9]
>>> sorted(enumerate(my_list), key=second_item)
[(1, 2), (2, 4), (0, 5), (3, 9)]

如您所见，结果列表中的每一对都具有(original_position, sorted_item)形式...例如，5最初位于0位置。

我们可以编写一个只返回原始位置的函数：

def order(s):
    return [t[0] for t in sorted(enumerate(s), key=second_item)]

让我们确保它有效：

>>> order(my_list)
[1, 2, 0, 3]

聪明的一点是，现在我们再次对自己的结果运行相同的函数：

>>> order([1, 2, 0, 3])
[2, 0, 1, 3]

要了解这里发生了什么，让我们回过头来看看order()实际上在做什么：

>>> sorted(enumerate([1, 2, 0, 3]), key=second_item)
[(2, 0), (0, 1), (1, 2), (3, 3)]

同样，每一对都有(original_position, sorted_item)形式，因此我们会有效地将这些位置排序回原始顺序并查看它们的最终位置。

现在我们需要做的就是在自己的函数中包含order()的双重使用，我们已经完成了：

from operator import itemgetter

second_item = itemgetter(1)

def order(s):
    return [t[0] for t in sorted(enumerate(s), key=second_item)]

def magnitude(s):
    return order(order(s))

......在这里它正在发挥作用：

>>> magnitude([5, 2, 4, 9])
[2, 0, 1, 3]

序列的索引元素，它们将出现在排序副本中

2 个答案: