Как добавить строку в DataFrame pandas: 5 эффективных методов

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

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

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

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

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

Способы добавления строк в DataFrame pandas

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

Рассмотрим пять основных методов для добавления строки в DataFrame:

• Метод append() — классический способ, удобный для единичных операций
• Метод concat() — мощный инструмент для объединения данных
• Использование loc[] — гибкий метод для добавления по индексу
• Методы at[] и iat[] — для точечных операций с высокой производительностью
• Расширение существующего DataFrame — с предварительным созданием нового DataFrame

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

import pandas as pd
import numpy as np

# Создаем базовый DataFrame
data = {'Имя': ['Анна', 'Борис', 'Виктор'],
'Возраст': [25, 30, 35],
'Город': ['Москва', 'Санкт-Петербург', 'Казань']}

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

# Результат:
# Имя Возраст Город
# 0 Анна 25 Москва
# 1 Борис 30 Санкт-Петербург
# 2 Виктор 35 Казань

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

Метод append(): быстрое добавление строк в DataFrame

Алексей Корнилов, Lead Data Scientist

Недавно работал над проектом анализа клиентской базы для розничной сети. Требовалось ежедневно обновлять основной DataFrame, добавляя новых клиентов. Изначально я использовал метод append() из-за его простоты и понятности. Код был прост: df = df.append(new_customer, ignore_index=True). Решение работало безупречно на небольших объемах данных. Однако, когда база клиентов выросла до нескольких миллионов записей, я заметил значительное замедление. После профилирования кода обнаружил, что append() создает копию DataFrame при каждом вызове, что неэффективно для больших данных. Это стало отличным уроком о важности выбора правильного метода в зависимости от масштаба задачи.

Метод append() — наиболее интуитивный способ добавить строку в DataFrame pandas. Он позволяет добавлять данные, представленные в виде Series, словаря или другого DataFrame. Хотя с версии pandas 1.4.0 этот метод помечен как устаревший, он все еще широко используется и важен для понимания.

Базовый синтаксис метода append():

# Добавление строки с использованием словаря
new_row = {'Имя': 'Дмитрий', 'Возраст': 40, 'Город': 'Новосибирск'}
df = df.append(new_row, ignore_index=True)

# Добавление строки с использованием Series
new_row_series = pd.Series(['Елена', 28, 'Екатеринбург'], index=df.columns)
df = df.append(new_row_series, ignore_index=True)

print(df)
# Результат:
# Имя Возраст Город
# 0 Анна 25 Москва
# 1 Борис 30 Санкт-Петербург
# 2 Виктор 35 Казань
# 3 Дмитрий 40 Новосибирск
# 4 Елена 28 Екатеринбург

Обратите внимание на параметр ignore_index=True. Он указывает pandas создать новый последовательный индекс для результирующего DataFrame, что часто полезно при добавлении строк.

Ключевые особенности метода append():

Если вам необходимо добавить множество строк, более эффективно сначала собрать их в отдельный DataFrame, а затем добавить все сразу:

# Создаем DataFrame с новыми строками
new_rows = pd.DataFrame([
{'Имя': 'Федор', 'Возраст': 45, 'Город': 'Сочи'},
{'Имя': 'Галина', 'Возраст': 32, 'Город': 'Владивосток'}
])

# Добавляем все строки одновременно
df = df.append(new_rows, ignore_index=True)

Важно помнить: поскольку метод append() помечен как устаревший, рекомендуется использовать альтернативные методы, такие как concat() или loc[], особенно в новых проектах, чтобы избежать проблем совместимости с будущими версиями pandas. 🚀

Метод concat(): объединение DataFrame с новыми строками

Метод pd.concat() — это мощный инструмент для вертикального (по строкам) или горизонтального (по столбцам) объединения DataFrame. Для задачи добавления строки в DataFrame этот метод не только более эффективен, чем append(), но и официально рекомендован как его замена.

Основной синтаксис использования concat() для добавления строк:

# Создаем DataFrame с новой строкой
new_row = pd.DataFrame({'Имя': ['Жанна'], 'Возраст': [38], 'Город': ['Краснодар']})

# Используем concat для добавления
df = pd.concat([df, new_row], ignore_index=True)

print(df)
# Результат:
# Имя Возраст Город
# 0 Анна 25 Москва
# 1 Борис 30 Санкт-Петербург
# 2 Виктор 35 Казань
# 3 Жанна 38 Краснодар

Метод concat() особенно полезен, когда нужно добавить несколько строк или даже целые DataFrame. Его параметры позволяют контролировать различные аспекты объединения данных:

• ignore_index: если True, не использует индексы исходных объектов, а создает новый числовой индекс
• axis: определяет ось объединения (0 для строк, 1 для столбцов)
• join: способ объединения ('inner' для пересечения, 'outer' для объединения всех столбцов)
• keys: добавляет иерархический уровень индексации для идентификации источника каждой строки

Пример добавления нескольких строк с использованием concat():

# Создаем DataFrame с несколькими новыми строками
new_rows = pd.DataFrame([
{'Имя': 'Игорь', 'Возраст': 41, 'Город': 'Самара'},
{'Имя': 'Карина', 'Возраст': 29, 'Город': 'Уфа'},
{'Имя': 'Леонид', 'Возраст': 37, 'Город': 'Тюмень'}
])

# Объединяем с основным DataFrame
df = pd.concat([df, new_rows], ignore_index=True)

Метод concat() также удобен для отслеживания источника данных с помощью параметра keys:

# Добавление с маркировкой источника
result = pd.concat([df, new_rows], keys=['original', 'new'])
print(result.head())

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

Сравнение методов concat() и append() для добавления строки в DataFrame:

Метод concat() оптимален для большинства сценариев добавления строк в DataFrame. Он не только эффективнее для массовых операций, но и предоставляет больше возможностей контроля над процессом объединения данных. 💪

Метод loc[] для добавления строк по индексу

Индексатор loc[] — это мощный инструмент pandas не только для доступа к данным, но и для добавления новых строк в DataFrame. Этот метод особенно удобен, когда вам необходимо добавить строку по конкретному индексу или когда индекс имеет смысловое значение.

Екатерина Морозова, Data Engineer

Работая над проектом по анализу временных рядов финансовых данных, я столкнулась с необходимостью добавлять новые записи с датами в качестве индекса. Метод loc[] оказался настоящим спасением. В моем случае DataFrame содержал ежедневные показатели, и индексом служила дата. При появлении новых данных мне нужно было вставлять их точно на нужную дату. Я использовала код вида df.loc[new_date] = [value1, value2, value3]. Это не только было интуитивно понятно, но и гарантировало, что данные попадут именно туда, куда нужно. Более того, если дата уже существовала, данные автоматически обновлялись, что избавило от необходимости проверять существование индекса перед вставкой.

Основной принцип работы loc[] для добавления строки — указание нового индекса и присвоение ему значений:

# Создаем DataFrame с числовыми индексами
df = pd.DataFrame({
'Имя': ['Анна', 'Борис', 'Виктор'],
'Возраст': [25, 30, 35],
'Город': ['Москва', 'Санкт-Петербург', 'Казань']
})

# Добавляем строку с индексом 3
df.loc[3] = ['Мария', 27, 'Нижний Новгород']

print(df)
# Результат:
# Имя Возраст Город
# 0 Анна 25 Москва
# 1 Борис 30 Санкт-Петербург
# 2 Виктор 35 Казань
# 3 Мария 27 Нижний Новгород

Этот подход особенно полезен при работе с индексами, имеющими смысловую нагрузку, например, датами или идентификаторами:

# Создаем DataFrame с индексами-датами
df_dates = pd.DataFrame({
'Значение': [100, 200, 300]
}, index=pd.to_datetime(['2023-01-01', '2023-01-02', '2023-01-03']))

# Добавляем новое значение для конкретной даты
df_dates.loc[pd.Timestamp('2023-01-04')] = 400

print(df_dates)
# Результат:
# Значение
# 2023-01-01 100
# 2023-01-02 200
# 2023-01-03 300
# 2023-01-04 400

Преимущества использования loc[] для добавления строки в DataFrame:

• Прямой контроль над индексом новой строки
• Возможность добавления строк в произвольном порядке
• Автоматическое обновление существующих строк при совпадении индекса
• Высокая производительность для одиночных операций
• Встроенная в pandas функциональность без создания временных объектов

Метод loc[] также позволяет добавлять строки с частичными данными или с данными только для определенных столбцов:

# Добавляем строку только с некоторыми данными
df.loc[4, ['Имя', 'Город']] = ['Олег', 'Иркутск']
# Недостающие значения будут заполнены NaN

# Можно потом дополнить недостающие данные
df.loc[4, 'Возраст'] = 33

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

Метод loc[] — эффективный инструмент для добавления строки в DataFrame pandas, особенно когда важен контроль над индексацией. Он обеспечивает прямой доступ к структуре данных без создания промежуточных копий, что делает его производительным для многих сценариев использования. 📈

Метод at[] и iat

Методы at[] и iat[] в pandas представляют собой специализированные инструменты для быстрого доступа к отдельным элементам DataFrame. Хотя они не предназначены специально для добавления новых строк, они могут быть чрезвычайно эффективными для создания новых строк по одному элементу за раз, особенно когда производительность критически важна.

Основное различие между этими методами:

• at[] — доступ по метке индекса и имени столбца
• iat[] — доступ по позиции индекса и позиции столбца (целочисленные позиции)

Рассмотрим использование at[] для добавления новой строки:

# Создаем базовый DataFrame
df = pd.DataFrame({
'A': [1, 2, 3],
'B': ['a', 'b', 'c']
}, index=[0, 1, 2])

# Добавляем новую строку с индексом 3, заполняя ячейки по одной
df.at[3, 'A'] = 4
df.at[3, 'B'] = 'd'

print(df)
# Результат:
# A B
# 0 1 a
# 1 2 b
# 2 3 c
# 3 4 d

Аналогично можно использовать iat[], если вы работаете с целочисленными позициями:

# Предположим, у нас есть DataFrame с 3 строками
# Чтобы добавить 4-ю строку с iat[], нам нужно сначала расширить DataFrame
df = df.reindex(index=[0, 1, 2, 3])

# Теперь заполняем ячейки по позиции
df.iat[3, 0] = 4 # 4-я строка, 1-й столбец
df.iat[3, 1] = 'd' # 4-я строка, 2-й столбец

Важно отметить, что при использовании iat[] для добавления строки необходимо сначала расширить DataFrame, иначе вы получите IndexError.

Преимущества и ограничения методов at[] и iat[]:

• Преимущества:
• Наивысшая производительность для точечного доступа
• Минимальные накладные расходы при работе с большими DataFrame
• Возможность добавлять данные выборочно
• Ограничения:
• Необходимость добавлять каждое значение по отдельности
• Требуется предварительное расширение DataFrame для iat[]
• Менее удобно для добавления полных строк с множеством столбцов

Этот метод наиболее эффективен в следующих сценариях:

1. Когда вам нужно добавить небольшое количество значений в конкретные позиции
2. В ситуациях, где критична производительность
3. При работе с очень большими DataFrame, где другие методы могут создавать значительные накладные расходы
4. Для обновления отдельных значений в уже существующей строке

Пример практического использования at[] в цикле для эффективного заполнения новой строки:

# Создаем DataFrame
df = pd.DataFrame({
'Признак_1': [10, 20, 30],
'Признак_2': [100, 200, 300],
'Признак_3': ['X', 'Y', 'Z']
})

# Определяем новый индекс
new_index = 3

# Данные для новой строки
new_data = {'Признак_1': 40, 'Признак_2': 400, 'Признак_3': 'W'}

# Добавляем строку по элементам
for col, value in new_data.items():
df.at[new_index, col] = value

print(df)

Методы at[] и iat[] предоставляют мощные инструменты для точечного добавления данных в DataFrame с максимальной производительностью. Хотя они могут быть менее удобны для добавления полных строк по сравнению с другими методами, их эффективность делает их незаменимыми в ситуациях, где критична скорость операций. 🚀

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

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

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

• Пакетное добавление: сбор множества строк в список и добавление их одним вызовом concat()

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

Основные выводы по производительности:

1. append() — наименее эффективен для больших DataFrame из-за создания копии при каждом вызове
2. concat() — эффективнее append() и хорошо работает для пакетных операций
3. loc[] — обеспечивает хороший баланс между удобством и производительностью
4. at[] — самый быстрый метод для точечных операций, но требует добавления по одному значению
5. Пакетное добавление — наиболее эффективно для добавления множества строк

Рассмотрим пример кода для пакетного добавления строк, которое значительно эффективнее последовательного добавления:

import pandas as pd
import time

# Создаем тестовый DataFrame
df = pd.DataFrame({'A': range(100000), 'B': range(100000)})

# Строки для добавления
rows_to_add = [{'A': i, 'B': i} for i in range(100000, 100100)]

# Метод 1: Последовательное добавление с append()
start = time.time()
for row in rows_to_add:
df = df.append(row, ignore_index=True)
print(f"append() последовательно: {time.time() – start:.4f} сек")

# Сбрасываем DataFrame
df = pd.DataFrame({'A': range(100000), 'B': range(100000)})

# Метод 2: Пакетное добавление с concat()
start = time.time()
new_rows_df = pd.DataFrame(rows_to_add)
df = pd.concat([df, new_rows_df], ignore_index=True)
print(f"concat() пакетно: {time.time() – start:.4f} сек")

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

• Для одиночных добавлений в небольшие DataFrame: любой метод подойдет, выбирайте по удобству синтаксиса
• Для частых добавлений в цикле: избегайте append(), используйте loc[] или собирайте строки в список для последующего пакетного добавления
• Для добавления с заданным индексом: loc[] обеспечивает прямой и понятный синтаксис
• Для максимальной производительности: at[] для точечных операций или пакетное добавление для множества строк
• Для новых проектов: предпочтительнее concat() вместо устаревшего append()

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

Правильный выбор метода добавления строки в DataFrame может значительно повысить производительность вашего кода, особенно при работе с большими наборами данных. Учитывайте особенности вашей задачи и характеристики данных при выборе оптимального подхода. 📊

Выбор правильного метода добавления строк в DataFrame pandas – это баланс между удобством, читаемостью кода и производительностью. Для небольших данных различия несущественны, но при масштабировании они становятся критичными. Методы append() и concat() интуитивно понятны и достаточны для большинства задач. Локаторы loc[] и at[] обеспечивают точный контроль и высокую производительность. Помните главное правило: избегайте добавления строк по одной в циклах – объединяйте их в отдельный DataFrame и добавляйте одной операцией. Владение всеми этими методами сделает ваш код не только эффективным, но и элегантным.

Читайте также

• Зарплаты Python-разработчиков: от джуниора до сеньора в России
• Автоматизация работы с Excel на Python: экономим время, силы
• Pandas для Python: мощный инструмент анализа и обработки данных
• Python и Google Sheets API: автоматизация работы с таблицами
• Интеграция PyCharm и ClickUp: автоматизация задач разработки
• Как установить Anaconda и Jupyter Notebook для работы с данными
• 5 мощных способов добавления столбцов с условиями в pandas
• PyTorch и TensorFlow: выбор фреймворка для задач машинного обучения
• Автоматизация Google Таблиц через Python: пишем код, экономим время
• Как использовать значения словарей в Python: полное руководство