我有一个数字数组，我想创建另一个数组，表示第一个数组中每个项目的排名。我正在使用Python和NumPy。
例如：
array = [4,2,7,1]
ranks = [2,1,3,0]
这是我提出的最佳方法：
array = numpy.array([4,2,7,1])
temp = array.argsort()
ranks = numpy.arange(len(array))[temp.argsort()]
是否有更好/更快的方法避免对数组进行两次排序？
答案 0 :(得分：79)
使用argsort两次，首先获取数组的顺序，然后获得排名：
array = numpy.array([4,2,7,1])
order = array.argsort()
ranks = order.argsort()
处理2D（或更高维度）数组时，请务必将argsort的轴参数传递给正确的轴。
答案 1 :(得分：71)
这个问题已有几年了，接受的答案很好，但我认为以下内容仍值得一提。如果您不介意依赖scipy，则可以使用scipy.stats.rankdata：
In [22]: from scipy.stats import rankdata
In [23]: a = [4, 2, 7, 1]
In [24]: rankdata(a)
Out[24]: array([ 3., 2., 4., 1.])
In [25]: (rankdata(a) - 1).astype(int)
Out[25]: array([2, 1, 3, 0])
rankdata的一个很好的特性是method参数提供了几个处理关系的选项。例如，b中有三次出现20次，两次出现40次：
In [26]: b = [40, 20, 70, 10, 20, 50, 30, 40, 20]
默认值将平均排名指定为关联值：
In [27]: rankdata(b)
Out[27]: array([ 6.5, 3. , 9. , 1. , 3. , 8. , 5. , 6.5, 3. ])
method='ordinal'指定连续排名：
In [28]: rankdata(b, method='ordinal')
Out[28]: array([6, 2, 9, 1, 3, 8, 5, 7, 4])
method='min'将绑定值的最小等级分配给所有绑定值：
In [29]: rankdata(b, method='min')
Out[29]: array([6, 2, 9, 1, 2, 8, 5, 6, 2])
有关更多选项，请参阅docstring。
答案 2 :(得分：53)
在最后一步的左侧使用切片：
array = numpy.array([4,2,7,1])
temp = array.argsort()
ranks = numpy.empty_like(temp)
ranks[temp] = numpy.arange(len(array))
这可以通过在最后一步中反转排列来避免排序两次。
答案 3 :(得分：4)
我试图为多个维度的数组A扩展两个解决方案，假设您逐行处理数组（axis = 1）。
我在行上循环扩展了第一个代码;可能它可以改进
temp = A.argsort(axis=1)
rank = np.empty_like(temp)
rangeA = np.arange(temp.shape[1])
for iRow in xrange(temp.shape[0]):
rank[iRow, temp[iRow,:]] = rangeA
根据k.rooijers的建议，第二个成为：
temp = A.argsort(axis=1)
rank = temp.argsort(axis=1)
我随机生成了400个形状（1000,100）的阵列;第一个代码约占7.5，第二个代码占3.8。
答案 4 :(得分：4)
对于平均排名的矢量化版本，请参见下文。我喜欢np.unique，它确实扩大了代码的范围，无法有效地进行矢量化。除了避免python for循环之外，这种方法还避免了对'a'的隐式双循环。
import numpy as np
a = np.array( [4,1,6,8,4,1,6])
a = np.array([4,2,7,2,1])
rank = a.argsort().argsort()
unique, inverse = np.unique(a, return_inverse = True)
unique_rank_sum = np.zeros_like(unique)
np.add.at(unique_rank_sum, inverse, rank)
unique_count = np.zeros_like(unique)
np.add.at(unique_count, inverse, 1)
unique_rank_mean = unique_rank_sum.astype(np.float) / unique_count
rank_mean = unique_rank_mean[inverse]
print rank_mean
答案 5 :(得分：2)
我尝试了上述方法，但因为我有很多zeores而失败了。是的，即使浮动重复项也许很重要。
所以我通过添加一个绑定检查步骤来编写修改后的一维解决方案：
def ranks (v):
import numpy as np
t = np.argsort(v)
r = np.empty(len(v),int)
r[t] = np.arange(len(v))
for i in xrange(1, len(r)):
if v[t[i]] <= v[t[i-1]]: r[t[i]] = r[t[i-1]]
return r
# test it
print sorted(zip(ranks(v), v))
我相信它尽可能高效。
答案 6 :(得分：2)
除了解决方案的简洁和简短之外，还存在性能问题。这是一个小基准：
import numpy as np
from scipy.stats import rankdata
l = list(reversed(range(1000)))
%%timeit -n10000 -r5
x = (rankdata(l) - 1).astype(int)
>>> 128 µs ± 2.72 µs per loop (mean ± std. dev. of 5 runs, 10000 loops each)
%%timeit -n10000 -r5
a = np.array(l)
r = a.argsort().argsort()
>>> 69.1 µs ± 464 ns per loop (mean ± std. dev. of 5 runs, 10000 loops each)
%%timeit -n10000 -r5
a = np.array(l)
temp = a.argsort()
r = np.empty_like(temp)
r[temp] = np.arange(len(a))
>>> 63.7 µs ± 1.27 µs per loop (mean ± std. dev. of 5 runs, 10000 loops each)
答案 7 :(得分：1)
使用argsort（）两次就可以了：
>>> array = [4,2,7,1]
>>> ranks = numpy.array(array).argsort().argsort()
>>> ranks
array([2, 1, 3, 0])
答案 8 :(得分：0)
我喜欢k.rooijers的方法，但正如rcoup写的那样，重复的数字按照数组位置进行排名。这对我来说没什么用，所以我修改了版本来对队列进行后处理，并将任何重复的数字合并为一个综合的平均排名：
import numpy as np
a = np.array([4,2,7,2,1])
r = np.array(a.argsort().argsort(), dtype=float)
f = a==a
for i in xrange(len(a)):
if not f[i]: continue
s = a == a[i]
ls = np.sum(s)
if ls > 1:
tr = np.sum(r[s])
r[s] = float(tr)/ls
f[s] = False
print r # array([ 3. , 1.5, 4. , 1.5, 0. ])
我希望这也可能对其他人有所帮助，我试图找到一个解决方法，但找不到...
答案 9 :(得分：0)
尝试两次切片，而不是argsort两次。因为slice比argsort快
array = numpy.array([4,2,7,1])
order = array.argsort()
ranks = np.arange(array.shape[0])[order][order]
答案 10 :(得分：0)
答案的更一般的版本：
$order->update_meta_data( billing_first_name, 'foo' );
$order->save;
请参见How to use numpy.argsort() as indices in more than 2 dimensions?以泛化为更多的暗淡。