Функция quantile NumPy – эффективный расчёт квантилей в Python

Для кого эта статья:

• аналитики данных и разработчики
• студенты и начинающие специалисты в области программирования на Python

• профессионалы, занимающиеся статистикой и анализом данных

  Обработка больших объёмов данных требует эффективных инструментов для извлечения ключевой информации о распределениях. Именно здесь функция quantile из библиотеки NumPy становится незаменимым помощником каждого аналитика и разработчика. Эта мощная функция позволяет мгновенно получить представление о структуре данных, выделить ключевые точки распределения и обнаружить скрытые закономерности — всё это за одну строчку кода! В 2025 году, когда скорость работы с данными критически важна, грамотное использование numpy.quantile() может существенно ускорить ваш рабочий процесс и дать преимущество в конкурентной среде анализа данных. 📊🚀

Освоить функцию numpy.quantile() и другие инструменты для эффективной работы с данными вы сможете на Курсе «Python-разработчик» с нуля от Skypro. На курсе вы не просто изучите синтаксис — вы погрузитесь в практическое применение NumPy, Pandas и других библиотек для анализа данных. Наши студенты уже через 3 месяца решают реальные аналитические задачи и оптимизируют процессы с помощью Python. Присоединяйтесь и станьте экспертом по работе с данными!

Функция quantile NumPy: определение и назначение

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

Функция numpy.quantile() вычисляет квантиль заданного уровня для массива данных. Квантиль уровня q (где q находится в диапазоне от 0 до 1) — это значение, ниже которого лежит доля q всех данных выборки. Например:

• Квантиль 0.5 (или медиана) — значение, ниже которого находится 50% данных
• Квантиль 0.25 (или первый квартиль) — значение, ниже которого находится 25% данных
• Квантиль 0.75 (или третий квартиль) — значение, ниже которого находится 75% данных
• Квантиль 0.99 (или 99-й процентиль) — значение, ниже которого находится 99% данных

Основное преимущество numpy.quantile() заключается в ее векторизованной реализации, которая значительно превосходит по производительности аналогичные функции из стандартной библиотеки Python или даже pandas.

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

Попытка использовать среднее и стандартное отклонение оказалась неудачной из-за асимметричного распределения нагрузки. После безуспешных экспериментов я применил numpy.quantile() для расчета 95-го и 99-го процентилей времени отклика сервера.

Это сработало блестяще — система мониторинга стала точнее определять аномалии, количество ложных срабатываний уменьшилось на 78%, а время обнаружения реальных проблем сократилось в среднем на 12 минут. Самое удивительное, что реализация заняла всего 5 строк кода благодаря эффективности NumPy!

Синтаксис и параметры функции numpy.quantile()

Функция numpy.quantile() имеет гибкий, но интуитивно понятный синтаксис, позволяющий эффективно работать с данными разной структуры. Основная сигнатура функции выглядит следующим образом:

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

Разберём каждый параметр подробно:

• a: входной массив или объект, который можно преобразовать в массив (список, кортеж и т.д.)
• q: квантиль или массив квантилей в диапазоне [0, 1]
• axis: определяет ось (или оси), вдоль которых вычисляются квантили. По умолчанию None, что означает вычисление по всем элементам массива
• out: альтернативный выходной массив для размещения результата
• overwrite_input: если True, то входной массив может быть изменен во время вычислений (повышает эффективность)
• interpolation: метод интерполяции, используемый при вычислении квантилей ('linear', 'lower', 'higher', 'midpoint', 'nearest')
• keepdims: если True, то размерности, сокращенные из-за операции axis, сохраняются в результате с размером 1

Вот несколько примеров использования функции в различных сценариях:

# Базовый пример расчета медианы
import numpy as np

data = np.array([1, 3, 5, 7, 9])
median = np.quantile(data, 0.5) # Результат: 5.0

# Расчет нескольких квантилей одновременно
quartiles = np.quantile(data, [0\.25, 0.5, 0.75]) # [3\., 5., 7.]

# Расчет квантилей по определенной оси многомерного массива
matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
col_medians = np.quantile(matrix, 0.5, axis=0) # [4\., 5., 6.]
row_medians = np.quantile(matrix, 0.5, axis=1) # [2\., 5., 8.]

Параметр axis особенно полезен при работе с многомерными данными. Он позволяет вычислять квантили вдоль определенных измерений массива, что критически важно для задач обработки изображений, временных рядов или табличных данных. 📏

Оптимизация расчётов квантилей с помощью NumPy

Одним из главных преимуществ использования numpy.quantile() является значительное ускорение расчетов по сравнению с чистым Python или даже с некоторыми функциями pandas. Оптимизация достигается благодаря нескольким ключевым особенностям реализации NumPy. 🚀

Векторизация — главный козырь NumPy, позволяющий выполнять операции над целыми массивами данных вместо использования циклов Python. Внутри функции quantile() вычисления проводятся с использованием оптимизированного C-кода, что обеспечивает существенный прирост производительности.

Вот несколько способов оптимизировать работу с квантилями в NumPy:

• Используйте параметр overwrite_input=True для больших массивов, если исходные данные после вычислений не требуются
• Применяйте axis параметр для работы только с нужными измерениями данных
• Вычисляйте несколько квантилей за один проход, передавая массив значений q
• Используйте np.nanquantile() для данных с пропущенными значениями вместо предварительной фильтрации
• Рассмотрите возможность использования np.percentile() (эквивалент, но с процентами от 0 до 100 вместо долей от 0 до 1)

Для иллюстрации преимуществ numpy.quantile() сравним время выполнения с аналогичными решениями:

import numpy as np
import pandas as pd
import statistics
import time
import random

# Создаем большой массив данных
data = np.random.randn(1000000)
data_list = data.tolist()
data_series = pd.Series(data)

# Измеряем время вычисления медианы с NumPy
start = time.time()
np_result = np.quantile(data, 0.5)
np_time = time.time() – start

# Измеряем время вычисления медианы с Pandas
start = time.time()
pd_result = data_series.quantile(0.5)
pd_time = time.time() – start

# Измеряем время вычисления медианы с statistics
start = time.time()
stats_result = statistics.median(data_list)
stats_time = time.time() – start

print(f"NumPy: {np_time:.6f} сек")
print(f"Pandas: {pd_time:.6f} сек")
print(f"Statistics: {stats_time:.6f} сек")

Результаты подобного сравнения на типичном компьютере в 2025 году показывают, что numpy.quantile() может быть до 50-100 раз быстрее стандартной библиотеки Python и в 2-5 раз быстрее pandas для больших объемов данных.

Марина Соколова, технический лид команды ML-инженеров В нашем проекте по прогнозированию нагрузки на электросети мы столкнулись с серьезной проблемой производительности. Нам приходилось обрабатывать телеметрию с миллионами записей в режиме, близком к реальному времени, и вычислять различные статистические показатели для определения аномалий.

Первоначально мы использовали pandas для расчета процентилей, но время обработки было недопустимо большим — около 3.5 секунд на один блок данных. Когда я оптимизировала код с использованием numpy.quantile() с правильно настроенными параметрами, время выполнения упало до 0.2 секунды — улучшение в 17.5 раз!

Но настоящий прорыв произошел, когда мы применили дополнительные оптимизации: предварительное приведение данных к типу float32 вместо float64, использование параметра overwrite_input=True и распараллеливание вычислений по разным измерениям данных. В результате, мы смогли обрабатывать в 30 раз больше данных на том же оборудовании, а наша система стала работать с задержкой всего в 0.12 секунды, что критически важно для обнаружения аварийных ситуаций.

Алгоритмы интерполяции в numpy.quantile()

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

Параметр interpolation в функции numpy.quantile() определяет, как именно будет рассчитано значение квантиля, когда оно попадает между имеющимися значениями в выборке:

import numpy as np
import matplotlib.pyplot as plt

# Создаем небольшой набор данных
data = np.array([1, 3, 5, 7, 9])

# Вычисляем квантиль 0.4 разными методами интерполяции
q_linear = np.quantile(data, 0.4, interpolation='linear')
q_lower = np.quantile(data, 0.4, interpolation='lower')
q_higher = np.quantile(data, 0.4, interpolation='higher')
q_midpoint = np.quantile(data, 0.4, interpolation='midpoint')
q_nearest = np.quantile(data, 0.4, interpolation='nearest')

print(f"linear: {q_linear}") # 3.6 (3 + 0.4*5 = 3 + 2 = 5)
print(f"lower: {q_lower}") # 3.0 (нижнее значение)
print(f"higher: {q_higher}") # 5.0 (верхнее значение)
print(f"midpoint: {q_midpoint}") # 4.0 ((3+5)/2)
print(f"nearest: {q_nearest}") # 3.0 (ближайшее к расчетному индексу)

Каждый метод интерполяции имеет свои особенности:

• linear: линейная интерполяция между соседними рангами. Наиболее распространенный метод, дает плавные результаты
• lower: использует меньшее значение из пары соседних рангов, полезно для консервативных оценок
• higher: использует большее значение из пары соседних рангов, применяется в случаях, когда ошибки недооценки более критичны
• midpoint: вычисляет среднее арифметическое пары соседних рангов, полезно для симметричных распределений
• nearest: выбирает ближайший ранг к расчетному, предпочтительно, когда важно использовать только фактически наблюдаемые значения

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

Математически, процесс вычисления квантиля с интерполяцией можно представить следующим образом. Пусть у нас есть отсортированный массив x длины n, и мы хотим найти q-квантиль:

1. Вычисляем индекс i = q * (n – 1)
2. Если i — целое число, то квантиль равен x[i]
3. Если i — дробное число, разложим его на целую и дробную части: i = k + f, где 0 ≤ f < 1
4. Используем метод интерполяции для вычисления результата на основе x[k] и x[k+1]

В случае линейной интерполяции, которая используется по умолчанию, формула будет следующей:

quantile = x[k] + f * (x[k+1] – x[k])

Где f — дробная часть индекса, а x[k] и x[k+1] — соседние элементы массива.

Практические задачи анализа данных с numpy.quantile()

Функция numpy.quantile() находит широкое применение в различных областях анализа данных. От определения выбросов до создания визуализаций, квантили являются мощным инструментом для понимания структуры данных и принятия решений. Рассмотрим наиболее распространенные практические применения этой функции. 📊

1. Идентификация выбросов с помощью межквартильного размаха (IQR)

import numpy as np

# Генерируем данные с выбросами
data = np.concatenate([np.random.normal(0, 1, 1000), np.array([10, -10, 15, -15])])

# Вычисляем квартили
q1, q3 = np.quantile(data, [0\.25, 0.75])

# Вычисляем межквартильный размах
iqr = q3 – q1

# Определяем границы для выбросов
lower_bound = q1 – 1.5 * iqr
upper_bound = q3 + 1.5 * iqr

# Находим выбросы
outliers = data[(data < lower_bound) | (data > upper_bound)]

print(f"Нижняя граница: {lower_bound}, Верхняя граница: {upper_bound}")
print(f"Обнаружено {len(outliers)} выбросов")

2. Создание ящика с усами (box plot)

import numpy as np
import matplotlib.pyplot as plt

# Генерируем несколько наборов данных
data = [np.random.normal(0, std, 100) for std in [1, 2, 3]]

# Вычисляем квантили для каждого набора
stats = []
for d in data:
q1, q2, q3 = np.quantile(d, [0\.25, 0.5, 0.75])
iqr = q3 – q1
stats.append({
'median': q2,
'q1': q1,
'q3': q3,
'whislo': q1 – 1.5 * iqr,
'whishi': q3 + 1.5 * iqr
})

# Создаем box plot
plt.figure(figsize=(10, 6))
plt.boxplot(data)
plt.title('Box Plot с использованием numpy.quantile()')
plt.ylabel('Значение')
plt.xlabel('Набор данных')
plt.grid(True, linestyle='--', alpha=0.7)
plt.show()

3. Нормализация данных с использованием процентильной шкалы

import numpy as np

# Исходные данные
data = np.random.exponential(size=1000)

# Преобразуем данные в процентильный ранг
def percentile_rank(data, values):
# Вычисляем процентильный ранг для каждого значения в values
result = np.zeros_like(values, dtype=float)
for i, value in enumerate(values):
result[i] = np.sum(data <= value) / len(data) * 100
return result

# Выбираем несколько значений для демонстрации
values = np.quantile(data, [0\.1, 0.25, 0.5, 0.75, 0.9])
ranks = percentile_rank(data, values)

for value, rank in zip(values, ranks):
print(f"Значение {value:.3f} имеет процентильный ранг {rank:.1f}%")

4. Робастное масштабирование данных

import numpy as np

# Генерируем данные с выбросами
data = np.concatenate([np.random.normal(10, 5, 1000), np.array([100, -50, 200])])

# Стандартное масштабирование (подвержено влиянию выбросов)
mean = np.mean(data)
std = np.std(data)
standard_scaled = (data – mean) / std

# Робастное масштабирование на основе квантилей
q1, q3 = np.quantile(data, [0\.25, 0.75])
iqr = q3 – q1
robust_scaled = (data – np.median(data)) / iqr

print(f"Диапазон стандартно масштабированных данных: [{np.min(standard_scaled):.2f}, {np.max(standard_scaled):.2f}]")
print(f"Диапазон робастно масштабированных данных: [{np.min(robust_scaled):.2f}, {np.max(robust_scaled):.2f}]")

5. Вычисление перцентилей для мониторинга производительности

import numpy as np
import time

# Имитируем времена отклика веб-сервера (в миллисекундах)
response_times = np.concatenate([
np.random.normal(50, 10, 950), # Нормальные запросы
np.random.normal(200, 20, 50) # Медленные запросы
])

# Вычисляем ключевые процентили
p50, p90, p95, p99 = np.quantile(response_times, [0\.50, 0.90, 0.95, 0.99])

print("Показатели производительности:")
print(f"Медиана (P50): {p50:.2f} мс")
print(f"90% запросов: {p90:.2f} мс")
print(f"95% запросов: {p95:.2f} мс")
print(f"99% запросов: {p99:.2f} мс")

Хотите развить свои навыки анализа данных и статистических вычислений? Не знаете, в каком направлении двигаться дальше? Пройдите Тест на профориентацию от Skypro и узнайте, какая область в IT подходит именно вам! Тест определит ваши сильные стороны и предрасположенности, поможет понять, стоит ли вам углубляться в анализ данных, машинное обучение или, может быть, в другую перспективную область. Получите персональные рекомендации по развитию карьеры в сфере работы с данными всего за 5 минут!

Функция numpy.quantile() — это не просто математический инструмент, а мощное средство раскрытия истории, которую рассказывают ваши данные. Владея техниками эффективного расчета и интерпретации квантилей, вы получаете возможность видеть сквозь шум и выбросы, принимать взвешенные решения на основе фактов и создавать надежные системы анализа. В эпоху, когда объемы данных растут экспоненциально, умение быстро извлекать ключевые статистические показатели стало незаменимым навыком для каждого специалиста по данным. Используйте мощь NumPy для трансформации необработанных чисел в понятные закономерности, и пусть ваши данные заговорят!