我想创建一个函数，它将(排序的)列表作为其参数，并输出一个包含每个元素对应百分位数的列表。

例如，fn([1,2,3,4,17]) 返回 [0.0, 0.25, 0.50, 0.75, 1.00]。

任何人都可以请:

1. 帮我更正下面的代码？或
2. 提供比我的代码更好的替代方法来将列表中的值映射到相应的百分位数？

我当前的代码:

def median(mylist):
    length = len(mylist)
    if not length % 2:
        return (mylist[length / 2] + mylist[length / 2 - 1]) / 2.0
    return mylist[length / 2]

###############################################################################
# PERCENTILE FUNCTION
###############################################################################

def percentile(x):
    """
    Find the correspoding percentile of each value relative to a list of values.
    where x is the list of values
    Input list should already be sorted!
    """

    # sort the input list
    # list_sorted = x.sort()

    # count the number of elements in the list
    list_elementCount = len(x)

    #obtain set of values from list

    listFromSetFromList = list(set(x))

    # count the number of unique elements in the list
    list_uniqueElementCount = len(set(x))

    # define extreme quantiles
    percentileZero    = min(x)
    percentileHundred = max(x)

    # define median quantile
    mdn = median(x) 

    # create empty list to hold percentiles
    x_percentile = [0.00] * list_elementCount 

    # initialize unique count
    uCount = 0

    for i in range(list_elementCount):
        if x[i] == percentileZero:
            x_percentile[i] = 0.00
        elif x[i] == percentileHundred:
            x_percentile[i] = 1.00
        elif x[i] == mdn:
            x_percentile[i] = 0.50 
        else:
            subList_elementCount = 0
            for j in range(i):
                if x[j] < x[i]:
                    subList_elementCount = subList_elementCount + 1 
            x_percentile[i] = float(subList_elementCount / list_elementCount)
            #x_percentile[i] = float(len(x[x > listFromSetFromList[uCount]]) / list_elementCount)
            if i == 0:
                continue
            else:
                if x[i] == x[i-1]:
                    continue
                else:
                    uCount = uCount + 1
    return x_percentile

目前，如果我提交 percentile([1,2,3,4,17])，列表 [0.0, 0.0, 0.5, 0.0, 1.0]被退回。

最佳答案

我认为您的示例输入/输出与计算百分位数的典型方法不对应。如果您将百分位数计算为“数据点的比例严格小于该值”，则最大值应为 0.8(因为 5 个值中有 4 个小于最大值)。如果将其计算为“小于或等于该值的数据点的百分比”，则底部值应为 0.2(因为 5 个值中的 1 个等于最小值)。因此，百分位数将是 [0, 0.2, 0.4, 0.6, 0.8] 或 [0.2, 0.4, 0.6, 0.8, 1]。您的定义似乎是“数据点的数量严格小于该值，被视为不等于该值的数据点数量的比例”，但根据我的经验，这不是一个常见的定义(例如参见 wikipedia ) .

使用典型的百分位数定义，数据点的百分位数等于其排名除以数据点的数量。 (例如，参见 Stats SE 上的 this question，询问如何在 R 中做同样的事情。)如何计算百分位数的差异相当于如何计算排名的差异(例如，如何对绑定(bind)值进行排名)。 scipy.stats.percentileofscore 函数提供了四种计算百分位数的方法:

>>> x = [1, 1, 2, 2, 17]
>>> [stats.percentileofscore(x, a, 'rank') for a in x]
[30.0, 30.0, 70.0, 70.0, 100.0]
>>> [stats.percentileofscore(x, a, 'weak') for a in x]
[40.0, 40.0, 80.0, 80.0, 100.0]
>>> [stats.percentileofscore(x, a, 'strict') for a in x]
[0.0, 0.0, 40.0, 40.0, 80.0]
>>> [stats.percentileofscore(x, a, 'mean') for a in x]
[20.0, 20.0, 60.0, 60.0, 90.0]

(我使用了一个包含关系的数据集来说明在这种情况下会发生什么。)

“排名”方法为并列组分配的排名等于他们将覆盖的排名的平均值(即，第三名的三人并列获得排名 3，因为它“占用”排名 2、3 和4)。 “弱”方法根据小于或等于给定点的数据点的比例分配百分位数； “严格”是相同的，但计算点的比例严格小于给定点。 “均值”法是后两者的平均值。

正如 Kevin H. Lin 所说，在循环中调用 percentileofscore 效率低下，因为它必须在每次通过时重新计算排名。但是，可以使用 scipy.stats.rankdata 提供的不同排名方法轻松复制这些百分位数计算，让您一次计算所有百分位数:

>>> from scipy import stats
>>> stats.rankdata(x, "average")/len(x)
array([ 0.3,  0.3,  0.7,  0.7,  1. ])
>>> stats.rankdata(x, 'max')/len(x)
array([ 0.4,  0.4,  0.8,  0.8,  1. ])
>>> (stats.rankdata(x, 'min')-1)/len(x)
array([ 0. ,  0. ,  0.4,  0.4,  0.8])

在最后一种情况下，将排名向下调整 1 以使它们从 0 而不是 1 开始。(我省略了“均值”，但可以通过对后两种方法的结果进行平均来轻松获得。)

我做了一些计时。对于您的示例中的小数据，使用 rankdata 比 Kevin H. Lin 的解决方案要慢一些(可能是由于 scipy 在将事物转换为 numpy 数组时产生的开销)，但比调用更快percentileofscore 在循环中，如 reptilicus 的回答:

In [11]: %timeit [stats.percentileofscore(x, i) for i in x]
1000 loops, best of 3: 414 µs per loop

In [12]: %timeit list_to_percentiles(x)
100000 loops, best of 3: 11.1 µs per loop

In [13]: %timeit stats.rankdata(x, "average")/len(x)
10000 loops, best of 3: 39.3 µs per loop

不过，对于大型数据集，numpy 的性能优势开始发挥作用，使用 rankdata 比 Kevin 的 list_to_percentiles 快 10 倍:

In [18]: x = np.random.randint(0, 10000, 1000)

In [19]: %timeit [stats.percentileofscore(x, i) for i in x]
1 loops, best of 3: 437 ms per loop

In [20]: %timeit list_to_percentiles(x)
100 loops, best of 3: 1.08 ms per loop

In [21]: %timeit stats.rankdata(x, "average")/len(x)
10000 loops, best of 3: 102 µs per loop

这种优势只会在越来越大的数据集上变得更加明显。

关于python - 将每个列表值映射到其相应的百分位数，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/12414043/