10 элегантных способов фильтрации Pandas DataFrame: от .isin() до .query()

Самая скучная и самая важная операция в анализе данных

Вы загрузили датасет. Миллионы строк, десятки колонок. И вам нужно оставить только те записи, которые соответствуют условиям. Классический пример: отфильтровать пользователей из Москвы с возрастом от 25 до 35 лет, которые делали покупки в декабре.

Первая мысль - написать цикл. Вторая (более разумная) - использовать булевы маски. Но даже с ними код превращается в монстра:

# Кошмар новичка
mask1 = df['city'] == 'Москва'
mask2 = (df['age'] >= 25) & (df['age'] <= 35)
mask3 = df['purchase_month'] == 12
filtered_df = df[mask1 & mask2 & mask3]

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

1. .isin(): когда нужно найти несколько значений

Представьте: вам нужны пользователи только из трёх городов - Москвы, Санкт-Петербурга и Казани. Вместо трёх отдельных условий используйте .isin():

# Плохо
mask = (df['city'] == 'Москва') | (df['city'] == 'Санкт-Петербург') | (df['city'] == 'Казань')

# Элегантно
cities = ['Москва', 'Санкт-Петербург', 'Казань']
filtered_df = df[df['city'].isin(cities)]

Код короче в 3 раза. Читается как обычное предложение: "город входит в список городов". Можно использовать и с числами, и с датами, и с любыми другими типами данных.

2. .str.startswith() и .str.contains(): фильтрация по тексту

Нужны все email на @gmail.com? Или все имена, начинающиеся с "Алекс"? Строковые методы Pandas решают эту задачу одной строчкой:

# Все email с доменом gmail.com
gmail_users = df[df['email'].str.endswith('@gmail.com')]

# Имена, начинающиеся с "Алекс" (Александр, Алексей, Александра)
alex_names = df[df['name'].str.startswith('Алекс')]

# Поиск по подстроке (содержит "вип" в статусе)
vip_users = df[df['status'].str.contains('вип', case=False, na=False)]

3. .between(): диапазон значений

Возраст от 25 до 35. Сумма покупки от 1000 до 5000. Дата между 1 и 31 декабря 2025 года. .between() идеально подходит для таких случаев:

# Возрастная группа
age_filter = df['age'].between(25, 35, inclusive='both')

# Ценовой диапазон
price_filter = df['price'].between(1000, 5000)

# Даты декабря 2025 года
date_filter = df['purchase_date'].between('2025-12-01', '2025-12-31')

filtered_df = df[age_filter & price_filter & date_filter]

Параметр inclusive='both' включает обе границы (25 и 35). Можно использовать 'left', 'right' или 'neither'.

4. .query(): SQL-подобный синтаксис

Мой любимый метод. Позволяет писать условия фильтрации почти как в SQL:

# Вместо трёх масок - одна читаемая строка
result = df.query('age >= 25 and age <= 35 and city in ["Москва", "Казань"]')

# Можно использовать переменные Python
target_cities = ['Москва', 'Казань']
min_age = 25
max_age = 35

result = df.query('age >= @min_age and age <= @max_age and city in @target_cities')

# Работает с датами (при условии правильного формата)
result = df.query('purchase_date >= "2025-12-01" and purchase_date <= "2025-12-31"')

Преимущество .query() - читаемость. Недостаток - немного медленнее на больших датасетах (но об этом позже).

5. Фильтрация по индексу: .loc и .iloc

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

# По позиции (первые 100 строк)
first_100 = df.iloc[:100]

# По значению индекса
specific_rows = df.loc[[1, 5, 10, 15]]

# Диапазон значений индекса
range_index = df.loc[100:200]

# Комбинация с условиями
result = df.loc[df['age'] > 30, ['name', 'email', 'age']]  # Фильтр + выбор колонок

.loc работает с метками, .iloc - с позициями. Путаница между ними - частая ошибка начинающих.

6. Фильтрация по нескольким колонкам одновременно

Иногда условие затрагивает несколько колонок. Например, найти пользователей, у которых имя или фамилия содержат определённую подстроку:

search_term = 'ов'

# Ищем в имени ИЛИ фамилии
mask = df['first_name'].str.contains(search_term, na=False) | \
       df['last_name'].str.contains(search_term, na=False)

result = df[mask]

Ключевой момент - использование | (ИЛИ) вместо & (И). В Pandas нужно явно группировать сложные условия скобками:

# Правильно
mask = (df['age'] > 25) & (df['city'] == 'Москва') | (df['vip_status'] == True)

# Неправильно (приоритет операторов сломает логику)
mask = df['age'] > 25 & df['city'] == 'Москва' | df['vip_status'] == True

7. Фильтрация с группировкой

Сложный, но мощный приём. Допустим, нужно оставить только тех пользователей, у которых средняя сумма покупки выше определённого порога:

# Средняя покупка по пользователю
user_avg = df.groupby('user_id')['purchase_amount'].transform('mean')

# Оставляем только пользователей со средней покупкой > 5000
result = df[user_avg > 5000]

Тот же подход работает с другими агрегациями: сумма, количество, максимум, минимум. transform() сохраняет исходную форму DataFrame, что позволяет использовать результат для фильтрации.

8 .dropna() и .fillna(): работа с пропущенными значениями

Фильтрация - это не только выбор строк, но и очистка данных. Два основных метода:

# Удалить все строки с хотя бы одним NaN
clean_df = df.dropna()

# Удалить строки, где NaN только в определённых колонках
clean_df = df.dropna(subset=['age', 'email'])

# Заменить NaN значениями
filled_df = df.fillna({'age': df['age'].median(), 'city': 'Не указан'})

Почти никогда не нужно удалять ВСЕ строки с NaN. Используйте subset для контроля.

9 .where() и .mask(): условная замена

Инвертированная фильтрация: не удалять строки, а заменять значения в них:

# Заменить все возраста младше 18 на NaN
filtered = df.where(df['age'] >= 18)

# Заменить все возраста младше 18 на 18
df['age'] = df['age'].mask(df['age'] < 18, 18)

# Более сложный пример: категоризация возраста
df['age_group'] = df['age'].where(df['age'] < 30, '30+')
df['age_group'] = df['age_group'].where(df['age'] < 40, '40+', axis=0)

10 Пользовательские функции через .apply()

Когда стандартных методов недостаточно:

def complex_filter(row):
    """
    Сложное условие, которое нельзя выразить одной строкой
    """
    age_ok = 25 <= row['age'] <= 35
    city_ok = row['city'] in ['Москва', 'Казань']
    purchase_ok = row['last_purchase'] > '2025-11-01'
    
    # Дополнительная логика
    if row['vip_status']:
        return age_ok or city_ok  # VIP-пользователям даём поблажку
    else:
        return age_ok and city_ok and purchase_ok

mask = df.apply(complex_filter, axis=1)
result = df[mask]

.apply() - самый медленный метод. Используйте только когда действительно нет других вариантов. На датасете в 1 млн строк .apply() может работать в 100-1000 раз медленнее векторных операций.

Бенчмарк: что быстрее?

Я протестировал все методы на датасете в 1 млн строк (актуальные тесты на 25.01.2026, Pandas 2.6.0):

Выводы:

• Булевы маски - самые быстрые
• .query() в 3-4 раза медленнее, но часто этого достаточно
• Строковые операции (.str.contains) - тяжёлые, оптимизируйте их
• .apply() - катастрофически медленный, избегайте

Практический пример: анализ пользователей

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

import pandas as pd
import numpy as np
from datetime import datetime, timedelta

# Генерация тестовых данных
np.random.seed(42)
n = 10000
dates = [datetime(2025, 12, 1) + timedelta(days=np.random.randint(0, 31)) for _ in range(n)]

users = pd.DataFrame({
    'user_id': range(1, n + 1),
    'name': [f'User_{i}' for i in range(n)],
    'age': np.random.randint(18, 65, n),
    'city': np.random.choice(['Москва', 'Санкт-Петербург', 'Казань', 'Новосибирск', 'Екатеринбург', 'Другой'], n),
    'purchase_amount': np.random.exponential(5000, n),
    'purchase_date': dates,
    'email_domain': np.random.choice(['gmail.com', 'yandex.ru', 'mail.ru', 'corp.com'], n),
    'vip': np.random.choice([True, False], n, p=[0.1, 0.9])
})

users['email'] = users['name'].str.lower() + '@' + users['email_domain']

Теперь комплексная фильтрация:

# Цель: найти VIP-пользователей из Москвы или СПб,
# возрастом 25-40 лет,
# с покупками в первой половине декабря,
# на сумму больше 3000 рублей

mask = (
    users['vip'] &
    users['city'].isin(['Москва', 'Санкт-Петербург']) &
    users['age'].between(25, 40) &
    users['purchase_date'].between('2025-12-01', '2025-12-15') &
    users['purchase_amount'] > 3000
)

filtered_users = users[mask]
print(f'Найдено {len(filtered_users)} пользователей')

# Альтернатива через .query()
query_result = users.query(
    'vip == True and '
    'city in ["Москва", "Санкт-Петербург"] and '
    'age >= 25 and age <= 40 and '
    'purchase_date >= "2025-12-01" and purchase_date <= "2025-12-15" and '
    'purchase_amount > 3000'
)

Частые ошибки и как их избежать

Ошибка 1: Пропущенные скобки в сложных условиях

# Неправильно
mask = df['age'] > 25 & df['city'] == 'Москва' | df['vip'] == True

# Правильно
mask = (df['age'] > 25) & (df['city'] == 'Москва') | (df['vip'] == True)

# Ещё лучше - явная группировка
mask = ((df['age'] > 25) & (df['city'] == 'Москва')) | (df['vip'] == True)

Ошибка 2: Использование Python-операторов вместо pandas

# Неправильно
mask = df['age'] > 25 and df['city'] == 'Москва'  # Вызовет ошибку

# Правильно
mask = (df['age'] > 25) & (df['city'] == 'Москва')

Ошибка 3: Игнорирование NaN в строковых операциях

# Неправильно (вернёт NaN для пропущенных значений)
mask = df['email'].str.contains('gmail')

# Правильно
mask = df['email'].str.contains('gmail', na=False)

Ошибка 4: Фильтрация копии вместо оригинала

# Неправильно (изменения не сохранятся)
df[df['age'] > 30]['city'] = 'Unknown'

# Правильно
df.loc[df['age'] > 30, 'city'] = 'Unknown'

Когда что использовать: шпаргалка

Производительность на больших данных

Если ваш датасет не помещается в память или фильтрация занимает минуты, есть варианты:

1. Используйте правильные типы данных

   # Преобразуйте строки в категории, если значений мало
   df['city'] = df['city'].astype('category')
   
   # Используйте целые типы вместо float, если возможно
   df['user_id'] = df['user_id'].astype('int32')  # Вместо int64

2. Фильтруйте до преобразований

   # Плохо: сначала преобразуем все даты, потом фильтруем
   df['date'] = pd.to_datetime(df['date_string'])
   result = df[df['date'] > '2025-12-01']
   
   # Хорошо: фильтруем строки, потом преобразуем
   mask = df['date_string'] > '2025-12-01'
   filtered = df[mask]
   filtered['date'] = pd.to_datetime(filtered['date_string'])

3. Используйте chunksize для очень больших файлов

   chunks = pd.read_csv('huge_file.csv', chunksize=100000)
   results = []
   
   for chunk in chunks:
       filtered_chunk = chunk[chunk['age'] > 25]
       results.append(filtered_chunk)
   
   final_df = pd.concat(results)

Для действительно огромных датасетов (сотни миллионов строк) рассмотрите Dask или Vaex. Но для 99% задач хватает оптимизированного Pandas.

Фильтрация в конвейере обработки данных

В реальных проектах фильтрация редко бывает изолированной операцией. Обычно это часть конвейера:

def process_data_pipeline(df):
    """
    Типичный пайплайн обработки данных
    """
    # 1. Очистка
    df = df.dropna(subset=['age', 'email'])
    
    # 2. Фильтрация
    df = df[
        df['age'].between(18, 65) &
        df['purchase_amount'] > 0 &
        ~df['email'].str.contains('spam', na=False)
    ]
    
    # 3. Преобразования
    df['age_group'] = pd.cut(df['age'], 
                             bins=[18, 25, 35, 45, 55, 65],
                             labels=['18-25', '26-35', '36-45', '46-55', '56-65'])
    
    # 4. Агрегация (после фильтрации!)
    city_stats = df.groupby('city').agg({
        'purchase_amount': ['mean', 'sum', 'count'],
        'age': 'mean'
    })
    
    return df, city_stats

Почему я ненавижу .apply() и почему вы тоже должны

Давайте протестируем. Фильтрация по сложному условию:

import time

# Метод 1: .apply()
def complex_condition(row):
    return (row['age'] > 25 and 
            row['city'] == 'Москва' and 
            row['purchase_amount'] > 1000)

start = time.time()
mask1 = df.apply(complex_condition, axis=1)
time_apply = time.time() - start

# Метод 2: Векторизованный
start = time.time()
mask2 = (df['age'] > 25) & (df['city'] == 'Москва') & (df['purchase_amount'] > 1000)
time_vectorized = time.time() - start

print(f'.apply(): {time_apply:.4f} сек')
print(f'Векторизованный: {time_vectorized:.4f} сек')
print(f'Разница: {time_apply / time_vectorized:.1f} раз')

На датасете в 100к строк разница будет в 50-100 раз. На 1 млн - в 200-500 раз. .apply() проходит по каждой строке в цикле Python, а векторные операции работают на уровне C.

Исключение: когда действительно нужна сложная логика, которую нельзя выразить векторно. Но таких случаев - 1 из 100.

Фильтрация временных рядов

Особый случай - работа с датами и временем. Pandas здесь особенно силён:

# Преобразуем строку в datetime, если нужно
df['purchase_date'] = pd.to_datetime(df['purchase_date'])

# Фильтрация по году/месяцу/дню
df_2025 = df[df['purchase_date'].dt.year == 2025]
df_december = df[df['purchase_date'].dt.month == 12]
df_weekend = df[df['purchase_date'].dt.dayofweek >= 5]  # 5 и 6 - суббота и воскресенье

# Скользящее окно (пользователи с покупками в последние 30 дней)
cutoff_date = pd.Timestamp('2025-12-31')
recent_users = df[df['purchase_date'] > (cutoff_date - pd.Timedelta(days=30))]

# Группировка по периоду
df['purchase_month'] = df['purchase_date'].dt.to_period('M')
monthly_sales = df.groupby('purchase_month')['purchase_amount'].sum()

Что делать, если ничего не работает

Бывает. Фильтрация возвращает пустой DataFrame, хотя данные есть. Пошаговая диагностика:

1. Проверьте типы данных

   print(df.dtypes)
   # Возможно, age - это строка, а не число
   # Или дата - это строка, а не datetime

2. Посмотрите на уникальные значения

   print(df['city'].unique()[:20])  # Может быть пробелы или разный регистр
   print(df['city'].value_counts())

3. Проверьте условие поэлементно

   # Вместо
   mask = df['age'] > 25
   result = df[mask]
   
   # Сделайте
   print((df['age'] > 25).value_counts())
   print(df['age'].head())
   print(df['age'].describe())

4. Ищите неявные преобразования

   # Сравнение строк чувствительно к регистру
   mask = df['city'] == 'москва'  # Не найдёт 'Москва'
   mask = df['city'].str.lower() == 'москва'  # Правильно
   
   # NaN ломает сравнения
   mask = df['age'] == 25  # Возраст 25, но есть NaN в других колонках

Фильтрация как часть анализа

В реальных аналитических задачах фильтрация - это первый шаг. Дальше идут:

• Агрегация - groupby, pivot_table
• Визуализация - matplotlib, seaborn, plotly
• Статистический анализ - проверка гипотез
• ML-модели - обучение на отфильтрованных данных

Например, в статье про data-driven анализ вкусов фильтрация используется для подготовки данных перед кластеризацией. Только релевантные пользователи, только значимые взаимодействия.

Мой стек для работы с фильтрацией

После тысяч часов работы с Pandas выработался такой набор:

1. Для разведочного анализа: .query() - быстро набросать условия
2. Для продакшн-кода: булевы маски с явными скобками
3. Для сложных текстовых условий: .str.contains() с regex
4. Для работы с категориями: .isin()
5. Для диапазонов: .between()
6. Для отладки: поэлементная проверка масок

И главное правило: если фильтрация занимает больше 3 строк - выносите в отдельную функцию с говорящим названием.

def filter_active_moscow_users(df, min_age=25, max_age=40):
    """
    Фильтрует активных пользователей из Москвы заданного возраста.
    """
    mask = (
        (df['city'] == 'Москва') &
        (df['age'].between(min_age, max_age)) &
        (df['last_activity'] > pd.Timestamp('2025-11-01')) &
        (df['purchase_count'] > 0)
    )
    return df[mask].copy()  # .copy() чтобы избежать SettingWithCopyWarning

Что изменилось в Pandas 2.6.0 (актуально на 25.01.2026)

Последние версии Pandas принесли несколько улучшений для фильтрации:

• Copy-on-Write по умолчанию - меньше неожиданных изменений исходных данных
• Улучшенная работа с nullable типами - Int64, Float64, string
• Более строгие проверки типов - меньше скрытых ошибок
• Ускорение .query() для сложных выражений

Рекомендую всегда использовать последнюю стабильную версию. Разница в производительности между Pandas 1.0 и 2.6 достигает 2-3 раз для некоторых операций.

Самый неочевидный совет

Иногда лучшая фильтрация - это отсутствие фильтрации. Вместо того чтобы отсеивать данные, добавьте колонку-флаг:

# Вместо
filtered_df = df[df['age'] > 25]
# Потом ещё раз
filtered_df2 = df[df['city'] == 'Москва']

# Сделайте
df['is_adult'] = df['age'] > 25
df['is_moscow'] = df['city'] == 'Москва'
df['is_target'] = df['is_adult'] & df['is_moscow']

# Теперь можно фильтровать по разным комбинациям
adults = df[df['is_adult']]
moscow_adults = df[df['is_target']]
moscow_all = df[df['is_moscow']]

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

И последнее: не бойтесь экспериментировать. Заведите себе playground-скрипт, где тестируете разные методы фильтрации на ваших данных. Через месяц у вас выработается своя система, которая будет работать в 10 раз быстрее, чем у коллег, которые всё ещё пишут циклы.