使用Python/NumPy对数组中的项进行排名，而不需要两次排序数组

Question

我有一个数字数组，想要创建另一个数组来表示第一个数组中每个项目的排名。我正在使用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()]

有没有更好/更快的方法可以避免两次排序数组？

- joshayers

---

你的最后一行等同于 ranks = temp.argsort()。 - Sven Marnach

当数据存在平局时，该方法无效。 - Mohammad Tehrani

Answer 1

使用 argsort 两次，首先获取数组的顺序，然后获取排名：

array = numpy.array([4,2,7,1])
order = array.argsort()
ranks = order.argsort()

处理2D（或更高维）数组时，请确保向argsort传递一个轴参数，以便在正确的轴上进行排序。

- k.rooijers

---

请注意，如果您的输入数组中存在重复的数字（例如 [4,2,7,1,1]），则输出将根据它们在数组中的位置对这些数字进行排名（[3,2,4,0,1]）。 - rcoup

排序两次是低效的。@Sven Marnach的回答展示了如何通过一次调用argsort函数实现排名。 - Warren Weckesser

我刚刚测试了这两个方法的差异，你说得对，对于大数组来说，argsort是更快的选择。但是对于任何较小的东西（n <100），双倍argsort更快一些（对于n = 100大约快20％，对于n = 10则快了5倍）。因此，如果您需要在许多小值集之间进行大量排名处理，则这种方法要好得多。 - naught101

@WarrenWeckesser：实际上，我错了，这种方法毫无疑问更好。两种方法的速度都比scipy.stats方法要快得多。结果请看：https://gist.github.com/naught101/14042d91a2d0f18a6ae4 - naught101

你的脚本里有一个错误。第array = np.random.rand(10)行应该改为array = np.random.rand(n)。 - Warren Weckesser

Answer 2

这个问题已经存在几年了，接受的答案很好，但我认为以下内容仍然值得一提。 如果你不介意依赖于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])

更多选项，请查看函数文档字符串。

- Warren Weckesser

---

是的，这是任何地方都重要的边缘情况下最好的答案。 - naught101

我觉得有趣的是，rankdata 似乎使用与被接受的答案相同的机制来在内部生成初始排名。 - AlexV

这是一个很棒的答案，它同样适用于我想要在pandas数据框的每一行中对元素进行排名，但同时指定axis=0在rankdata()中处理并列情况。 - Laurin Herbsthofer

Answer 3

在最后一步中，在左侧使用高级索引：

array = numpy.array([4,2,7,1])
temp = array.argsort()
ranks = numpy.empty_like(temp)
ranks[temp] = numpy.arange(len(array))

这样做可以避免在最后一步中通过反转排列来进行两次排序。

- Sven Marnach

---

非常好，谢谢！我知道肯定有解决方案，一旦看到它就会显得很明显。我用timeit做了一些测试，对于小数组，这种方法略慢。在我的机器上，当数组有2,000个元素时它们是相等的。当有20,000个元素时，你的方法大约比另一种方法快25%。 - joshayers

有关如何逐行执行此操作的任何建议？ - Xaser

对于超过1维的情况，请参见下面的答案。 - mathtick

只是一个“小”的更正，间接引用 ranks[temp] 在技术上不是 切片 ，而是 索引（参见 https://numpy.org/doc/stable/reference/arrays.indexing.html）。 - Shmil The Cat

看起来有点像 scipy.stats.rankdata（用于计算序数排名）的实现。 - djvg

当数据存在平局时，该方法无法正常工作。 - Mohammad Tehrani

Answer 4

使用 argsort() 两次即可实现：

>>> array = [4,2,7,1]
>>> ranks = numpy.array(array).argsort().argsort()
>>> ranks
array([2, 1, 3, 0])

- Kwong

---

在你回答之前，这已经被提及过了。原文链接：https://dev59.com/WsKVzogBFxS5KdRj5vjM#6266510。 - Ciprian Tomoiagă

Answer 5

对于平均排名的矢量化版本，请参见下文。我喜欢np.unique，它真正扩大了代码可以和不能有效矢量化的范围。除了避免使用python循环外，这种方法还避免了对'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

- Eelco Hoogendoorn

---

顺便说一句，我编写了这段代码以生成与其他平均排名代码相同的输出，但我可以想象一组重复数字的最小排名同样适用。这甚至可以更容易地获得，如下所示：

unique, index, inverse = np.unique(a, True, True) rank_min = rank[index][inverse]

- Eelco Hoogendoorn

我在使用你提供的解决方案(numpy 1.7.1)时遇到了以下错误: AttributeError: 'numpy.ufunc' object has no attribute 'at' - Fear

这需要一个更新版本的numpy；您的版本相当陈旧。 - Eelco Hoogendoorn

Answer 6

我尝试扩展两个解决方案，用于处理多维数组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秒。

- Dr Fabio Gori

Answer 7

除了解决方案的优雅和简洁，性能也是一个问题。以下是一个小型基准测试：

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)

- Mischa Lisovyi

---

好主意，但为了公平比较，您应该使用rankdata(l, method='ordinal') - 1。 - Warren Weckesser

最好使用随机生成的数组 - l = random.choices(range(500),k=10000) - 变化样本、大小和迭代以获得更全面的图片。来自 @yupbank 的双重切片看起来很有趣。 - Peter

Answer 8

我尝试了上述方法，但由于我有很多零值，所以失败了。是的，即使使用浮点数，重复项也可能很重要。

因此，我编写了一个修改后的一维解决方案，添加了一个检查相等的步骤：

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

我相信它已经尽可能高效了。

- h2kyeong

Answer 9

argsort和slice是对称操作。

尝试两次使用slice而不是两次使用argsort。因为slice比argsort更快。

array = numpy.array([4,2,7,1])
order = array.argsort()
ranks = np.arange(array.shape[0])[order][order]

- yupbank

---

ranks = order[order] 不是等价的吗？顺便说一下，我认为你的代码通常不起作用。 - Andris Birkmanis

Answer 10

我喜欢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. ])

我希望这也能帮到其他人，我试图寻找其他的解决方案，但没有找到...

- Martin F Thomsen