numpy.percentile

numpy.percentile(a, q, axis=None, out=None, overwrite_input=False, interpolation='linear', keepdims=False)

Функция percentile() вычисляет q-й процентиль (перцентиль) значений элементов массива или элементов вдоль указанной оси.

Параметры:
a - массив NumPy или подобный массиву объект.
Входные данные.
q - целое положительное число, массив NumPy или подобный массиву объект.
Процентиль или последовательность процентилей. Допустимые значения находятся в интервале [0, 100]..
axis - целое число или кортеж целых чисел, необязательный параметр.
Указывает ось или оси по которым выполняется вычисление (доступно в NumPy с версии 1.9.0). По умолчанию axis = None, что соответствует вычислению процентиля так, словно a сжат до одной оси.
out - массив NumPy, необязательный параметр.
Массив в который можно поместить результат функции. Данный массив должен соответствовать форме и типу данных результирующего массива функции (зачастую, тип данных может быть преобразован автоматически). Указание данного параметра, позволяет избежать лишней операции присваивания тем самым немного ускоряя работу вашего кода. Полезный параметр если вы очень часто обращаетесь к функции в цикле.
overwrite_input - True или False, необязательный параметр.
Значение True позволяет использовать входной массив a для промежуточных вычислей, что позволяет сэкономит память но приводит к потере данных.
interpolation - {‘linear’, ‘lower’, ‘higher’, ‘midpoint’, ‘nearest’}, необязательный параметр.

Если требуемый процентиль находится между двумя значениями элементов входного массива, то данный параметр позволяет задать метод интерполяции для расчета конечного значения. Обозначим два элемента, между которыми находится значение процентиля, как i и j, причем i < j, тогда методы интерполяции будут задаваться следующими правилами:

  • ‘linear’ - i + (j - i) * fract, где frac является дробной частью процентиля.
  • ‘lower’ - возвращается i.
  • ‘higher’ - возвращается j.
  • ‘midpoint’ - к p значение.
  • ‘nearest’ - среднее значение между i и j.
keepdims - True или False, необязательный параметр.
Если данный параметр указан как True, то результат работы функции по указанным осям будет способен к транслированию по исходному массиву, т.е. результат функции оформляется в массив с количеством осей исходного массива. Если параметр установлен в значение False, то результатом работы функции будет либо число, либо одномерный массив чисел. Доступно в NumPy с версии 1.9.0.
Возвращает:
результат - массив NumPy или число
Если параметр q - это одно число, то результатом так же будет одно число. Если параметр q - это массив из нескольких процентилей, то будет возвращен массив аналогичной длинны. Если входной массив имеет несколько осей, указано несколько процентилей и указана ось (или указано несколько осей) в параметре axis, то будет возвращен массив, по первой оси которого расположены значения (массивы значения) для каждого указанного в q процентиля.

Замечание

Если типом данных входного массива являются целые числа или тип float меньший чем float64, то тип данных результирующего массива будет преобразован к float64. В противном случае, преобразование типов не выполняется.

Смотрите так же:
nanpercentile, quantile, nanquantile


Примеры

50-й процентиль, это, по сути, медиана, т.е. функция numpy.percentile должна вернуть такое значение, которое меньше ровно половины элементов массива:

>>> import numpy as np
>>> 
>>> a = np.arange(10)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> 
>>> np.percentile(a, 50)
4.5

Мы можем указать несколько процентилей, например, посмотрим каковы значения 30-го и 70-го процентиля для предыдущего массива:

>>> np.percentile(a, q = [30, 70])
array([2.7, 6.3])

Если мы имеем дело с двумерными массивами, то мы можем узнать процентиль каждого отдельного столбца или строки:

>>> b = np.arange(36).reshape(6, 6)
>>> b
array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11],
       [12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23],
       [24, 25, 26, 27, 28, 29],
       [30, 31, 32, 33, 34, 35]])
>>> 
>>> #  Процентиль каждого столбца:
... np.percentile(b, q = 50, axis = 0)
array([15., 16., 17., 18., 19., 20.])
>>> 
>>> #  Процентиль каждой строки:
... np.percentile(b, q = 50, axis = 1)
array([ 2.5,  8.5, 14.5, 20.5, 26.5, 32.5])

Мы можем указать несколько процентилей для каждой оси:

>>> np.percentile(b, q = [30, 70], axis = 0)
array([[ 9., 10., 11., 12., 13., 14.],
       [21., 22., 23., 24., 25., 26.]])
>>> 
>>> np.percentile(b, q = [30, 70], axis = 1)
array([[ 1.5,  7.5, 13.5, 19.5, 25.5, 31.5],
       [ 3.5,  9.5, 15.5, 21.5, 27.5, 33.5]])

Параметр keepdims сохраняет у результата форму исходного массива, что в дальнейшем позволяет использовать механизм транслирования:

>>> b
array([[ 0,  1,  2,  3,  4,  5],
       [ 6,  7,  8,  9, 10, 11],
       [12, 13, 14, 15, 16, 17],
       [18, 19, 20, 21, 22, 23],
       [24, 25, 26, 27, 28, 29],
       [30, 31, 32, 33, 34, 35]])
>>> 
>>> x = np.percentile(b, q = 50, axis = 0, keepdims = True)
>>> x
array([[15., 16., 17., 18., 19., 20.]])
>>> 
>>> y = np.percentile(b, q = 50, axis = 1, keepdims = True)
>>> y
array([[ 2.5],
       [ 8.5],
       [14.5],
       [20.5],
       [26.5],
       [32.5]])
>>> 
>>> c = np.zeros((6, 6))
>>> 
>>> c + x
array([[15., 16., 17., 18., 19., 20.],
       [15., 16., 17., 18., 19., 20.],
       [15., 16., 17., 18., 19., 20.],
       [15., 16., 17., 18., 19., 20.],
       [15., 16., 17., 18., 19., 20.],
       [15., 16., 17., 18., 19., 20.]])
>>> 
>>> c + y
array([[ 2.5,  2.5,  2.5,  2.5,  2.5,  2.5],
       [ 8.5,  8.5,  8.5,  8.5,  8.5,  8.5],
       [14.5, 14.5, 14.5, 14.5, 14.5, 14.5],
       [20.5, 20.5, 20.5, 20.5, 20.5, 20.5],
       [26.5, 26.5, 26.5, 26.5, 26.5, 26.5],
       [32.5, 32.5, 32.5, 32.5, 32.5, 32.5]])