5 мощных методов строковой фильтрации в pandas DataFrame

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

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

• Профессионалы, использующие pandas в своей работе

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

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

Основные методы поиска по подстрокам в pandas DataFrame

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

Рассмотрим основные методы фильтрации строковых данных:

• str.contains() — универсальный метод для поиска подстроки в любой части строки
• str.startswith() — проверяет, начинается ли строка с указанной подстроки
• str.endswith() — определяет, заканчивается ли строка заданным паттерном
• str.find() и str.index() — определяют позицию подстроки, что удобно для дальнейшей фильтрации
• Регулярные выражения через str.contains(regex=True) — для сложных паттернов поиска

Для начала, создадим тестовый DataFrame для демонстрации различных методов:

import pandas as pd

# Создаем тестовый DataFrame
data = {
'product_name': ['iPhone 13 Pro', 'Samsung Galaxy S21', 'MacBook Air M1', 
'iPad Pro 2021', 'AirPods Pro', 'Surface Laptop 4'],
'category': ['Phone', 'Phone', 'Laptop', 'Tablet', 'Audio', 'Laptop'],
'price': [999, 799, 1299, 799, 249, 1299],
'description': ['Apple flagship smartphone', 'Android flagship device',
'Powerful macOS laptop', 'Professional tablet from Apple',
'Wireless noise cancelling earbuds', 'Premium Windows laptop']
}

df = pd.DataFrame(data)

Антон Соколов, Lead Data Scientist

В одном из проектов мы анализировали отзывы клиентов e-commerce платформы — более 2 миллионов записей. Первоначально для поиска ключевых слов использовали простые проверки через df[df['review'].str.contains('word')]. Но когда дело дошло до анализа десятков ключевых фраз одновременно, производительность резко упала.

Решение нашлось в оптимизации: для поиска слов в начале предложения использовали str.startswith(), для суффиксов — str.endswith(), а для сложных шаблонов — предкомпилированные регулярные выражения. Это сократило время обработки с 4.5 часов до 37 минут. Кроме того, мы создали индексы для часто используемых текстовых колонок, что дополнительно ускорило работу.

Каждый метод имеет свои особенности использования и оптимален для разных задач. Давайте детальнее рассмотрим каждый из них, начиная с наиболее универсального — str.contains().

Фильтрация с помощью str.contains(): синтаксис и возможности

Метод str.contains() — это швейцарский нож для работы со строковыми данными в pandas. Он позволяет проверить наличие подстроки в строке, учитывая различные параметры. Рассмотрим его синтаксис и возможности, которые часто упускаются из виду даже опытными аналитиками. 🧰

Базовый синтаксис выглядит следующим образом:

# Найти все продукты Apple
apple_products = df[df['description'].str.contains('Apple')]
print(apple_products)

Однако str.contains() предлагает гораздо больше возможностей через дополнительные параметры:

• case — логический параметр для учета/игнорирования регистра (по умолчанию True)
• na — значение для NaN (по умолчанию NaN)
• regex — использовать ли регулярные выражения (по умолчанию True)
• pat — паттерн для поиска (строка или регулярное выражение)

Рассмотрим примеры использования этих параметров:

# Игнорирование регистра
case_insensitive = df[df['description'].str.contains('apple', case=False)]

# Обработка NaN значений
df_with_nan = df.copy()
df_with_nan.loc[2, 'description'] = None
result = df_with_nan[df_with_nan['description'].str.contains('Apple', na=False)]

# Экранирование специальных символов при отключении regex
special_chars = df[df['description'].str.contains('laptop.', regex=False)]

Один из частых сценариев — поиск по нескольким подстрокам одновременно. Здесь str.contains() также предлагает элегантное решение:

# Поиск по нескольким подстрокам через регулярное выражение
multi_search = df[df['description'].str.contains('Apple|Android')]

# Альтернативный способ через оператор | (OR)
multi_search_alt = df[df['description'].str.contains('Apple') | df['description'].str.contains('Android')]

Особое внимание стоит уделить обработке отсутствующих значений. При наличии NaN в столбце, метод str.contains() вернет NaN для соответствующих строк, что может привести к неожиданным результатам при фильтрации:

# Безопасная фильтрация с учетом NaN
result = df[df['description'].str.contains('Apple', na=False)]

# Альтернативный подход: заполнить NaN перед фильтрацией
df_filled = df.copy()
df_filled['description'] = df_filled['description'].fillna('')
result_alt = df_filled[df_filled['description'].str.contains('Apple')]

Важно отметить, что str.contains() автоматически использует регулярные выражения, если параметр regex=True. Это может привести к ошибкам, если в искомой строке содержатся специальные символы регулярных выражений (. ^ $ * + ? { } [ ] \ | ( )). Для литерального поиска таких символов используйте regex=False или экранируйте их:

# Поиск строки с точкой (буквально)
literal_search = df[df['description'].str.contains('\\.', regex=True)]

# Или отключите регулярные выражения
literal_search_alt = df[df['description'].str.contains('.', regex=False)]

Альтернативные функции: str.startswith(), str.endswith()

Хотя str.contains() является универсальным инструментом, существуют сценарии, где более специализированные методы str.startswith() и str.endswith() работают эффективнее и точнее. Эти функции особенно полезны, когда нужно фильтровать данные по началу или концу строки. 🎯

Метод str.startswith() проверяет, начинается ли строка с указанной подстроки:

# Найти все продукты, названия которых начинаются с "i"
i_products = df[df['product_name'].str.startswith('i', case=True)]
print(i_products)

# Поиск по нескольким префиксам
apple_products = df[df['product_name'].str.startswith(('iPhone', 'iPad', 'Mac'))]
print(apple_products)

Аналогично, str.endswith() проверяет, заканчивается ли строка определенной подстрокой:

# Найти все продукты, названия которых заканчиваются на "Pro"
pro_products = df[df['product_name'].str.endswith('Pro')]
print(pro_products)

# Поиск по нескольким суффиксам
premium_products = df[df['product_name'].str.endswith(('Pro', 'Air'))]
print(premium_products)

Преимущества этих методов по сравнению с str.contains():

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

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

# Поиск продуктов, начинающихся с нескольких брендов
multiple_brands = df[df['product_name'].str.startswith(('iPhone', 'Samsung', 'Surface'))]

# Поиск продуктов с определенными идентификаторами модели
model_variants = df[df['product_name'].str.endswith(('Pro', 'Air', 'S21'))]

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

# Безопасная фильтрация с учетом NaN
safe_filter = df[df['product_name'].str.startswith('i', na=False)]

Елена Иванова, Data Analyst Lead

При анализе логов пользовательских сессий e-commerce сайта (более 50 млн записей) мы столкнулись с необходимостью сегментировать трафик по источникам. Изначально мы использовали df[df['url'].str.contains('utm_source')], но это работало медленно и давало ложные срабатывания.

Переход на df[df['url'].str.contains('utm_source=')] улучшил точность, но настоящий прорыв произошел, когда мы разделили URL на компоненты и применили str.startswith() для параметров запроса. Для URL с UTM-метками мы использовали:

Python

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

# Извлекаем параметры из URL
df['query_params'] = df['url'].str.split('?').str[1].fillna('')
# Фильтруем по источникам
google_traffic = df[df['query_params'].str.startswith('utm_source=google')]

Это ускорило обработку на 78% и устранило все ложные срабатывания. Теперь анализ, который раньше занимал 3.5 часа, выполняется за 45 минут.

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

# Найти продукты Apple, названия которых заканчиваются на "Pro"
apple_pro = df[
(df['description'].str.contains('Apple', case=False)) & 
(df['product_name'].str.endswith('Pro'))
]

# Найти все телефоны, которые не начинаются с "iPhone"
non_iphone = df[
(df['category'] == 'Phone') & 
(~df['product_name'].str.startswith('iPhone'))
]

Регулярные выражения в str.contains() для сложного поиска

Регулярные выражения трансформируют возможности фильтрации текстовых данных из линейных в экспоненциальные, позволяя создавать сложнейшие паттерны поиска. Метод str.contains() с параметром regex=True открывает полный потенциал регулярных выражений для работы с DataFrame. 💪

Рассмотрим базовые примеры использования регулярных выражений:

# Найти все продукты, содержащие цифры в названии
numeric_products = df[df['product_name'].str.contains(r'\d', regex=True)]

# Найти продукты с годом в названии (4 цифры подряд)
year_products = df[df['product_name'].str.contains(r'\b\d{4}\b', regex=True)]

# Поиск слов, начинающихся на определенную букву
p_words = df[df['description'].str.contains(r'\bP\w+', regex=True)]

Для более сложных сценариев, регулярные выражения становятся незаменимым инструментом:

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

Примеры продвинутого использования регулярных выражений:

# Поиск продуктов с версией (например, "V2" или "V3")
version_products = df[df['product_name'].str.contains(r'V\d+', regex=True)]

# Поиск цен в тексте описания (числа с символом $ или суммы вида "100 USD")
price_mentions = df[df['description'].str.contains(r'\$\d+|\d+\s+USD', regex=True)]

# Поиск по нескольким ключевым словам с учетом вариаций
keywords = r'(?:high\s*performance|fast|quick|rapid)'
performance_products = df[df['description'].str.contains(keywords, regex=True, case=False)]

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

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

Пример использования скомпилированного регулярного выражения для повышения производительности:

import re

# Компиляция регулярного выражения
pattern = re.compile(r'apple|samsung', re.IGNORECASE)

# Использование предкомпилированного шаблона
brand_products = df[df['description'].str.contains(pattern)]

Дополнительные флаги регулярных выражений можно передавать через параметр flags:

# Использование флагов регулярных выражений
multiline_search = df[df['description'].str.contains(r'^powerful', regex=True, flags=re.IGNORECASE | re.MULTILINE)]

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

# Извлечение и фильтрация по извлеченным значениям
df['brand'] = df['description'].str.extract(r'(Apple|Samsung|Microsoft)', flags=re.IGNORECASE)
apple_only = df[df['brand'] == 'Apple']

# Использование .str.findall() для поиска всех соответствий
df['keywords'] = df['description'].str.findall(r'\b[A-Z][a-z]+\b')
has_keywords = df[df['keywords'].str.len() > 0]

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

# Нечеткий поиск с допуском опечаток
fuzzy_pattern = r'(lapt?op|note?book)' # Найдет laptop, latop, notebook, notbook
fuzzy_match = df[df['description'].str.contains(fuzzy_pattern, regex=True, case=False)]

# Поиск с учетом границ слов
word_boundary = df[df['description'].str.contains(r'\blaptop\b', regex=True)]

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

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

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

import pandas as pd
import numpy as np
import re
import time

# Создаем тестовый DataFrame с 1 млн строк
n = 1000000
words = ['apple', 'orange', 'banana', 'grape', 'watermelon']
descriptions = [np.random.choice(words) + ' ' + np.random.choice(words) for _ in range(n)]

big_df = pd.DataFrame({
'description': descriptions
})

# Функция для измерения времени выполнения
def measure_time(func, *args):
start = time.time()
result = func(*args)
end = time.time()
return end – start, len(result)

# Тестируем различные методы
methods = {
'str.contains': lambda: big_df[big_df['description'].str.contains('apple')],
'str.contains (case=False)': lambda: big_df[big_df['description'].str.contains('apple', case=False)],
'str.startswith': lambda: big_df[big_df['description'].str.startswith('apple')],
'str.endswith': lambda: big_df[big_df['description'].str.endswith('apple')],
'str.find != -1': lambda: big_df[big_df['description'].str.find('apple') != -1],
'str.contains + regex': lambda: big_df[big_df['description'].str.contains(r'ap+le', regex=True)],
'precompiled regex': lambda: big_df[big_df['description'].str.contains(re.compile('apple'))],
'apply with "in"': lambda: big_df[big_df['description'].apply(lambda x: 'apple' in x)]
}

# Проводим тестирование
results = {}
for name, method in methods.items():
time_taken, count = measure_time(method)
results[name] = {'time': time_taken, 'count': count}

Результаты сравнения производительности представлены в следующей таблице:

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

• Используйте str.startswith() и str.endswith() вместо str.contains() для поиска по началу или концу строки — это на 10-15% быстрее
• Метод str.find() != -1 часто работает быстрее str.contains() для простого поиска подстрок
• Предкомпиляция регулярных выражений значительно повышает производительность
• Избегайте использования .apply() с функциями Python для поиска — это самый медленный подход
• Игнорирование регистра (case=False) замедляет выполнение в среднем на 20-30%

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

# Использование векторизации вместо строковых методов
import re
pattern = re.compile('apple')
is_match = np.vectorize(lambda x: bool(pattern.search(x)))(big_df['description'].values)
result = big_df[is_match]

# Использование параллельной обработки
import multiprocessing as mp
from functools import partial

def process_chunk(df_chunk, pattern):
return df_chunk[df_chunk['description'].str.contains(pattern)]

n_cores = mp.cpu_count()
df_split = np.array_split(big_df, n_cores)
pool = mp.Pool(n_cores)
func = partial(process_chunk, pattern='apple')
results = pd.concat(pool.map(func, df_split))
pool.close()
pool.join()

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

• Dask — для параллельной обработки pandas DataFrame
• PySpark — для распределенной обработки на кластере
• NumPy — для векторизованных операций
• PyArrow/Vaex — для работы с данными, не помещающимися в память

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

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