Как подсчитать пропущенные значения (NaN) в таблице pandas: 3 метода

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

• Дата-аналитики и специалисты по обработке данных
• Студенты и начинающие аналитики данных, изучающие работу с pandas

• Руководители проектов и профессионалы, занимающиеся качеством данных и машинным обучением

  Работа с данными подобна поиску золотых самородков среди тонн породы — ценность имеет лишь то, что можно использовать. Пропущенные значения (NaN) в DataFrame — это те самые камни, которые могут исказить результаты вашего анализа, если их правильно не обработать. Точный подсчёт NaN-значений — первый шаг к качественной предобработке данных и повышению достоверности аналитики. В этой статье я расскажу о трёх проверенных методах, которые помогут вам эффективно выявлять и считать пропущенные данные в pandas, даже если вы работаете с огромными датасетами. 📊

Хотите превратить разрозненные знания о работе с данными в системную профессию? На курсе Профессия аналитик данных от Skypro вы освоите не только базовые методы обработки данных в pandas, включая работу с пропущенными значениями, но и продвинутые инструменты аналитики. Реальные проекты с ментором помогут вам закрепить навыки и собрать портфолио еще до окончания обучения.

Что такое NaN и почему важно их считать в DataFrame

NaN (Not a Number) — специальное значение в pandas и NumPy, представляющее отсутствующие или недействительные данные. Пропущенные значения могут появляться в наборах данных по различным причинам: ошибки при сборе, неполные записи, проблемы с импортом или намеренное исключение значений.

Подсчет и анализ NaN в DataFrame критически важен по нескольким причинам:

• Оценка качества данных — высокий процент пропусков может указывать на проблемы в процессе сбора данных
• Влияние на статистические расчеты — NaN искажают средние значения, медианы и другие метрики
• Выбор стратегии обработки — в зависимости от количества и паттернов пропусков применяются различные методы заполнения
• Требования алгоритмов ML — большинство моделей машинного обучения не работают с пропущенными значениями

Алексей Петров, ведущий дата-аналитик

Однажды мне пришлось анализировать датасет продаж крупной розничной сети. На первый взгляд, данные выглядели полными и корректными. Но когда я запустил предварительный анализ, выяснилось, что в столбце с ценами товаров 18% значений были пропущены! Если бы я просто удалил эти строки, мы бы потеряли данные почти по пятой части всех транзакций. Вместо этого я написал скрипт для подробного анализа паттернов пропусков и обнаружил, что NaN появлялись только для определенной категории товаров в конкретных магазинах. Оказалось, что у этих магазинов была другая система учета, и данные о ценах хранились в отдельной таблице. После объединения таблиц проблема была решена, и мы получили полный набор данных. Этот случай научил меня всегда начинать анализ с тщательного изучения пропущенных значений.

Важно понимать, что NaN — это не то же самое, что пустая строка, нуль или значение None в Python. Pandas обрабатывает эти значения по-разному, и методы, которые мы рассмотрим, специально предназначены для работы именно с NaN.

Теперь рассмотрим первый и наиболее распространенный метод подсчета NaN в столбце DataFrame.

Метод isna().sum() для подсчета NaN в столбце pandas

Метод isna().sum() является наиболее распространенным и эффективным способом подсчета пропущенных значений в столбце DataFrame. Он работает в два этапа:

1. isna() создает булеву маску, где True соответствует NaN-значениям
2. sum() суммирует все True значения (каждое True равно 1), давая итоговое количество NaN

Вот как выглядит базовое использование:

import pandas as pd
import numpy as np

# Создаем тестовый DataFrame
df = pd.DataFrame({
'A': [1, 2, np.nan, 4, np.nan],
'B': [5, np.nan, np.nan, 8, 9],
'C': [10, 11, 12, 13, 14]
})

# Подсчет NaN в столбце 'A'
nan_count_a = df['A'].isna().sum()
print(f"Количество NaN в столбце 'A': {nan_count_a}") # Выведет: 2

# Подсчет NaN в столбце 'B'
nan_count_b = df['B'].isna().sum()
print(f"Количество NaN в столбце 'B': {nan_count_b}") # Выведет: 2

# Подсчет NaN в столбце 'C'
nan_count_c = df['C'].isna().sum()
print(f"Количество NaN в столбце 'C': {nan_count_c}") # Выведет: 0

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

• Подсчитать количество NaN во всем DataFrame: df.isna().sum().sum()
• Получить процент пропущенных значений: df['A'].isna().mean() * 100
• Создать фильтр для строк с пропущенными значениями: df[df['A'].isna()]

Для более сложных случаев, вы можете комбинировать isna() с другими методами pandas:

# Подсчет NaN в каждом столбце
nan_counts = df.isna().sum()
print("Количество NaN по столбцам:")
print(nan_counts)

# Подсчет строк, где есть хотя бы один NaN
rows_with_nan = df.isna().any(axis=1).sum()
print(f"Количество строк с хотя бы одним NaN: {rows_with_nan}")

# Процент пропущенных значений в каждом столбце
nan_percentage = (df.isna().sum() / len(df)) * 100
print("Процент пропущенных значений по столбцам:")
print(nan_percentage)

Этот метод является стандартным в сообществе дата-аналитиков и обеспечивает хороший баланс между читаемостью кода и производительностью. 🚀

Использование isnull().sum() для определения пропусков

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

# Подсчет NaN в столбце 'A' с использованием isnull()
nan_count_a = df['A'].isnull().sum()
print(f"Количество NaN в столбце 'A': {nan_count_a}") # Выведет: 2

# Подсчет NaN во всем DataFrame
total_nan = df.isnull().sum().sum()
print(f"Общее количество NaN в DataFrame: {total_nan}") # Выведет: 4

Метод isnull() имеет те же возможности, что и isna(), включая:

• Создание булевой маски для фильтрации данных
• Комбинирование с другими методами для детального анализа пропущенных значений
• Работа как с отдельными столбцами, так и с целым DataFrame

Мария Соколова, руководитель отдела аналитики

В нашем проекте мы анализировали данные опроса клиентов, содержащего более 50 вопросов. Когда мы начали обрабатывать результаты, столкнулись с серьезной проблемой — некоторые ответы отсутствовали, но мы не знали точно, насколько существенной была эта проблема. Я написала небольшую функцию, использующую isnull().sum() для визуализации паттернов пропусков:

Python

Скопировать код

def analyze_missing_values(df):
missing = df.isnull().sum()
missing_percent = (missing / len(df)) * 100
missing_data = pd.concat([missing, missing_percent], axis=1)
missing_data.columns = ['Missing Values', 'Percentage']
return missing_data.sort_values('Percentage', ascending=False)

Результаты показали, что вопросы во второй половине опроса имели намного больше пропусков (до 40%), чем в первой (менее 5%). Это позволило нам выявить проблему с длиной опроса — люди просто не доходили до конца. На основе этого анализа мы сократили количество вопросов и изменили их порядок, поставив наиболее важные в начало. В следующем опросе процент пропусков снизился до 7% по всем вопросам, а качество данных значительно улучшилось.

Интересно отметить, что исторически в pandas существовало некоторое различие между isna() и isnull(), однако в современных версиях библиотеки они полностью эквивалентны. Вы можете проверить это, изучив исходный код pandas:

# Проверяем эквивалентность методов
print(pd.Series.isna is pd.Series.isnull) # Выведет: True

Выбирая между isna() и isnull(), руководствуйтесь следующими соображениями:

В общем случае, isna() считается более предпочтительным в современной разработке, поскольку его название лучше отражает функциональность — проверку на "is NA" (Not Available), что включает не только числовые NaN, но и None. 📈

Альтернативный способ через value_counts() и pd.isna()

Хотя isna().sum() и isnull().sum() являются стандартными методами для подсчета NaN, существует еще один интересный подход с использованием value_counts() в сочетании с pd.isna(). Этот метод особенно полезен, когда вам нужен не только подсчет пропущенных значений, но и более полная картина распределения всех значений в столбце.

# Подсчет NaN с использованием value_counts() и dropna=False
nan_count_a = df['A'].value_counts(dropna=False).get(np.nan, 0)
print(f"Количество NaN в столбце 'A': {nan_count_a}") # Выведет: 2

# Или более прямолинейный способ с использованием pd.isna()
nan_count_with_isna = df['A'][pd.isna(df['A'])].count()
print(f"Количество NaN в столбце 'A' (с pd.isna): {nan_count_with_isna}") # Выведет: 2

Метод value_counts() по умолчанию игнорирует NaN значения, поэтому важно передать параметр dropna=False, чтобы включить их в подсчет. Затем мы используем get(np.nan, 0), чтобы получить количество NaN значений, или 0, если таковых нет.

Этот подход имеет несколько преимуществ:

• Позволяет одновременно видеть распределение всех значений, включая NaN
• Удобен для последующего визуального анализа данных
• Может быть использован для более сложных сценариев анализа

Вот пример расширенного использования этого метода:

# Получаем полное распределение значений, включая NaN
distribution = df['A'].value_counts(dropna=False)
print("Распределение значений в столбце 'A':")
print(distribution)

# Вычисляем процентное соотношение NaN к общему количеству значений
total_values = len(df['A'])
nan_values = distribution.get(np.nan, 0)
nan_percentage = (nan_values / total_values) * 100
print(f"Процент NaN в столбце 'A': {nan_percentage:.2f}%")

# Создаем функцию для комплексного анализа пропущенных значений
def analyze_column_with_nans(df, column):
values = df[column].value_counts(dropna=False)
nan_count = values.get(np.nan, 0)
total = len(df[column])
return {
'total_values': total,
'nan_count': nan_count,
'nan_percentage': (nan_count / total) * 100,
'value_distribution': values
}

# Применяем функцию к столбцу 'B'
analysis_b = analyze_column_with_nans(df, 'B')
print(f"Анализ столбца 'B': {analysis_b['nan_count']} NaN ({analysis_b['nan_percentage']:.2f}%)")

Альтернативный подход с использованием pd.isna() также имеет свои преимущества:

• Более эксплицитный и читаемый для других разработчиков
• Позволяет легко комбинировать с другими условиями фильтрации
• Удобен для создания сложных масок выбора данных

Например, вы можете использовать pd.isna() для более сложных операций:

# Выбираем строки, где в столбце 'A' есть NaN, а в столбце 'B' нет
filtered_rows = df[pd.isna(df['A']) & ~pd.isna(df['B'])]
print("Строки с NaN в 'A', но без NaN в 'B':")
print(filtered_rows)

# Подсчитываем NaN только для определенного подмножества данных
subset = df[df['C'] > 11] # Только строки, где C > 11
nan_in_subset = subset['A'].isna().sum()
print(f"Количество NaN в столбце 'A' для подмножества: {nan_in_subset}")

Выбор между стандартными методами (isna().sum()) и альтернативными подходами зависит от конкретного сценария использования и ваших требований к анализу данных. 🧮

Сравнение эффективности методов подсчета NaN

При выборе метода подсчета NaN в больших датасетах важно учитывать не только удобство синтаксиса, но и производительность. Давайте сравним эффективность трех рассмотренных методов на различных объемах данных.

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

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

def measure_performance(df, column_name, iterations=100):
methods = {
'isna().sum()': lambda: df[column_name].isna().sum(),
'isnull().sum()': lambda: df[column_name].isnull().sum(),
'value_counts()': lambda: df[column_name].value_counts(dropna=False).get(np.nan, 0),
'pd.isna()': lambda: df[column_name][pd.isna(df[column_name])].count()
}

results = {}

for name, method in methods.items():
start_time = time.time()
for _ in range(iterations):
method()
elapsed_time = (time.time() – start_time) / iterations
results[name] = elapsed_time

return results

# Создаем датасеты разного размера
sizes = [1000, 10000, 100000, 1000000]
performance_results = {}

for size in sizes:
# Создаем DataFrame с ~15% NaN
data = [random.random() for _ in range(size)]
for i in range(size):
if random.random() < 0.15:
data[i] = np.nan

df_test = pd.DataFrame({'values': data})

# Измеряем производительность
results = measure_performance(df_test, 'values', iterations=10)
performance_results[size] = results

print(f"Размер датасета: {size}")
for method, time_taken in results.items():
print(f" {method}: {time_taken*1000:.4f} мс")
print()

Результаты тестов производительности показывают интересные закономерности:

Анализируя результаты, можно сделать следующие выводы:

1. isna().sum() и isnull().sum() показывают практически идентичную производительность, что подтверждает их функциональную эквивалентность.
2. value_counts(dropna=False) работает значительно медленнее (в 6-7 раз), так как выполняет более сложную операцию — полный подсчет всех уникальных значений.
3. pd.isna() с count() занимает промежуточное положение, работая примерно в 3-4 раза медленнее стандартных методов.

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

В зависимости от конкретной задачи, вот рекомендации по выбору метода:

• Для обычного подсчета NaN: используйте isna().sum() или isnull().sum() как наиболее эффективные методы
• Для одновременного анализа всех значений: используйте value_counts(dropna=False), несмотря на более низкую производительность, если вам нужно полное распределение
• Для сложных условий фильтрации: подход с pd.isna() более гибкий и может быть предпочтительным, когда требуется комбинирование с другими фильтрами

Если вы работаете с очень большими датасетами (миллионы строк и более), разница в производительности может быть существенной, и предпочтительным выбором будут методы isna().sum() или isnull().sum(). Для небольших наборов данных разница в производительности не так критична, и выбор может основываться на удобстве и читаемости кода. 💻

Определение пропущенных значений — фундаментальный элемент обработки данных, который влияет на каждый последующий этап аналитики. Выбор между методами isna().sum(), isnull().sum() и value_counts() зависит от конкретной задачи, размера датасета и необходимого уровня детализации. Какой бы метод вы ни выбрали, помните: качественный анализ пропущенных значений — не просто технический этап, а возможность лучше понять свои данные и принять более обоснованные решения на основе этого понимания. Делайте подсчет NaN не просто частью рутинной предобработки, а полноценным инструментом исследования данных.