Как найти квантили python

Пост №2 для начинающих посвящен описательным статистикам, группированию данных и нормальному распределению. Все эти сведения заложат основу для дальнейшего анализа электоральных данных. Предыдущий пост см. здесь.

Описательные статистики

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

def ex_1_6():
    '''Число значений в поле "Электорат"'''
    return load_uk_scrubbed()['Electorate'].count()
650

Мы уже очистили столбец, отфильтровав пустые значения (nan) из набора данных, и поэтому предыдущий пример должен вернуть суммарное число избирательных округов.

Описательные статистики, так называемые сводные статистики, представляют собой разные подходы к измерению свойств последовательностей чисел. Они помогают охарактеризовать последовательность и способны выступать в качестве ориентира для дальнейшего анализа. Начнем с двух самых базовых статистик, которые мы можем вычислить из последовательности чисел — ее среднее значение и дисперсию (варианс).

  • Среднее значение

Наиболее распространенный способ усреднить набор данных — взять его среднее значение. Среднее значение на самом деле представляет собой один из нескольких способов измерения центра распределения данных.

x̅=frac{1}{n}sum _{i=1}^nx_i

Среднее значение числового ряда вычисляется на Python следующим образом:

def mean(xs): 
    '''Среднее значение числового ряда'''
    return sum(xs) / len(xs) 

Мы можем воспользоваться нашей новой функцией mean для вычисления среднего числа избирателей в Великобритании:

def ex_1_7():
    '''Вернуть среднее значение поля "Электорат"'''
    return mean( load_uk_scrubbed()['Electorate'] )
70149.94

На самом деле, библиотека pandas уже содержит функцию mean, которая гораздо эффективнее вычисляет среднее значение последовательности. В нашем случае ее можно применить следующим образом:

load_uk_scrubbed()['Electorate'].mean()
  • Медиана

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

def median(xs):
    '''Медиана числового ряда'''
    n = len(xs)
    mid = n // 2
    if n % 2 == 1:
        return sorted(xs)[mid]
    else:
        return mean( sorted(xs)[mid-1:][:2] )

Медианное значение электората Великобритании составляет:

def ex_1_8():
    '''Вернуть медиану поля "Электорат"'''
    return median( load_uk_scrubbed()['Electorate'] )
70813.5

Библиотека pandas тоже располагает встроенной функцией для вычисления медианного значения, которая так и называется median.

  • Дисперсия

Среднее арифметическое и медиана являются двумя альтернативными способами описания среднего значения последовательности, но сами по себе они мало что говорят о содержащихся в ней значениях. Например, если известно, что среднее последовательности из девяноста девяти значений равно 50, то мы почти ничего не скажем о том, какого рода значения последовательность содержит.

Она может содержать целые числа от одного до девяноста девяти либо сорок девять нулей и пятьдесят девяносто девяток, а может быть и так, что она девяносто восемь раз содержит отрицательную единицу и одно число 5048, или же вообще все значения могут быть равны 50.

Дисперсия (варианс) последовательности чисел показывает «разброс» данных вокруг среднего значения. К примеру, данные, приведенные выше, имели бы разную дисперсию. На языке математики дисперсия обозначается следующим образом:

s^2=frac{1}{n}sum _{i=1}^nleft(x_i-x̅right)^2

где s2  — это математический символ, который часто используют для обозначения дисперсии.

Выражение

left(x_i-x̅right)^2

def variance(xs):
    '''Дисперсия (варианс) числового ряда,
       несмещенная дисперсия при n <= 30'''
    mu = mean(xs)
    n = len(xs)
    n = n-1 if n in range(1, 30) else n  
    square_deviation = lambda x : (x - mu) ** 2 
    return sum( map(square_deviation, xs) ) / n

Для вычисления квадрата выражения используется оператор языка Python возведения в степень **.

  • Стандартное отклонение

Поскольку мы взяли средний квадрат отклонения, т.е. получили квадрат отклонения и затем его среднее, то единицы измерения дисперсии (варианса) тоже будут в квадрате, т.е. дисперсия электората Великобритании будет измеряться «людьми в квадрате». Несколько неестественно рассуждать об избирателях в таком виде. Единицу измерения можно привести к более естественному виду, снова обозначающему «людей», путем извлечения квадратного корня из дисперсии (варианса). В результате получим так называемое стандартное отклонение, или среднеквадратичное отклонение:

def standard_deviation(xs):
    '''Стандартное отклонение числового ряда'''
    return sp.sqrt( variance(xs) )
       
def ex_1_9():
    '''Стандартное отклонение поля "Электорат"'''
    return standard_deviation( load_uk_scrubbed()['Electorate'] )
7672.77

В библиотеке pandas функции для вычисления дисперсии (варианса) и стандартного отклонения имплементированы соответственно, как var и std. При этом последняя по умолчанию вычисляет несмещенное значение, поэтому, чтобы получить тот же самый результат, нужно применить именованный аргумент ddof=0, который сообщает, что требуется вычислить смещенное значение стандартного отклонения:

load_uk_scrubbed()['Electorate'].std( ddof=0 )
  • Квантили

Медиана представляет собой один из способов вычислить срединное значение из списка, т.е. находящееся ровно по середине, дисперсия же предоставляет способ измерить разброс данных вокруг среднего значения. Если весь разброс данных представить на шкале от 0 до 1, то значение 0.5 будет медианным.

Для примера рассмотрим следующую ниже последовательность чисел:

[10 11 15 21 22.5 28 30]

Отсортированная последовательность состоит из семи чисел, поэтому медианой является число 21 четвертое в ряду. Его также называют 0.5-квантилем. Мы можем получить более полную картину последовательности чисел, взглянув на 0.0 (нулевой), 0.25, 0.5, 0.75 и 1.0 квантили. Все вместе эти цифры не только показывают медиану, но также обобщают диапазон данных и сообщат о характере распределения чисел внутри него. Они иногда упоминаются в связи с пятичисловой сводкой.

Один из способов составления пятичисловой сводки для данных об электорате Великобритании показан ниже. Квантили можно вычислить непосредственно в pandas при помощи функции quantile. Последовательность требующихся квантилей передается в виде списка.

def ex_1_10():
    '''Вычислить квантили:
       возвращает значение в последовательности xs, 
       соответствующее p-ому проценту'''
    q = [0, 1/4, 1/2, 3/4, 1]
    return load_uk_scrubbed()['Electorate'].quantile(q=q)
0.00     21780.00
0.25     65929.25
0.50     70813.50
0.75     74948.50
1.00    109922.00
Name: Electorate, dtype: float64

Когда квантили делят диапазон на четыре равных диапазона, как показано выше, то они называются квартилями. Разница между нижним (0.25) и верхним (0.75) квартилями называется межквартильным размахом, или иногда сокращенно МКР. Аналогично дисперсии (варианса) вокруг среднего значения, межквартильный размах измеряет разброс данных вокруг медианы.

Группирование данных в корзины

В целях развития интуитивного понимания в отношении того, что именно все эти расчеты разброса значений измеряют, мы можем применить метод под названием группировка в частотные корзины (binning). Когда данные имеют непрерывный характер, использование специального словаря для подсчета частот Counter (подобно тому, как он использовался при подсчете количества пустых значений в наборе данных об электорате) становится нецелесообразным, поскольку никакие два значения не могут быть одинаковыми. Между тем, общее представление о структуре данных можно все-равно получить, сгруппировав для этого данные в частотные корзины (bins).

Процедура образования корзин заключается в разбиении диапазона значений на ряд последовательных, равноразмерных и меньших интервалов. Каждое значение в исходном ряду попадает строго в одну корзину. Подсчитав количества точек, попадающих в каждую корзину, мы можем получить представление о разбросе данных:

На приведенном выше рисунке показано 15 значений x, разбитых на 5 равноразмерных корзин. Подсчитав количество точек, попадающих в каждую корзину, мы можем четко увидеть, что большинство точек попадают в корзину по середине, а меньшинство — в корзины по краям. Следующая ниже функция Python nbin позволяет добиться того же самого результата:

def nbin(n, xs): 
    '''Разбивка данных на частотные корзины'''
    min_x, max_x = min(xs), max(xs)
    range_x = max_x - min_x
    fn = lambda x: min( int((abs(x) - min_x) / range_x * n), n-1 )
    return map(fn, xs)

Например, мы можем разбить диапазон 0-14 на 5 корзин следующим образом:

list( nbin(5, range(15)) )
[0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4]

После того, как мы разбили значения на корзины, мы можем в очередной раз воспользоваться словарем Counter, чтобы подсчитать количество точек в каждой корзине. В следующем ниже примере мы воспользуемся этим словарем для разбиения данных об электорате Великобритании на пять корзин:

def ex_1_11():
    '''Разбиmь электорат Великобритании на 5 корзин'''
    series = load_uk_scrubbed()['Electorate']
    return Counter( nbin(5, series) )
Counter({2: 450, 3: 171, 1: 26, 0: 2, 4: 1})

Количество точек в крайних корзинах (0 и 4) значительно ниже, чем в корзинах в середине — количества, судя по всему, растут по направлению к медиане, а затем снова снижаются. В следующем разделе мы займемся визуализацией формы этих количеств.

Гистограммы

Гистограмма — это один из способов визуализации распределения одной последовательности значений. Гистограммы попросту берут непрерывное распределение, разбивают его на корзины, и изображают частоты точек, попадающих в каждую корзину, в виде столбцов. Высота каждого столбца гистограммы показывает количество точек данных, которые содержатся в этой корзине.

Мы уже увидели, каким образом можно выполнить разбиение данных на корзины самостоятельно, однако в библиотеке pandas уже содержится функция hist, которая разбивает данные и визуализирует их в виде гистограммы.

def ex_1_12():
    '''Построить гистограмму частотных корзин 
       электората Великобритании'''
    load_uk_scrubbed()['Electorate'].hist()
    plt.xlabel('Электорат Великобритании')
    plt.ylabel('Частота')
    plt.show()

Приведенный выше пример сгенерирует следующий ниже график:

Число корзин, на которые данные разбиваются, можно сконфигурировать, передав в функцию при построении гистограммы именованный аргумент bins:

def ex_1_13():
    '''Построить гистограмму частотных корзин 
       электората Великобритании с 200 корзинами'''
    load_uk_scrubbed()['Electorate'].hist(bins=200)
    plt.xlabel('Электорат Великобритании')
    plt.ylabel('Частота')
    plt.show()

Приведенный выше график показывает единственный высокий пик, однако он выражает форму данных довольно грубо. Следующий ниже график показывает мелкие детали, но величина столбцов делает неясной форму распределения, в особенности в хвостах:

При выборе количества корзин для представления данных следует найти точку равновесия — с малым количеством корзин форма данных будет представлена лишь приблизительно, а слишком большое их число приведет к тому, что шумовые признаки могут заслонить лежащую в основании структуру.

def ex_1_14():
    '''Построить гистограмму частотных корзин 
       электората Великобритании с 20 корзинами'''
    load_uk_scrubbed()['Electorate'].hist(bins=20)
    plt.xlabel('Электорат Великобритании')
    plt.ylabel('Частота')
    plt.show()

Ниже показана гистограмма теперь уже из 20 корзин:

Окончательный график, состоящий из 20 корзин, судя по всему, пока лучше всего представляет эти данные.

Наряду со средним значением и медианой, есть еще один способ измерить среднюю величину последовательности. Это мода. Мода — это значение, встречающееся в последовательности наиболее часто. Она определена исключительно только для последовательностей, имеющих по меньшей мере одно дублирующее значение; во многих статистических распределениях это не так, и поэтому для них мода не определена. Тем не менее, пик гистограммы часто называют модой, поскольку он соответствует наиболее распространенной корзине.

Из графика ясно видно, что распределение вполне симметрично относительно моды, и его значения резко падают по обе стороны от нее вдоль тонких хвостов. Эти данные приближенно подчиняются нормальному распределению.

Нормальное распределение

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

Распределение названо нормальным распределением из-за того, что оно очень часто встречается в природе. Галилей заметил, что ошибки в его астрономических измерениях подчинялись распределению, где малые отклонения от среднего значения встречались чаще, чем большие. Вклад великого математика Гаусса в описание математической формы этих ошибок привел к тому, что это распределение стали называть в его честь распределением Гаусса.

Любое распределение похоже на алгоритм сжатия: оно позволяет очень эффективно резюмировать потенциально большой объем данных. Нормальное распределение требует только два параметра, исходя из которых можно аппроксимировать остальные данные. Это среднее значение и стандартное отклонение.

Центральная предельная теорема

Высокая встречаемость нормального распределения отчасти объясняется центральной предельной теоремой. Дело в том, что значения, полученные из разнообразных статистических распределений, при определенных обстоятельствах имеют тенденцию сходиться к нормальному распределению, и мы это покажем далее.

В программировании типичным распределением является равномерное распределение. Оно представлено распределением чисел, генерируемых функцией библиотеки scipy stats.uniform.rvs: в справедливом генераторе случайных чисел все числа имеют равные шансы быть сгенерированными. Мы можем увидеть это на гистограмме, многократно генерируя серию случайных чисел между 0 и 1 и затем построив график с результатами.

def ex_1_15():
    '''Показать гистограмму равномерного распределения 
       синтетического набора данных'''
    xs = stats.uniform.rvs(0, 1, 10000)
    pd.Series(xs).hist(bins=20)
    plt.xlabel('Равномерное распределение')
    plt.ylabel('Частота')
    plt.show()

Обратите внимание, что в этом примере мы впервые использовали тип Series библиотеки pandas для числового ряда данных.

Приведенный выше пример создаст следующую гистограмму:

Каждый столбец гистограммы имеет примерно одинаковую высоту, что соответствует равновероятности генерирования числа, которое попадает в каждую корзину. Столбцы имеют не совсем одинаковую высоту, потому что равномерное распределение описывает теоретический результат, который наша случайная выборка не может отразить в точности. Раздел инференциальной статистики, посвященный проверке статистических гипотез, изучает способы точной количественной оценки расхождения между теорией и практикой, чтобы определить, являются ли расхождения достаточно большими, чтобы обратить на это внимание. В данном случае они таковыми не являются.

Если напротив сгенерировать гистограмму средних значений последовательностей чисел, то в результате получится распределение, которое выглядит совсем непохоже.

def bootstrap(xs, n, replace=True): 
    '''Вернуть список массивов меньших размеров 
       по n элементов каждый'''
    return np.random.choice(xs, (len(xs), n), replace=replace) 

def ex_1_16():
    '''Построить гистограмму средних значений'''
    xs = stats.uniform.rvs(loc=0, scale=1, size=10000)
    pd.Series( map(sp.mean, bootstrap(xs, 10)) ).hist(bins=20)
    plt.xlabel('Распределение средних значений') 
    plt.ylabel('Частота')
    plt.show()

Приведенный выше пример сгенерирует результат, аналогичный следующей ниже гистограмме:

Хотя величина среднего значения близкая к 0 или 1 не является невозможной, она является чрезвычайно невероятной и становится менее вероятной по мере роста числа усредненных чисел и числа выборочных средних. Фактически, на выходе получается результат очень близкий к нормальному распределению.

Этот результат, когда средний эффект множества мелких случайных колебаний в итоге приводит к нормальному распределению, называется центральной предельной теоремой, иногда сокращенно ЦПТ, и играет важную роль для объяснения, почему нормальное распределение встречается так часто в природных явлениях.

До 20-ого века самого термина еще не существовало, хотя этот эффект был зафиксирован еще в 1733 г. французским математиком Абрахамом де Mуавром, который использовал нормальное распределение, чтобы аппроксимировать число орлов в результате бросания уравновешенной монеты. Исход бросков монеты лучше всего моделировать при помощи биномиального распределения. В отличие от центральной предельной теоремы, которая позволяет получать выборки из приближенно нормального распределения, библиотека scipy содержит функции для эффективного генерирования выборок из самых разнообразных статистических распределений, включая нормальное:

def ex_1_17():
    '''Показать гистограмму нормального распределения 
       синтетического набора данных'''
    xs = stats.norm.rvs(loc=0, scale=1, size=10000)
    pd.Series(xs).hist(bins=20)
    plt.xlabel('Нормальное распределение')
    plt.ylabel('Частота')
    plt.show()

Отметим, что в функции sp.random.normal параметр loc – это среднее значение, scale – дисперсия и size – размер выборки. Приведенный выше пример сгенерирует следующую гистограмму нормального распределения:

По умолчанию среднее значение и стандартное отклонение для получения нормального распределения равны соответственно 0 и 1.

Примеры исходного кода для этого поста находятся в моем репо на Github. Все исходные данные взяты в репозитории автора книги.

Следующая часть, часть 3, серии постов «Python, исследование данных и выборы» посвящена генерированию распределений, их свойствам, а также графикам для их сопоставительного анализа

Quantile in Python (4 Examples)

In this tutorial you’ll learn how to get quantiles of a list or a pandas DataFrame column in Python programming.

The tutorial contains these contents:

Let’s get started:

Example 1: Quantiles of List Object

In this example, I’ll show how to calculate the quantiles of a list object in Python.

Let’s first create an example list:

my_list = [8, 4, 4, 3, 2, 4, 1, 3, 5, 2, 1, 3, 7]             # Create example list
print(my_list)                                                # Print example list
# [8, 4, 4, 3, 2, 4, 1, 3, 5, 2, 1, 3, 7]

Furthermore, we have to import the NumPy library:

import numpy as np                                            # Load NumPy library

Now, we can use the quantile function of the NumPy package to create different types of quantiles in Python.

The following syntax returns the quartiles of our list object. Note that we are using the arange function within the quantile function to specify the sequence of quantiles to compute. Since we want to find the quartiles of our list, we have to specify a sequence containing the values 0.25, 0.5, and 0.75:

print(np.quantile(my_list, q = np.arange(0.25, 1, 0.25)))     # Get quartiles of list
# [2. 3. 4.]

As you can see, the values 2, 3, and 4 have been printed (i.e. the first second and third quartile).

We can modify the sequence within the quantile function to get other kinds of quantiles. The following Python code prints the deciles…

print(np.quantile(my_list, q = np.arange(0.1, 1, 0.1)))       # Get deciles of list
# [1.2 2.  2.6 3.  3.  4.  4.  4.6 6.6]

…and the Python syntax below returns the percentiles of our list:

print(np.quantile(my_list, q = np.arange(0.01, 1, 0.01)))     # Get percentiles of list
# [1.   1.   1.   1.   1.   1.   1.   1.   1.08 1.2  1.32 1.44 1.56 1.68
#  1.8  1.92 2.   2.   2.   2.   2.   2.   2.   2.   2.   2.12 2.24 2.36
#  2.48 2.6  2.72 2.84 2.96 3.   3.   3.   3.   3.   3.   3.   3.   3.
#  3.   3.   3.   3.   3.   3.   3.   3.   3.12 3.24 3.36 3.48 3.6  3.72
#  3.84 3.96 4.   4.   4.   4.   4.   4.   4.   4.   4.   4.   4.   4.
#  4.   4.   4.   4.   4.   4.12 4.24 4.36 4.48 4.6  4.72 4.84 4.96 5.16
#  5.4  5.64 5.88 6.12 6.36 6.6  6.84 7.04 7.16 7.28 7.4  7.52 7.64 7.76
#  7.88]

Note that we could use the same logic to return other kinds of quantile values such as terciles, quintiles, sextiles, septiles, octiles, duodeciles, vigintiles, and permilles.

Example 2: Quantiles of One Particular Column in pandas DataFrame

In this example, I’ll demonstrate how to get the quantiles of a specific column in a pandas DataFrame.

First, we have to import the pandas library:

import pandas as pd                                           # Load pandas library

Also, we have to create an exemplifying pandas DataFrame:

data = pd.DataFrame({'x1':[6, 2, 7, 3, 1, 4, 3, 4, 8, 7, 5],  # Create pandas DataFrame
                     'x2':range(10, 21),
                     'group':['A', 'B', 'B', 'C', 'A', 'B', 'A', 'C', 'B', 'B', 'A']})
print(data)                                                   # Print pandas DataFrame

table 1 DataFrame quantile python programming language

After running the previous code the pandas DataFrame shown in Table 1 has been created. It contains the two float variables x1 and x2 as well as a group indicator.

If we want to find the quartiles of a certain variable in our data set (i.e. x1), we can use the following Python code:

print(data['x1'].quantile(np.arange(0.25, 1, 0.25)))          # Get quartiles of one column
# 0.25    3.0
# 0.50    4.0
# 0.75    6.5
# Name: x1, dtype: float64

Similar to that, we can calculate the deciles…

print(data['x1'].quantile(np.arange(0.1, 1, 0.1)))            # Get deciles of one column
# 0.1    2.0
# 0.2    3.0
# 0.3    3.0
# 0.4    4.0
# 0.5    4.0
# 0.6    5.0
# 0.7    6.0
# 0.8    7.0
# 0.9    7.0
# Name: x1, dtype: float64

…and the percentiles of a pandas DataFrame column:

print(data['x1'].quantile(np.arange(0.01, 1, 0.01)))          # Get percentiles of one column
# 0.01    1.1
# 0.02    1.2
# 0.03    1.3
# 0.04    1.4
# 0.05    1.5
         ...
# 0.95    7.5
# 0.96    7.6
# 0.97    7.7
# 0.98    7.8
# 0.99    7.9
# Name: x1, Length: 99, dtype: float64

Example 3: Quantiles of All Columns in pandas DataFrame

In the previous example, I have illustrated how to return the quantiles of a single pandas DataFrame column.

In this section, I’ll explain how to return the quantiles of all pandas DataFrame columns in one single call of the quantile function.

For this task, we can use the Python code below:

print(data.quantile(np.arange(0.25, 1, 0.25)))                # Get quartiles of all columns
#        x1    x2
# 0.25  3.0  12.5
# 0.50  4.0  15.0
# 0.75  6.5  17.5

The previous output shows the quartiles for each column in our data set.

Example 4: Quantiles by Group in pandas DataFrame

In Example 4, I’ll demonstrate how to calculate quantile values by group.

To accomplish this, we have to separate our data using the groupby function as shown below. Note that we have specified only one value (i.e. 0.25) within the quantile function to return only the first quartile by group.

print(data.groupby('group').quantile(0.25))                   # Get first quartiles by group
#          x1    x2
# group            
# A      2.50  13.0
# B      4.00  12.0
# C      3.25  14.0

Video, Further Resources & Summary

Would you like to know more about the computation of quantiles of a list and a pandas DataFrame column? Then I can recommend having a look at the following video on my YouTube channel. In the video, I’m explaining the contents of this article.

In addition, you could read the related articles on this website. A selection of tutorials is listed here.

  • Quantile by Group in Python
  • Quantile of NumPy Array in Python
  • Percentiles & Deciles of NumPy Array
  • Percentile & Decile in Python
  • Summary Statistics by Group of pandas DataFrame
  • Summary Statistics of pandas DataFrame
  • Basic Course for the pandas Library in Python
  • All Python Programming Tutorials

Summary: In this Python programming tutorial you have learned how to calculate quantiles. If you have any further questions, let me know in the comments.

numpy.quantile(a, q, axis=None, out=None, overwrite_input=False, method=‘linear’, keepdims=False, *, interpolation=None)[source]#

Compute the q-th quantile of the data along the specified axis.

New in version 1.15.0.

Parameters:
aarray_like

Input array or object that can be converted to an array.

qarray_like of float

Quantile or sequence of quantiles to compute, which must be between
0 and 1 inclusive.

axis{int, tuple of int, None}, optional

Axis or axes along which the quantiles are computed. The default is
to compute the quantile(s) along a flattened version of the array.

outndarray, optional

Alternative output array in which to place the result. It must have
the same shape and buffer length as the expected output, but the
type (of the output) will be cast if necessary.

overwrite_inputbool, optional

If True, then allow the input array a to be modified by
intermediate calculations, to save memory. In this case, the
contents of the input a after this function completes is
undefined.

methodstr, optional

This parameter specifies the method to use for estimating the
quantile. There are many different methods, some unique to NumPy.
See the notes for explanation. The options sorted by their R type
as summarized in the H&F paper [1] are:

  1. ‘inverted_cdf’

  2. ‘averaged_inverted_cdf’

  3. ‘closest_observation’

  4. ‘interpolated_inverted_cdf’

  5. ‘hazen’

  6. ‘weibull’

  7. ‘linear’ (default)

  8. ‘median_unbiased’

  9. ‘normal_unbiased’

The first three methods are discontinuous. NumPy further defines the
following discontinuous variations of the default ‘linear’ (7.) option:

  • ‘lower’

  • ‘higher’,

  • ‘midpoint’

  • ‘nearest’

Changed in version 1.22.0: This argument was previously called “interpolation” and only
offered the “linear” default and last four options.

keepdimsbool, optional

If this is set to True, the axes which are reduced are left in
the result as dimensions with size one. With this option, the
result will broadcast correctly against the original array a.

interpolationstr, optional

Deprecated name for the method keyword argument.

Deprecated since version 1.22.0.

Returns:
quantilescalar or ndarray

If q is a single quantile and axis=None, then the result
is a scalar. If multiple quantiles are given, first axis of
the result corresponds to the quantiles. The other axes are
the axes that remain after the reduction of a. If the input
contains integers or floats smaller than float64, the output
data-type is float64. Otherwise, the output data-type is the
same as that of the input. If out is specified, that array is
returned instead.

Notes

Given a vector V of length n, the q-th quantile of V is
the value q of the way from the minimum to the maximum in a
sorted copy of V. The values and distances of the two nearest
neighbors as well as the method parameter will determine the
quantile if the normalized ranking does not match the location of
q exactly. This function is the same as the median if q=0.5, the
same as the minimum if q=0.0 and the same as the maximum if
q=1.0.

The optional method parameter specifies the method to use when the
desired quantile lies between two indexes i and j = i + 1.
In that case, we first determine i + g, a virtual index that lies
between i and j, where i is the floor and g is the
fractional part of the index. The final result is, then, an interpolation
of a[i] and a[j] based on g. During the computation of g,
i and j are modified using correction constants alpha and
beta whose choices depend on the method used. Finally, note that
since Python uses 0-based indexing, the code subtracts another 1 from the
index internally.

The following formula determines the virtual index i + g, the location
of the quantile in the sorted sample:

[i + g = q * ( n — alpha — beta + 1 ) + alpha]

The different methods then work as follows

inverted_cdf:

method 1 of H&F [1].
This method gives discontinuous results:

  • if g > 0 ; then take j

  • if g = 0 ; then take i

averaged_inverted_cdf:

method 2 of H&F [1].
This method gives discontinuous results:

  • if g > 0 ; then take j

  • if g = 0 ; then average between bounds

closest_observation:

method 3 of H&F [1].
This method gives discontinuous results:

  • if g > 0 ; then take j

  • if g = 0 and index is odd ; then take j

  • if g = 0 and index is even ; then take i

interpolated_inverted_cdf:

method 4 of H&F [1].
This method gives continuous results using:

  • alpha = 0

  • beta = 1

hazen:

method 5 of H&F [1].
This method gives continuous results using:

  • alpha = 1/2

  • beta = 1/2

weibull:

method 6 of H&F [1].
This method gives continuous results using:

  • alpha = 0

  • beta = 0

linear:

method 7 of H&F [1].
This method gives continuous results using:

  • alpha = 1

  • beta = 1

median_unbiased:

method 8 of H&F [1].
This method is probably the best method if the sample
distribution function is unknown (see reference).
This method gives continuous results using:

  • alpha = 1/3

  • beta = 1/3

normal_unbiased:

method 9 of H&F [1].
This method is probably the best method if the sample
distribution function is known to be normal.
This method gives continuous results using:

  • alpha = 3/8

  • beta = 3/8

lower:

NumPy method kept for backwards compatibility.
Takes i as the interpolation point.

higher:

NumPy method kept for backwards compatibility.
Takes j as the interpolation point.

nearest:

NumPy method kept for backwards compatibility.
Takes i or j, whichever is nearest.

midpoint:

NumPy method kept for backwards compatibility.
Uses (i + j) / 2.

References

[1]
(1,2,3,4,5,6,7,8,9,10)

R. J. Hyndman and Y. Fan,
“Sample quantiles in statistical packages,”
The American Statistician, 50(4), pp. 361-365, 1996

Examples

>>> a = np.array([[10, 7, 4], [3, 2, 1]])
>>> a
array([[10,  7,  4],
       [ 3,  2,  1]])
>>> np.quantile(a, 0.5)
3.5
>>> np.quantile(a, 0.5, axis=0)
array([6.5, 4.5, 2.5])
>>> np.quantile(a, 0.5, axis=1)
array([7.,  2.])
>>> np.quantile(a, 0.5, axis=1, keepdims=True)
array([[7.],
       [2.]])
>>> m = np.quantile(a, 0.5, axis=0)
>>> out = np.zeros_like(m)
>>> np.quantile(a, 0.5, axis=0, out=out)
array([6.5, 4.5, 2.5])
>>> m
array([6.5, 4.5, 2.5])
>>> b = a.copy()
>>> np.quantile(b, 0.5, axis=1, overwrite_input=True)
array([7.,  2.])
>>> assert not np.all(a == b)

See also numpy.percentile for a visualization of most methods.

Improve Article

Save Article

Like Article

  • Read
  • Discuss
  • Improve Article

    Save Article

    Like Article

    numpy.quantile(arr, q, axis = None) : Compute the qth quantile of the given data (array elements) along the specified axis. Quantile plays a very important role in Statistics when one deals with the Normal Distribution. In the figure given above, Q2 is the median of the normally distributed data. Q3 – Q2 represents the Interquartile Range of the given dataset.

    Parameters : arr : [array_like]input array. q : quantile value. axis : [int or tuples of int]axis along which we want to calculate the quantile value. Otherwise, it will consider arr to be flattened(works on all the axis). axis = 0 means along the column and axis = 1 means working along the row. out : [ndarray, optional]Different array in which we want to place the result. The array must have same dimensions as expected output. Results : qth quantile of the array (a scalar value if axis is none) or array with quantile values along specified axis.

    Code #1: 

    Python3

    import numpy as np

    arr = [20, 2, 7, 1, 34]

    print("arr : ", arr)

    print("Q2 quantile of arr : ", np.quantile(arr, .50))

    print("Q1 quantile of arr : ", np.quantile(arr, .25))

    print("Q3 quantile of arr : ", np.quantile(arr, .75))

    print("100th quantile of arr : ", np.quantile(arr, .1))

    Output : 

    arr : [20, 2, 7, 1, 34]
    Q2 quantile of arr : 7.0)
    Q1 quantile of arr : 2.0)
    Q3 quantile of arr : 20.0)
    100th quantile of arr : 1.4)

      Code #2: 

    Python3

    import numpy as np

    arr = [[14, 17, 12, 33, 44], 

           [15, 6, 27, 8, 19],

           [23, 2, 54, 1, 4, ]]

    print("narr : n", arr)

    print("n50th quantile of arr, axis = None : ", np.quantile(arr, .50))

    print("0th quantile of arr, axis = None : ", np.quantile(arr, 0))

    print("n50th quantile of arr, axis = 0 : ", np.quantile(arr, .25, axis = 0))

    print("0th quantile of arr, axis = 0 : ", np.quantile(arr, 0, axis = 0))

    print("n50th quantile of arr, axis = 1 : ", np.quantile(arr, .50, axis = 1))

    print("0th quantile of arr, axis = 1 : ", np.quantile(arr, 0, axis = 1))

    print("n0th quantile of arr, axis = 1 : n",

       np.quantile(arr, .50, axis = 1, keepdims = True))

    print("n0th quantile of arr, axis = 1 : n",

       np.quantile(arr, 0, axis = 1, keepdims = True))

    Output : 

    arr : 
    [[14, 17, 12, 33, 44], [15, 6, 27, 8, 19], [23, 2, 54, 1, 4]]
    
    50th quantile of arr, axis = None : 15.0
    0th quantile of arr, axis = None : 1)
    
    50th quantile of arr, axis = 0 : [14.5  4.  19.5  4.5 11.5]
    0th quantile of arr, axis = 0 : [14  2 12  1  4]
    
    50th quantile of arr, axis = 1 : [17. 15.  4.]
    0th quantile of arr, axis = 1 : [12  6  1]
    
    0th quantile of arr, axis = 1 : 
    [[17.]
    [15.]
    [ 4.]]
    
    0th quantile of arr, axis = 1 : 
    [[12]
    [ 6]
    [ 1]]

    Last Updated :
    09 Aug, 2022

    Like Article

    Save Article

    • Редакция Кодкампа

    17 авг. 2022 г.
    читать 1 мин


    Вы можете использовать следующий базовый синтаксис для вычисления квантилей по группам в Pandas:

    df.groupby('grouping_variable'). quantile ( .5 )
    

    В следующих примерах показано, как использовать этот синтаксис на практике.

    Пример 1: Расчет квантиля по группе

    Предположим, у нас есть следующие Pandas DataFrame:

    import pandas as pd
    
    #create DataFrame 
    df = pd.DataFrame({'team': [1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2],
     'score': [3, 4, 4, 5, 5, 8, 1, 2, 2, 3, 3, 5]})
    
    #view first five rows
    df.head ()
    
    team score
    0 1 3
    1 1 4
    2 1 4
    3 1 5
    4 1 5
    

    В следующем коде показано, как вычислить 90-й процентиль значений в столбце «Очки», сгруппированных по столбцу «Команда»:

    df.groupby('team'). quantile ( .90 )
    
     score
    team 
    1 6.5
    2 4.0
    

    Вот как интерпретировать вывод:

    • 90-й процентиль «очков» для команды 1 равен 6,5 .
    • 90-й процентиль «очков» для команды 2 равен 4,0 .

    Пример 2. Расчет нескольких квантилей по группам

    Следующий код показывает, как вычислить сразу несколько квантилей по группам:

    import pandas as pd
    
    #create DataFrame
    df = pd.DataFrame({'team': [1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2],
     'score': [3, 4, 4, 5, 5, 8, 1, 2, 2, 3, 3, 5]})
    
    #create functions to calculate 1st and 3rd quartiles
    def q1(x):
     return x. quantile ( 0.25 )
    
    def q3(x):
     return x. quantile ( 0.75 )
    
    #calculate 1st and 3rd quartiles by group
    vals = {' score': [q1, q3]}
    
    df.groupby('team').agg(vals)
    
     score
     q1 q3
    team 
    1 4.0 5.0
    2 2.0 3.0
    

    Вот как интерпретировать вывод:

    • Первый и третий квартиль баллов для команды 1 составляют 4,0 и 5,0 соответственно.
    • Первая и третья квартиль очков для команды 2 составляют 2,0 и 3,0 соответственно.

    Дополнительные ресурсы

    В следующих руководствах объясняется, как выполнять другие распространенные функции в pandas:

    Как найти максимальное значение по группе в Pandas
    Как подсчитать наблюдения по группе в Pandas
    Как рассчитать среднее значение столбцов в Pandas

    Понравилась статья? Поделить с друзьями:

    Не пропустите также:

  • Как найти рецепт пиццы в геншине
  • Как составить код расходов бюджетов
  • Как найти звуковую плату на материнской
  • Как составить тест на модуле
  • Если котенок потерялся как его найти

  • 0 0 голоса
    Рейтинг статьи
    Подписаться
    Уведомить о
    guest

    0 комментариев
    Старые
    Новые Популярные
    Межтекстовые Отзывы
    Посмотреть все комментарии