Как эффективно извлечь часть строки (подстроку) из столбца в Pandas DataFrame с использованием Python?

01.04.2026
79097

7 мин
16

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

Саммари статьи

ChatGPT

Google AI

Grok

Perplexity

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

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

Основы работы с текстовыми данными в Pandas

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

В этом разделе мы рассмотрим фундаментальные концепции, лежащие в основе обработки строковых данных в Pandas. Мы начнем с изучения специального строкового аксессора .str, который открывает доступ ко множеству строковых методов Python, адаптированных для работы с Series. Затем мы перейдем к практической подготовке данных, создавая примеры DataFrame и Series с текстовыми столбцами, чтобы наглядно продемонстрировать применение этих инструментов.

Понимание строкового аксессора .str в Pandas

В экосистеме Pandas, когда вы работаете со столбцами, содержащими текстовые данные (строки), вы заметите, что стандартные строковые методы Python (например, lower(), upper(), split()) не могут быть применены напрямую к объекту Series или DataFrame. Это связано с тем, что Series — это коллекция элементов, а не одна строка, и прямое применение строковых методов к ней вызовет ошибку.

Именно здесь на помощь приходит строковый аксессор .str. Это специальный атрибут, доступный для Series, чей тип данных (dtype) является object и содержит строки. Аксессор .str предоставляет доступ к большинству встроенных строковых методов Python, а также к нескольким дополнительным, специфичным для Pandas, но в векторизованной форме.

Использование .str позволяет:

Применять строковые операции ко всем элементам Series одновременно, без необходимости писать явные циклы.
Эффективно обрабатывать отсутствующие значения (NaN), которые часто встречаются в реальных данных. Применение строковых методов через .str к NaN обычно возвращает NaN, предотвращая ошибки.
Значительно повысить производительность по сравнению с итеративным применением строковых функций.

Таким образом, вместо my_series.lower(), что вызовет ошибку, вы будете использовать my_series.str.lower(). Этот подход является краеугольным камнем для любых манипуляций со строками в Pandas, включая извлечение подстрок, которое мы рассмотрим далее.

Подготовка данных: Создание DataFrame и Series с текстовыми столбцами

Прежде чем приступить к извлечению подстрок, необходимо иметь данные, с которыми можно работать. В Pandas текстовые данные обычно хранятся в объектах Series или в столбцах DataFrame. Для демонстрации различных методов извлечения подстрок создадим несколько примеров таких структур.

Создание Series с текстовыми данными:

import pandas as pd

# Пример Series с названиями продуктов и их кодами
products_series = pd.Series([
    "Смартфон Samsung Galaxy S23 (SM-S911B)",
    "Ноутбук Apple MacBook Air M2 (MLY33LL/A)",
    "Телевизор LG OLED C2 (OLED55C2PUA)",
    "Наушники Sony WH-1000XM5 (Black)",
    "Планшет Xiaomi Pad 6 (8/256GB)",
    "Умные часы Garmin Fenix 7 (Solar)",
    None # Пример отсутствующего значения
])
print("\nПример Series:\n", products_series)

Создание DataFrame с текстовыми столбцами:

# Пример DataFrame с информацией о заказах
data = {
    'order_id': [101, 102, 103, 104, 105],
    'product_description': [
        "Книга 'Искусство программирования' (Том 1)",
        "Флешка USB 3.0 Kingston DataTraveler (64GB)",
        "Мышь беспроводная Logitech MX Master 3S (Graphite)",
        "Монитор Dell UltraSharp U2723QE (27 дюймов)",
        "Клавиатура механическая HyperX Alloy Origins (Red Switch)"
    ],
    'customer_email': [
        "ivan.petrov@example.com",
        "maria.sidorova@test.org",
        "alex.ivanov@mail.ru",
        "olga.kuznetsova@domain.net",
        "dmitry.smirnov@sample.com"
    ]
}
orders_df = pd.DataFrame(data)
print("\nПример DataFrame:\n", orders_df)

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

Извлечение подстрок по индексу и срезам (.str[])

После того как мы подготовили наши текстовые данные в Series и DataFrame, следующим логичным шагом является их непосредственная обработка. Один из наиболее интуитивно понятных и базовых способов извлечения подстрок — это использование индексации и срезов, аналогично тому, как это делается с обычными строками в Python. В Pandas для этого применяется строковый аксессор .str в сочетании с оператором квадратных скобок [].

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

Получение подстроки по фиксированным индексам и срезам

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

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

import pandas as pd

data = {'ID': [1, 2, 3, 4],
        'КодПродукта': ['ABC-12345-X', 'DEF-67890-Y', 'GHI-11223-Z', 'JKL-44556-A']}
df = pd.DataFrame(data)
print(df)

Вывод:

   ID КодПродукта
0   1  ABC-12345-X
1   2  DEF-67890-Y
2   3  GHI-11223-Z
3   4  JKL-44556-A

Извлечение по фиксированному индексу

Чтобы получить отдельный символ по его позиции, используйте синтаксис Series.str[индекс]. Например, для извлечения первого символа (индекс 0) из КодПродукта:

первый_символ = df['КодПродукта'].str[0]
print(первый_символ)

Вывод:

0    A
1    D
2    G
3    J
Name: КодПродукта, dtype: object

Извлечение подстроки по срезу (slicing)

Для извлечения последовательности символов используйте срезы [начало:конец]. Помните, что конец не включается в результат. Например, чтобы получить числовую часть кода продукта (с 4-го по 8-й символ, т.е. индексы с 4 по 8):

числовая_часть = df['КодПродукта'].str[4:9]
print(числовая_часть)

Вывод:

0    12345
1    67890
2    11223
3    44556
Name: КодПродукта, dtype: object

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

Извлечение начала, конца и отдельных символов с созданием нового столбца

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

Для извлечения начала строки (первых N символов) используется срез [:N]. Например, чтобы получить первые три символа из столбца ProductCode и сохранить их в новом столбце Prefix:

import pandas as pd

data = {'ID': [1, 2, 3, 4],
        'ProductCode': ['ABC-12345-X', 'DEF-67890-Y', 'GHI-11223-Z', 'JKL-44556-A']}
df = pd.DataFrame(data)

df['Prefix'] = df['ProductCode'].str[:3]
print(df)

Аналогично, для извлечения конца строки (последних N символов) применяется отрицательный срез [-N:]. Чтобы получить последний символ (например, код версии) и поместить его в столбец VersionCode:

df['VersionCode'] = df['ProductCode'].str[-1:]
print(df)

Извлечение отдельного символа по его индексу также просто. Например, если нам нужен символ, находящийся на 4-й позиции (индекс 3) в каждой строке, мы можем создать столбец FourthChar:

df['FourthChar'] = df['ProductCode'].str[3]
print(df)

Эти операции создают новые Series, которые затем легко присваиваются новым столбцам DataFrame, сохраняя исходные данные нетронутыми.

Мощное извлечение подстрок с помощью регулярных выражений (.str.extract())

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

Для решения этих более сложных задач Pandas предоставляет мощный инструмент — метод .str.extract(), который позволяет использовать регулярные выражения. Регулярные выражения (regex) — это гибкий и выразительный язык для описания текстовых шаблонов, позволяющий точно определять, какие фрагменты строк необходимо извлечь, независимо от их точного положения или длины. Этот раздел посвящен глубокому изучению .str.extract() и его применению для извлечения подстрок по сложным шаблонам.

Применение метода .str.extract() для извлечения по шаблону

Метод .str.extract() является мощным инструментом для извлечения подстрок, когда их положение или длина не фиксированы, но они соответствуют определенному шаблону. В основе этого метода лежат регулярные выражения (regex) — гибкий язык для описания текстовых паттернов.

Для использования .str.extract() необходимо передать ему регулярное выражение, которое содержит одну или несколько групп захвата (capturing groups), обозначенных круглыми скобками (). Каждая группа захвата будет соответствовать отдельному столбцу в результирующем DataFrame.

Рассмотрим пример, где нам нужно извлечь числовой идентификатор из строки, который всегда следует за префиксом "ID-":

import pandas as pd

data = {'text': ['Заказ ID-12345 обработан', 'Ошибка в ID-98765', 'Без идентификатора', 'ID-111']}
df = pd.DataFrame(data)

# Извлекаем числовой ID
df['extracted_id'] = df['text'].str.extract(r'ID-(\d+)')
print(df)

В этом примере r'ID-(\d+)' — это регулярное выражение:

ID- соответствует буквальному тексту "ID-".
(\d+) — это группа захвата, которая ищет одну или более цифр (\d+).

Результатом будет новый столбец extracted_id, содержащий извлеченные идентификаторы. Если шаблон не найден, соответствующее значение будет NaN.

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

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

Рассмотрим пример, где нам нужно извлечь код продукта, его версию и идентификатор из сложной строки:

import pandas as pd

data = {'product_info': [
    'Product-CODE123-v1.0-ID456',
    'Item-CODE789-v2.1-ID101',
    'Service-CODEABC-v3.2-ID202',
    'Invalid-Format'
]}
df = pd.DataFrame(data)

# Регулярное выражение с несколькими группами захвата
# (CODE\w+) - код продукта
# (v\d+\.\d+) - версия
# (ID\d+) - идентификатор
pattern = r'(?:Product|Item|Service)-(CODE\w+)-(v\d+\.\d+)-(ID\d+)'
extracted_parts = df['product_info'].str.extract(pattern)

print(extracted_parts)

В этом примере extracted_parts будет DataFrame с тремя столбцами, каждый из которых содержит данные, извлеченные соответствующей группой захвата. Если шаблон не находит совпадений (как в случае с ‘Invalid-Format’), соответствующие значения в результирующем DataFrame будут NaN.

Для улучшения читаемости и автоматического присвоения имен столбцам можно использовать именованные группы захвата (?P<name>...):

pattern_named = r'(?:Product|Item|Service)-(?P<ProductCode>CODE\w+)-(?P<Version>v\d+\.\d+)-(?P<Identifier>ID\d+)'
extracted_named = df['product_info'].str.extract(pattern_named)
print(extracted_named)

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

Продвинутые сценарии и оптимизация

После того как мы освоили базовые и мощные методы извлечения подстрок, такие как индексирование .str[] и использование регулярных выражений с .str.extract(), пришло время рассмотреть более сложные, но крайне важные аспекты работы с реальными данными. В практических задачах данные редко бывают идеальными, и часто приходится сталкиваться с отсутствующими значениями или ситуациями, когда шаблон не находит совпадений. Эффективная обработка таких сценариев критически важна для надежности и устойчивости вашего кода.

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

Обработка отсутствующих значений (NaN) и ошибок при извлечении подстрок

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

Обработка NaN при использовании `.str`

Методы, вызываемые через строковый аксессор .str, по умолчанию "пропускают" значения NaN (включая None), возвращая NaN в результате. Это интуитивно понятное поведение, которое предотвращает ошибки при попытке применить строковые операции к нестроковым или отсутствующим данным.

import pandas as pd

df_data = pd.DataFrame({
    'text': ['apple_pie', None, 'banana_split', 'grape_juice']
})

df_data['first_part_str'] = df_data['text'].str[0:5]
print(df_data)
# Вывод:
#            text first_part_str
# 0     apple_pie          apple
# 1          None            NaN
# 2  banana_split          banan
# 3   grape_juice          grape

Как видно, для None (который Pandas интерпретирует как NaN) результат также NaN.

Обработка отсутствующих совпадений и NaN с `.str.extract()`

Метод .str.extract() особенно устойчив к отсутствующим значениям и несовпадающим шаблонам. Если регулярное выражение не находит совпадения в строке, или если исходное значение является NaN, .str.extract() автоматически возвращает NaN для соответствующих групп.

import pandas as pd

df_regex = pd.DataFrame({
    'codes': ['ID123_ABC', 'XYZ_456', None, 'NO_MATCH_HERE', 'CODE789_DEF']
})

df_regex['extracted_id'] = df_regex['codes'].str.extract(r'ID(\d+)')
print(df_regex)
# Вывод:
#            codes extracted_id
# 0      ID123_ABC          123
# 1        XYZ_456          NaN
# 2           None          NaN
# 3  NO_MATCH_HERE          NaN
# 4    CODE789_DEF          789

Здесь NaN появляется как для None, так и для строк, где шаблон ID(\d+) не был найден (XYZ_456, NO_MATCH_HERE). Это позволяет легко фильтровать или заполнять эти значения после извлечения, используя методы вроде .fillna() или .dropna().

# Заполнение NaN после извлечения
df_regex['extracted_id_filled'] = df_regex['extracted_id'].fillna('N/A')
print(df_regex)
# Вывод:
#            codes extracted_id extracted_id_filled
# 0      ID123_ABC          123                 123
# 1        XYZ_456          NaN                 N/A
# 2           None          NaN                 N/A
# 3  NO_MATCH_HERE          NaN                 N/A
# 4    CODE789_DEF          789                 789

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

Сравнение методов: .str[] vs .str.extract() и выбор оптимального подхода

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

.str[] (Извлечение по индексу/срезу):
- Идеален для извлечения подстрок, когда их позиция и длина фиксированы или известны заранее (например, первые 5 символов, символы с 3 по 7).
- Прост в использовании и очень быстр для базовых операций, так как не требует компиляции регулярных выражений.
- Возвращает объект Series.
.str.extract() (Извлечение по регулярному выражению):
- Незаменим, когда позиция подстроки нефиксирована, или требуется сложная логика поиска на основе шаблона.
- Позволяет извлекать несколько групп (подстрок) одновременно, возвращая DataFrame.
- Более гибок и универсален, но может быть медленнее из-за накладных расходов на обработку регулярных выражений.

Выбор оптимального подхода:

Используйте .str[], если вам нужно извлечь подстроку по точному индексу или срезу.
Применяйте .str.extract(), когда требуется поиск по шаблону или извлечение нескольких фрагментов, особенно если структура данных нерегулярна.

Заключение

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

Выбор между .str[] и .str.extract() зависит от специфики вашей задачи: первый идеален для фиксированных позиций, второй — для сложных шаблонов. Помните о важности обработки отсутствующих значений и ошибок для обеспечения надежности кода. Освоив эти методы, вы значительно повысите свою продуктивность при манипуляциях со строковыми данными в Pandas, делая ваш анализ более точным и эффективным.

Как эффективно извлечь часть строки (подстроку) из столбца в Pandas DataFrame с использованием Python?

Основы работы с текстовыми данными в Pandas

Понимание строкового аксессора .str в Pandas

Подготовка данных: Создание DataFrame и Series с текстовыми столбцами

Извлечение подстрок по индексу и срезам (.str[])

Получение подстроки по фиксированным индексам и срезам

Извлечение по фиксированному индексу

Извлечение подстроки по срезу (slicing)

Извлечение начала, конца и отдельных символов с созданием нового столбца

Мощное извлечение подстрок с помощью регулярных выражений (.str.extract())

Применение метода .str.extract() для извлечения по шаблону

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

Продвинутые сценарии и оптимизация

Обработка отсутствующих значений (NaN) и ошибок при извлечении подстрок

Обработка NaN при использовании `.str`

Обработка отсутствующих совпадений и NaN с `.str.extract()`

Сравнение методов: .str[] vs .str.extract() и выбор оптимального подхода

Заключение

Метки:

Добавить комментарий

Как эффективно извлечь часть строки (подстроку) из столбца в Pandas DataFrame с использованием Python?

Основы работы с текстовыми данными в Pandas

Понимание строкового аксессора .str в Pandas

Подготовка данных: Создание DataFrame и Series с текстовыми столбцами

Извлечение подстрок по индексу и срезам (.str[])

Получение подстроки по фиксированным индексам и срезам

Извлечение по фиксированному индексу

Извлечение подстроки по срезу (slicing)

Извлечение начала, конца и отдельных символов с созданием нового столбца

Мощное извлечение подстрок с помощью регулярных выражений (.str.extract())

Применение метода .str.extract() для извлечения по шаблону

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

Продвинутые сценарии и оптимизация

Обработка отсутствующих значений (NaN) и ошибок при извлечении подстрок

Обработка NaN при использовании .str

Обработка отсутствующих совпадений и NaN с .str.extract()

Сравнение методов: .str[] vs .str.extract() и выбор оптимального подхода

Заключение

Метки:

Добавить комментарий

Обнаружение и распознавание лиц в Python с OpenCV и эффективным применением NumPy

Python Matplotlib: Подробное руководство по изменению цвета заголовка и подписей осей графика

Pandas applymap для Series: Какой метод использовать для поэлементной обработки данных в Python?

Обработка NaN при использовании `.str`

Обработка отсутствующих совпадений и NaN с `.str.extract()`