Фильтрация DataFrame по списку значений в Python: методы pandas

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

• Аналитики данных и научные работники, работающие с Python и Pandas
• Студенты и начинающие программисты, изучающие обработку данных

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

  Эффективная фильтрация данных в Python — это искусство, которым должен владеет каждый аналитик. Работа с большими наборами информации требует точности и скорости, особенно когда нужно выбрать строки по определённым критериям. Pandas предоставляет несколько мощных инструментов для фильтрации DataFrame по спискам значений, существенно упрощая извлечение нужных данных из массивных таблиц. Освоив эти методы, вы сможете превратить часы мучительного кодирования в минуты элегантных решений, сэкономив время и ресурсы для более глубокого анализа. 🚀

Осваиваете работу с данными в Python? Обучение Python-разработке от Skypro поможет систематизировать знания и поднять навыки на новый уровень. На курсе вы научитесь эффективно работать с pandas, освоите продвинутые методы фильтрации и анализа данных, которые мгновенно повысят вашу продуктивность и откроют новые карьерные возможности. Учитесь у практикующих разработчиков и станьте экспертом по обработке данных!

Основы фильтрации строк DataFrame по списку значений

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

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

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

import pandas as pd

# Создаем тестовый DataFrame
data = {
'id': [1, 2, 3, 4, 5, 6, 7, 8, 9],
'category': ['A', 'B', 'C', 'A', 'B', 'C', 'A', 'B', 'C'],
'value': [100, 200, 300, 150, 250, 350, 180, 280, 380]
}

df = pd.DataFrame(data)
print(df)

Допустим, нам нужно выбрать все строки, где столбец 'category' содержит значения из списка ['A', 'C']. Существует несколько подходов к такой фильтрации:

1. Использование метода .isin() — самый распространённый и читаемый способ
2. Применение индексации .loc[] с булевой маской — универсальный метод для сложных условий
3. Метод .query() — компактный синтаксис для сложных фильтров

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

Алексей Петров, Senior Data Analyst

Однажды я работал над анализом данных о клиентском поведении с таблицей, содержащей более 10 миллионов строк. Требовалось выделить транзакции только определённых категорий товаров для дальнейшего анализа. Изначально я использовал циклы и условные операторы, что приводило к неприемлемой производительности — обработка занимала около 40 минут.

После изучения возможностей pandas я переписал код, используя фильтрацию по списку значений через метод .isin(). Время выполнения сократилось до 15 секунд! Это кардинально изменило мой подход к обработке данных. Теперь я мог проводить итеративный анализ, тестируя разные гипотезы в режиме реального времени, вместо того чтобы ждать часами результатов каждого запроса.

Существуют определённые паттерны при работе с фильтрацией по списку значений, которые повышают эффективность кода:

• Предварительное создание списков значений до фильтрации
• Использование множеств (set) вместо списков для повышения производительности при проверке принадлежности
• Комбинирование нескольких условий фильтрации для сложных запросов

Понимание этих основ создаёт прочный фундамент для изучения более специализированных методов фильтрации в pandas.

Метод .isin() для эффективной выборки данных в pandas

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

Синтаксис метода предельно прост и интуитивно понятен:

# Синтаксис базовой фильтрации с использованием .isin()
filtered_df = df[df['column_name'].isin(values_list)]

Рассмотрим практический пример, используя наш тестовый DataFrame:

# Выбираем все строки, где категория A или C
categories_of_interest = ['A', 'C']
filtered_df = df[df['category'].isin(categories_of_interest)]
print(filtered_df)

Результат выполнения этого кода:

Метод .isin() особенно полезен, когда необходимо проверить принадлежность к набору значений, а не просто равенство одному значению. Он значительно упрощает код по сравнению с альтернативами, такими как множественные условия с операторами OR (|).

Дополнительно метод .isin() можно комбинировать с другими операциями фильтрации:

# Комбинирование .isin() с другими условиями
result = df[(df['category'].isin(['A', 'C'])) & (df['value'] > 200)]
print(result)

Существует также инвертированная версия .isin() с использованием отрицания (~):

# Выбор всех строк, где категория НЕ A и НЕ C
not_in_categories = df[~df['category'].isin(['A', 'C'])]
print(not_in_categories)

При работе с большими наборами данных стоит обратить внимание на некоторые оптимизации:

1. Использование множеств вместо списков внутри .isin() для повышения производительности
2. Предварительная фильтрация DataFrame перед применением .isin() для уменьшения объёма обрабатываемых данных
3. Применение .isin() к индексированным столбцам для максимальной эффективности

Таблица сравнения различных сценариев использования .isin():

Метод .isin() является оптимальным выбором для большинства сценариев фильтрации по списку значений благодаря своей читаемости, производительности и гибкости. 🔍

Применение .loc[] при фильтрации по нескольким условиям

Метод .loc[] в pandas представляет собой мощный инструмент для индексации и выборки данных. Когда речь идет о фильтрации строк по нескольким условиям, включая списки значений, .loc[] предлагает гибкие и эффективные решения.

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

Базовый синтаксис .loc[] для фильтрации по списку значений:

# Фильтрация с использованием .loc[] и .isin()
filtered_df = df.loc[df['column_name'].isin(values_list)]

Рассмотрим пример использования .loc[] с нашим тестовым DataFrame:

# Выбираем строки категорий A и C, и только столбцы 'id' и 'value'
result = df.loc[df['category'].isin(['A', 'C']), ['id', 'value']]
print(result)

Что делает .loc[] особенно мощным, так это возможность комбинировать сложные условия фильтрации с выбором конкретных столбцов в одном выражении:

# Комплексная фильтрация с несколькими условиями
complex_filter = df.loc[(df['category'].isin(['A', 'B'])) & (df['value'] > 200), ['category', 'value']]
print(complex_filter)

Марина Соколова, Lead Data Scientist

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

Изначально я использовала последовательные фильтры, что приводило к созданию множества промежуточных DataFrame и усложняло код. Переход на метод .loc[] с комбинированными условиями фильтрации позволил не только упростить код, но и ускорить обработку примерно на 30%. Особенно элегантным оказалось решение для сценария, где требовалось выбрать клиентов определенных тарифных планов с высоким ARPU и специфическим паттерном использования услуг — всего одной строкой кода с .loc[].

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

При работе со сложными условиями фильтрации, .loc[] особенно полезен благодаря нескольким преимуществам:

• Возможность одновременной фильтрации строк и выбора столбцов
• Улучшенная читаемость кода при сложных условиях
• Поддержка различных типов индексации (метки, логические массивы, числовые позиции)
• Эффективная работа с иерархическими индексами

Рассмотрим примеры различных сценариев использования .loc[] для фильтрации по списку значений:

# Фильтрация с условием OR (вместо .isin())
result_or = df.loc[df['category'].isin(['A', 'C']) | (df['value'] > 300)]
print(result_or)

# Использование .loc[] с индексами
df.set_index('id', inplace=True)
ids_to_select = [1, 4, 7]
result_by_index = df.loc[ids_to_select]
print(result_by_index)

# Фильтрация с конструкцией where
result_where = df.loc[df['category'].where(df['value'] > 200).isin(['A', 'B'])]
print(result_where)

Одна из наиболее мощных возможностей .loc[] — это работа с вложенными условиями и сложными логическими выражениями:

# Сложное условие с вложенными группами
mask = (
(df['category'].isin(['A', 'B']) & (df['value'] > 200)) |
(df['category'].isin(['C']) & (df['value'] < 350))
)
complex_result = df.loc[mask]
print(complex_result)

Хотя .loc[] предоставляет исключительную гибкость, важно помнить о некоторых особенностях его использования:

1. Условия фильтрации должны возвращать булеву маску той же длины, что и DataFrame
2. При выборке по меткам индекса несуществующие метки вызывают KeyError (в отличие от .iloc[])
3. Сложные логические выражения лучше разбивать на отдельные переменные для улучшения читаемости

В контексте фильтрации по списку значений, .loc[] особенно эффективен, когда необходимо выполнить многомерную выборку данных с многочисленными условиями. 🧩

Синтаксис .query() для удобной выборки по списку значений

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

Синтаксис метода .query() отличается от традиционных методов фильтрации в pandas:

# Базовый синтаксис метода .query()
filtered_df = df.query('column_name == value')

# Фильтрация по списку значений
filtered_df = df.query('column_name in @values_list')

Обратите внимание на символ @, который используется для ссылки на переменные из локальной области видимости Python внутри строки запроса.

Рассмотрим применение .query() на нашем тестовом DataFrame:

# Выбираем категории A и C
categories = ['A', 'C']
query_result = df.query('category in @categories')
print(query_result)

Метод .query() особенно полезен при комбинировании нескольких условий, так как делает код более компактным и читаемым:

# Комбинированные условия с использованием .query()
complex_query = df.query('category in ["A", "C"] and value > 200')
print(complex_query)

# Эквивалентный код с использованием традиционной фильтрации
equivalent_result = df[(df['category'].isin(['A', 'C'])) & (df['value'] > 200)]
print(equivalent_result)

Преимущества метода .query() наиболее заметны при работе со сложными условиями:

Важно отметить некоторые особенности работы с методом .query():

• Имена столбцов можно использовать непосредственно в строке запроса без префикса 'df['']'
• Имена столбцов с пробелами или специальными символами должны заключаться в обратные кавычки (column name)
• Для доступа к переменным из внешнего окружения используется символ @ (например, @variable_name)
• Метод поддерживает сложные логические выражения с операторами and, or, not
• Внутри строки запроса можно использовать литералы списков, например 'column in ["A", "B", "C"]'

Примеры более сложного использования .query():

# Использование регулярных выражений внутри .query()
import numpy as np

# Создаем DataFrame с текстовыми данными
text_df = pd.DataFrame({
'product': ['Apple iPhone', 'Samsung Galaxy', 'Google Pixel', 'Apple iPad', 'OnePlus 9'],
'price': [999, 899, 799, 499, 699]
})

# Фильтрация с помощью .str и регулярных выражений
apple_products = text_df.query('product.str.contains("Apple")', engine='python')
print(apple_products)

# Фильтрация с числовыми диапазонами и списками
mid_range_phones = text_df.query('price between 700 and 900 and product not in @["Apple iPhone", "Apple iPad"]')
print(mid_range_phones)

Метод .query() также может использоваться для динамической фильтрации на основе пользовательского ввода или параметров:

# Динамическая фильтрация с .query()
def filter_by_category_and_value(df, categories, min_value):
query_str = f'category in @categories and value >= {min_value}'
return df.query(query_str)

# Использование функции
result = filter_by_category_and_value(df, ['A', 'B'], 200)
print(result)

При работе с большими наборами данных метод .query() может обеспечить более высокую производительность благодаря оптимизации выполнения выражений через движок numexpr (если он установлен). 📝

Сравнение методов фильтрации: производительность и применение

Выбор оптимального метода фильтрации DataFrame по списку значений зависит от нескольких факторов: размера данных, сложности условий, читаемости кода и требований к производительности. Давайте проведем сравнительный анализ рассмотренных методов: .isin(), .loc[] с булевыми масками и .query().

Для объективной оценки производительности создадим тестовый DataFrame большего размера и измерим время выполнения различных методов фильтрации:

import pandas as pd
import numpy as np
import time

# Создаем большой тестовый DataFrame
n_rows = 1_000_000
categories = ['A', 'B', 'C', 'D', 'E']
data = {
'id': np.arange(n_rows),
'category': np.random.choice(categories, n_rows),
'value': np.random.randint(100, 1000, n_rows)
}

large_df = pd.DataFrame(data)

# Список значений для фильтрации
filter_categories = ['A', 'C', 'E']

# Функция для измерения времени выполнения
def time_execution(func, n_iterations=5):
times = []
for _ in range(n_iterations):
start = time.time()
result = func()
end = time.time()
times.append(end – start)
return np.mean(times)

# Тестируемые методы
def method_isin():
return large_df[large_df['category'].isin(filter_categories)]

def method_loc():
return large_df.loc[large_df['category'].isin(filter_categories)]

def method_query():
return large_df.query('category in @filter_categories')

# Измеряем производительность
time_isin = time_execution(method_isin)
time_loc = time_execution(method_loc)
time_query = time_execution(method_query)

print(f"Время выполнения .isin(): {time_isin:.4f} сек.")
print(f"Время выполнения .loc[]: {time_loc:.4f} сек.")
print(f"Время выполнения .query(): {time_query:.4f} сек.")

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

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

• Используйте .isin() с прямой индексацией для простых случаев фильтрации по одному условию — это самый читаемый и интуитивно понятный подход
• Применяйте .loc[] когда нужно одновременно фильтровать строки и выбирать подмножество столбцов
• Выбирайте .query() для сложных логических выражений с множеством условий, особенно когда важна читаемость кода
• Для критических по производительности участков проведите бенчмаркинг всех методов с вашими реальными данными

Дополнительные факторы, влияющие на выбор метода:

1. Размер списка значений: при очень больших списках метод .isin() может быть менее эффективен
2. Частота выполнения фильтрации: для часто повторяющихся операций в циклах выбирайте наиболее производительный метод
3. Тип данных столбца: некоторые методы могут работать эффективнее с определёнными типами данных
4. Требования к памяти: создание промежуточных булевых масок может потребовать значительного объёма памяти для очень больших DataFrame

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

# Пример поэтапной фильтрации для улучшения читаемости и поддерживаемости кода
# Шаг 1: фильтрация по категориям
step1 = large_df[large_df['category'].isin(['A', 'C'])]

# Шаг 2: фильтрация по значению
step2 = step1[step1['value'] > 500]

# Шаг 3: сортировка результатов
final_result = step2.sort_values('value', ascending=False)

Независимо от выбранного метода, важно помнить о практиках оптимизации производительности при фильтрации больших DataFrame:

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

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

Освоение различных методов фильтрации DataFrame по списку значений существенно расширяет возможности эффективной обработки данных в Python. Каждый из рассмотренных подходов — будь то элегантный .isin(), универсальный .loc[] или лаконичный .query() — имеет свои сильные стороны и оптимальные сценарии применения. Истинное мастерство анализа данных проявляется в способности выбрать подходящий инструмент для конкретной задачи, учитывая объем данных, сложность условий и требования к производительности. Применяя эти техники в своей работе, вы не просто оптимизируете код, но и приобретаете более глубокое понимание внутренних механизмов pandas, что неизбежно поднимет ваш уровень как специалиста по данным.