给定一个自索引（不确定这是否是正确的术语）numpy 数组，例如：
a = np.array([3, 2, 0, 1])
这表示这种排列（=>是一个箭头）：
0 => 3
1 => 2
2 => 0
3 => 1
我正在尝试制作一个表示逆变换的数组，而不是在 python 中“手动”执行它，也就是说，我想要一个纯numpy 解决方案。在上述情况下我想要的结果是：
array([2, 3, 1, 0])
这相当于
0 <= 3 0 => 2
1 <= 2 or 1 => 3
2 <= 0 2 => 1
3 <= 1 3 => 0
看起来很简单，但我就是想不出该怎么做。我试过谷歌搜索，但没有找到任何相关的东西。
排序在这里是多余的。 这只是一个具有恒定内存要求的单次线性时间算法：
from __future__ import print_function
import numpy as np
p = np.array([3, 2, 0, 1])
s = np.empty(p.size, dtype=np.int32)
for i in np.arange(p.size):
s[p[i]] = i
print('s =', s)
上面的代码打印
s = [2 3 1 0]
按要求。
答案的其余部分与上述for循环的有效矢量化有关。如果您只是想知道解决方案，请跳到此答案的末尾。
（2014 年 8 月 27 日的原始答案；时间对 NumPy 1.8 有效。稍后会更新 NumPy 1.11。）
单程线性时间算法预计比np.argsort; 有趣的是，上述循环的微不足道的矢量化（s[p] = xrange(p.size)见索引数组for）实际上比np.argsort只要p.size < 700 000（好吧，在我的机器上，你的里程会有所不同）稍慢：
import numpy as np
def np_argsort(p):
return np.argsort(p)
def np_fancy(p):
s = np.zeros(p.size, p.dtype) # np.zeros is better than np.empty here, at least on Linux
s[p] = xrange(p.size)
return s
def create_input(n):
np.random.seed(31)
indices = np.arange(n, dtype = np.int32)
return np.random.permutation(indices)
从我的 IPython 笔记本中：
p = create_input(700000)
%timeit np_argsort(p)
10 loops, best of 3: 72.7 ms per loop
%timeit np_fancy(p)
10 loops, best of 3: 70.2 ms per loop
最终，渐近复杂性开始出现（O(n log n)对于argsort单通道算法），并且单通道算法在足够大（我的机器上的阈值约为 700k）O(n)之后将始终更快。n = p.size
但是，有一种不太直接的方法可以使用以下方法对上述for循环进行矢量化np.put：
def np_put(p):
n = p.size
s = np.zeros(n, dtype = np.int32)
i = np.arange(n, dtype = np.int32)
np.put(s, p, i) # s[p[i]] = i
return s
这给出了n = 700 000（与上面相同的大小）：
p = create_input(700000)
%timeit np_put(p)
100 loops, best of 3: 12.8 ms per loop
这是一个不错的 5.6 倍加速，几乎没有！
公平地说，np.argsort仍然优于np.put较小的方法n（引爆点n = 1210在我的机器上）：
p = create_input(1210)
%timeit np_argsort(p)
10000 loops, best of 3: 25.1 µs per loop
%timeit np_fancy(p)
10000 loops, best of 3: 118 µs per loop
%timeit np_put(p)
10000 loops, best of 3: 25 µs per loop
这很可能是因为我们np.arange()使用该方法分配并填充了一个额外的数组（在调用时）np_put。
尽管您没有要求 Cython 解决方案，但出于好奇，我还使用键入的 memoryviews为以下 Cython 解决方案计时：
import numpy as np
cimport numpy as np
def in_cython(np.ndarray[np.int32_t] p):
cdef int i
cdef int[:] pmv
cdef int[:] smv
pmv = p
s = np.empty(p.size, dtype=np.int32)
smv = s
for i in xrange(p.size):
smv[pmv[i]] = i
return s
时间：
p = create_input(700000)
%timeit in_cython(p)
100 loops, best of 3: 2.59 ms per loop
所以，np.put解决方案仍然没有尽可能快（这个输入大小运行 12.8 毫秒；argsort 花了 72.7 毫秒）。
Jamie、Andris 和 Paul 在下面的评论中指出，花式索引的性能问题已经解决。Jamie 说它已经在 NumPy 1.9 中解决了。我在 2014 年使用的机器上使用 Python 3.5 和 NumPy 1.11 对其进行了测试。
def invert_permutation(p):
s = np.empty(p.size, p.dtype)
s[p] = np.arange(p.size)
return s
时间：
p = create_input(880)
%timeit np_argsort(p)
100000 loops, best of 3: 11.6 µs per loop
%timeit invert_permutation(p)
100000 loops, best of 3: 11.5 µs per loop
确实是一个显着的进步！
总而言之，我会选择
def invert_permutation(p):
'''The argument p is assumed to be some permutation of 0, 1, ..., len(p)-1.
Returns an array s, where s[i] gives the index of i in p.
'''
s = np.empty_like(p)
s[p] = np.arange(p.size)
return s
代码清晰的方法。在我看来，它比 不那么晦涩argsort，并且对于大输入大小也更快。如果速度成为问题，我会选择 Cython 解决方案。
p排列的倒数是排序np.arange(n)的索引数组，即sp
p[s] == np.arange(n)
一定是真的。这s正是np.argsort返回的结果：
>>> p = np.array([3, 2, 0, 1])
>>> np.argsort(p)
array([2, 3, 1, 0])
>>> p[np.argsort(p)]
array([0, 1, 2, 3])
我想为 larsmans 的正确答案提供更多背景知识。当您使用矩阵表示排列时，可以找到正确的原因。置换矩阵的数学优势在于矩阵“对向量进行运算”，即置换矩阵乘以向量来置换向量。argsort P
你的排列看起来像：
import numpy as np
a = np.array([3,2,0,1])
N = a.size
rows = np.arange(N)
P = np.zeros((N,N),dtype=int)
P[rows,a] = 1
[[0 0 0 1]
[0 0 1 0]
[1 0 0 0]
[0 1 0 0]]
给定一个置换矩阵，我们可以通过乘以它的逆来“撤销”乘法P^-1。置换矩阵的美妙之处在于它们是正交的，因此P*P^(-1)=I，或者换句话说P(-1)=P^T，逆矩阵是转置矩阵。这意味着我们可以使用转置矩阵的索引来找到您的倒置置换向量：
inv_a = np.where(P.T)[1]
[2 3 1 0]
P如果您考虑一下，这与查找对!的列进行排序的索引完全相同。