Объединение текстовых колонок в pandas: 3 эффективных метода

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

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

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

  Обработка текстовых данных — одна из самых частых задач в арсенале аналитика. Объединение текстовых колонок в pandas DataFrame может потребоваться при создании полных имён из имени и фамилии, формировании адресов из отдельных компонентов или генерации уникальных идентификаторов. Хотя задача кажется элементарной, неправильный подход может привести к NaN-ошибкам, некорректной обработке пустых значений и снижению производительности. Я подготовил для вас три проверенных способа решения этой задачи, включая тонкости работы с пропущенными значениями и оптимизацию для больших наборов данных. 🐼

Если вы хотите не просто решить отдельную задачу по объединению колонок, а системно освоить обработку и анализ данных на Python, обратите внимание на курс Профессия аналитик данных от Skypro. Программа включает углубленное изучение pandas для трансформации данных, визуализацию в matplotlib и seaborn, а также построение моделей машинного обучения. Выпускники курса уверенно решают задачи любой сложности и востребованы на рынке труда.

Три метода объединения текстовых колонок в DataFrame pandas

Библиотека pandas предоставляет несколько мощных инструментов для объединения текстовых данных, каждый из которых имеет свои преимущества и особенности применения. При выборе метода стоит учитывать такие факторы, как размер данных, наличие пустых значений и требования к форматированию. 📊

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

import pandas as pd

data = {
'first_name': ['Анна', 'Иван', 'Мария', None, 'Алексей'],
'last_name': ['Иванова', 'Петров', None, 'Сидоров', 'Козлов']
}

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

Вывод:

first_name last_name
0 Анна Иванова
1 Иван Петров
2 Мария None
3 None Сидоров
4 Алексей Козлов

Давайте рассмотрим три основных метода объединения текстовых колонок в pandas и проанализируем их особенности:

Базовый способ объединения строк с помощью оператора +

Самый интуитивный способ объединения текстовых колонок — использование оператора сложения (+). Этот метод напрямую наследует поведение конкатенации строк в Python и особенно удобен для быстрых операций с чистыми данными.

Дмитрий Волков, старший аналитик данных

Когда я только начинал работать с pandas, столкнулся с задачей подготовки данных клиентов для CRM-системы. Нужно было объединить имена и фамилии из разных столбцов в один формат «Фамилия И.». Первым делом попробовал оператор «+», так как это казалось очевидным решением. Код был элементарным:

Python

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

df['full_name'] = df['last_name'] + ' ' + df['first_name'].str[0] + '.'

Всё работало идеально, пока на тестовой выборке не появились клиенты с пропущенными данными. Вся колонка full_name превратилась в NaN, и мне пришлось срочно искать альтернативные методы. С тех пор я всегда сначала проверяю данные на пропуски, прежде чем использовать оператор +.

Простейшее объединение имени и фамилии с помощью оператора + выглядит следующим образом:

# Простое объединение с пробелом между именем и фамилией
df['full_name'] = df['first_name'] + ' ' + df['last_name']
print(df)

Результат:

first_name last_name full_name
0 Анна Иванова Анна Иванова
1 Иван Петров Иван Петров
2 Мария None NaN
3 None Сидоров NaN
4 Алексей Козлов Алексей Козлов

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

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

# Заполняем пропуски перед объединением
df['full_name'] = df['first_name'].fillna('') + ' ' + df['last_name'].fillna('')
# Удаляем лишние пробелы
df['full_name'] = df['full_name'].str.strip()
print(df)

Этот метод имеет следующие характеристики:

• Скорость: Достаточно быстрый для небольших и средних датасетов
• Читаемость: Интуитивно понятный код, легко поддерживать
• Обработка ошибок: Требует дополнительной обработки NaN-значений
• Гибкость: Ограниченная — работает только с простой конкатенацией

Использование метода str.cat() для гибкой конкатенации данных

Метод str.cat() представляет собой более продвинутый инструмент для объединения текстовых данных в pandas. Он был специально разработан для работы с текстовыми колонками и предлагает значительно больше гибкости, особенно при работе с разделителями и пустыми значениями. 🔄

Базовый синтаксис метода выглядит так:

# Объединение с использованием str.cat()
df['full_name'] = df['first_name'].str.cat(df['last_name'], sep=' ', na_rep='')
print(df)

Основные параметры метода str.cat():

• others — другая колонка или список колонок для объединения
• sep — разделитель между элементами (по умолчанию пустая строка)
• na_rep — значение, которым будут заменены NaN (по умолчанию NaN)
• join — тип объединения ('left', 'right', 'outer', 'inner')

Метод особенно удобен, когда требуется объединить несколько колонок с разными разделителями:

# Создадим DataFrame с адресами
address_data = {
'city': ['Москва', 'Санкт-Петербург', 'Казань', None, 'Новосибирск'],
'street': ['Ленина', 'Невский', None, 'Баумана', 'Красный'],
'building': ['12', '100', '45', '7', None]
}

address_df = pd.DataFrame(address_data)

# Объединяем с разными разделителями
address_df['full_address'] = address_df['city'].str.cat(
[address_df['street'], address_df['building']], 
sep=[', ул. ', ', д. '], 
na_rep='')
print(address_df)

Елена Соколова, Data Scientist

В проекте по анализу отзывов клиентов мне пришлось объединять текстовые поля из разных источников данных. Многие записи содержали пропуски, и обычное сложение строк давало некорректные результаты. После нескольких часов отладки я открыла для себя метод str.cat() с параметром na_rep.

Код стал не только надежнее, но и элегантнее:

Python

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

df['review_with_context'] = df['review_text'].str.cat(
[df['product_name'], df['customer_segment']], 
sep=[' | Продукт: ', ' | Сегмент: '], 
na_rep='Не указано')

Это позволило сохранить структуру данных даже при наличии пропусков. Теперь я всегда использую str.cat() в проектах с текстовыми данными, так как он обеспечивает контроль над каждым аспектом объединения. Этот метод стал моим стандартным инструментом для обработки клиентских данных.

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

# Объединяем все имена в одну строку
all_names = df['first_name'].str.cat(sep=', ', na_rep='Неизвестно')
print(f"Все имена: {all_names}")

Сравнение производительности различных методов объединения текста показывает, что str.cat() имеет преимущества при работе с большими датасетами и сложными сценариями объединения:

Функция pd.concat() для сложных сценариев объединения

Функция pd.concat() обычно ассоциируется с объединением нескольких DataFrame, но она также может применяться для конкатенации текстовых колонок в сложных сценариях. Этот метод особенно полезен, когда необходимо объединить много колонок или когда требуется расширенный контроль над процессом. 🧩

Основной синтаксис применения pd.concat() для объединения текстовых колонок:

# Объединение колонок с помощью pd.concat
df['full_name'] = pd.concat([df['first_name'], df['last_name']], axis=1).agg(' '.join, axis=1)
print(df)

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

# Сложное форматирование с лямбда-функцией
df['formatted_name'] = pd.concat([df['first_name'], df['last_name']], axis=1).apply(
lambda row: f"{row['last_name']}, {row['first_name'][0]}." if pd.notna(row['first_name']) and pd.notna(row['last_name']) 
else (row['last_name'] if pd.notna(row['last_name']) else row['first_name']), axis=1
)
print(df)

Этот метод позволяет создавать более сложные форматы объединения, такие как:

• Форматирование инициалов: "Иванов И. П."
• Сортировка компонентов: фамилия сначала, затем имя
• Условная логика: разное форматирование для разных типов записей
• Обработка пустых значений с применением пользовательской логики
• Преобразование регистра или других текстовых трансформаций

Функция pd.concat() также может использоваться для объединения более двух колонок:

# Создаем DataFrame с полными ФИО
name_data = {
'first_name': ['Анна', 'Иван', 'Мария', None, 'Алексей'],
'middle_name': ['Петровна', None, 'Ивановна', 'Сергеевич', 'Владимирович'],
'last_name': ['Иванова', 'Петров', None, 'Сидоров', 'Козлов']
}

name_df = pd.DataFrame(name_data)

# Объединяем ФИО
name_df['full_name'] = pd.concat([
name_df['last_name'], 
name_df['first_name'], 
name_df['middle_name']
], axis=1).agg(lambda x: ' '.join(filter(lambda v: pd.notna(v), x)), axis=1)

print(name_df)

Обратите внимание, что в этом примере мы используем filter для удаления NaN-значений перед объединением.

Решение проблемы NaN-значений при соединении текстовых колонок

Обработка пропущенных значений (NaN) — одна из самых частых проблем при объединении текстовых колонок. Если не учесть эту особенность, объединение может привести к неожиданным результатам или потере данных. Рассмотрим несколько стратегий работы с NaN-значениями. ⚠️

Основная проблема в том, что при стандартной конкатенации с использованием оператора + наличие NaN в любой из объединяемых колонок приводит к NaN в результате:

# Демонстрация проблемы с NaN
data_with_nan = {
'col1': ['A', 'B', None, 'D', 'E'],
'col2': ['X', None, 'Z', 'W', None]
}
df_nan = pd.DataFrame(data_with_nan)

# Проблемный подход
df_nan['concat_bad'] = df_nan['col1'] + df_nan['col2']
print(df_nan)

Вывод:

col1 col2 concat_bad
0 A X AX
1 B None NaN
2 None Z NaN
3 D W DW
4 E None NaN

Есть несколько эффективных стратегий решения проблемы NaN-значений:

1. Заполнение пропусков перед объединением:

# Заполняем пустые значения перед объединением
df_nan['concat_fillna'] = df_nan['col1'].fillna('') + df_nan['col2'].fillna('')
print(df_nan)

2. Использование метода str.cat() с параметром na_rep:

# Используем str.cat с параметром na_rep
df_nan['concat_strcat'] = df_nan['col1'].str.cat(df_nan['col2'], na_rep='')
print(df_nan)

3. Применение пользовательской логики обработки NaN:

# Используем apply с пользовательской логикой
df_nan['concat_custom'] = df_nan.apply(
lambda row: (row['col1'] if pd.notna(row['col1']) else '') + 
(row['col2'] if pd.notna(row['col2']) else ''),
axis=1
)
print(df_nan)

4. Использование функции numpy.where для условной обработки:

import numpy as np

# Используем numpy.where для различных сценариев
df_nan['concat_where'] = np.where(
df_nan['col1'].notna() & df_nan['col2'].notna(),
df_nan['col1'] + df_nan['col2'],
np.where(
df_nan['col1'].notna(),
df_nan['col1'],
np.where(
df_nan['col2'].notna(),
df_nan['col2'],
''
)
)
)
print(df_nan)

Выбор метода обработки NaN-значений зависит от конкретной задачи и требований к выходным данным:

• Простое заполнение пустыми строками — когда NaN должен быть просто пропущен в результате
• Заполнение специальными маркерами — когда нужно явно отметить отсутствие данных (например, "N/A", "Не указано")
• Сложная логика обработки — когда разные колонки требуют разного подхода к обработке пропусков
• Условное форматирование — когда формат результата зависит от наличия или отсутствия значений

Важно также учитывать производительность: методы с использованием apply() могут работать медленнее на больших датасетах, в то время как векторизованные операции (например, с numpy.where()) обычно более эффективны.

Объединение текстовых колонок в pandas — это базовая, но важная техника, которая открывает множество возможностей для обработки данных. Выбор правильного метода может существенно повлиять на качество результата и производительность кода. Операция сложения идеальна для простых случаев без пропусков, str.cat() обеспечивает баланс между простотой и функциональностью, а pd.concat() с агрегацией подходит для самых сложных сценариев. Помните о правильной обработке NaN-значений, и ваши текстовые трансформации будут надежны и эффективны в любых условиях.