5 способов превратить DataFrame в список в Python: эффективность и примеры

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

• аналитики данных
• разработчики, работающие с Python и библиотекой Pandas

• студенты, изучающие аналитику данных и машинное обучение

  Трансформация данных из DataFrame в список — это навык, который регулярно спасает жизнь аналитику данных. Представьте: у вас массивный датасет, но для визуализации нужен только определенный столбец в виде списка. Или алгоритм машинного обучения принимает только Python-списки. Возможно, вы интегрируете данные с API, который не понимает pandas. В таких ситуациях преобразование DataFrame в список становится не просто удобством, а необходимостью. Разберем пять эффективных способов выполнить эту задачу, от базовых до продвинутых, с анализом производительности каждого метода. 🐼

Осваиваете работу с DataFrame в Pandas и хотите профессионально извлекать и трансформировать данные? На курсе Профессия аналитик данных от Skypro вы не только изучите все тонкости работы с Pandas, но и научитесь эффективно манипулировать данными для бизнес-задач. От базовых операций до сложных трансформаций — вы освоите все необходимые техники и будете применять их на реальных проектах под руководством опытных менторов.

Почему преобразование DataFrame в список важно для аналитики

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

Вот ключевые причины, почему эта операция так важна:

• Интеграция с другими библиотеками — многие Python-библиотеки (особенно более старые) ожидают данные в виде стандартных списков, а не специализированных структур данных Pandas
• Оптимизация памяти — в некоторых случаях извлечение только необходимых данных в виде списка позволяет значительно сократить потребление памяти
• Упрощение визуализации — библиотеки для визуализации, такие как Matplotlib, часто работают эффективнее с простыми списками
• Предобработка для машинного обучения — некоторые модели машинного обучения принимают данные в виде обычных Python-списков
• Ускорение итераций — итерация по обычному Python-списку может быть быстрее, чем по DataFrame, особенно для небольших наборов данных

Александр Петров, Senior Data Analyst Помню, как столкнулся с необходимостью обработать огромный датасет транзакций клиентов банка. Нужно было выявить аномальные операции, а затем передать результаты в устаревшую, но критически важную систему мониторинга, принимающую только структуры в формате списков. Весь процесс превратился в настоящее испытание, пока я не освоил эффективные методы преобразования DataFrame. В итоге разработал скрипт, который сократил время выявления подозрительных транзакций с 4 часов до 15 минут. Сейчас такие преобразования — базовая часть нашего пайплайна анализа, и без них невозможно представить эффективную работу системы мониторинга.

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

Теперь, понимая важность этой операции, рассмотрим различные методы её выполнения, начиная с самого распространенного — метода to_list().

Метод to_list() для извлечения данных из столбца

Метод to_list() — это, пожалуй, самый интуитивный и прямолинейный способ получить список из столбца DataFrame. Он применяется к Series (столбцу DataFrame) и возвращает обычный Python-список, сохраняя исходные типы данных элементов. 📊

Вот базовый пример использования этого метода:

import pandas as pd

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

df = pd.DataFrame(data)

# Получаем список из столбца "Возраст"
age_list = df['Возраст'].to_list()
print(age_list)
# Вывод: [25, 30, 22, 35, 28]

# Получаем список из столбца "Имя"
names_list = df['Имя'].to_list()
print(names_list)
# Вывод: ['Анна', 'Иван', 'Елена', 'Петр', 'Мария']

Метод to_list() обладает следующими важными характеристиками:

• Работает только с одномерными Series (отдельными столбцами), не с целым DataFrame
• Сохраняет типы данных элементов (числа остаются числами, строки — строками)
• Поддерживает обработку пропущенных значений (NaN), преобразуя их в Python None
• Легко читается и интуитивно понятен, что делает код более поддерживаемым

Примечательно, что метод to_list() появился относительно недавно как замена устаревшему методу tolist() (без подчеркивания). Хотя старый метод все еще работает, рекомендуется использовать новый синтаксис для совместимости с будущими версиями Pandas.

Вот несколько типичных сценариев применения to_list():

# Извлечение уникальных значений как список
unique_cities = df['Город'].unique().tolist()

# Фильтрация и затем преобразование в список
young_people = df[df['Возраст'] < 30]['Имя'].to_list()

# Применение агрегирующей функции и преобразование результата
cities_per_age = df.groupby('Возраст')['Город'].apply(list).to_list()

Однако у метода to_list() есть и ограничения. Он может быть не самым эффективным при работе с очень большими датасетами, так как создает копию данных в памяти. Кроме того, он не подходит для прямого извлечения строк DataFrame или работы с многомерными данными.

Мария Соколова, Data Scientist В одном из проектов мне нужно было обработать результаты опроса клиентов, где каждый столбец представлял отдельный вопрос. Данные должны были отправляться в систему аналитики, работающую только с JSON-форматом. Сначала я перебирала DataFrame построчно, но это было катастрофически медленно для 50,000+ ответов. Когда заменила итерации на прямое преобразование столбцов через tolist(), время обработки сократилось с 3 минут до 6 секунд. Клиент был в восторге от того, как быстро теперь обновлялась аналитическая панель! Самое важное, что я поняла: метод tolist() невероятно прост, но при этом решает огромный пласт задач без необходимости изобретать сложные конструкции. Это как швейцарский нож для работы с данными — базовый инструмент, который должен быть в арсенале каждого аналитика.

Использование values.tolist() для работы со строками и столбцами

Метод values.tolist() — это более универсальный подход, позволяющий работать как со столбцами, так и со строками DataFrame, а также с многомерными данными. Это двухэтапный процесс: сначала мы получаем атрибут values, который возвращает numpy-массив, а затем применяем к нему метод tolist(). 🧩

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

import pandas as pd

# Создаем DataFrame
data = {
'Продукт': ['Ноутбук', 'Смартфон', 'Планшет', 'Наушники'],
'Цена': [65000, 35000, 25000, 8000],
'Количество': [10, 25, 15, 40]
}

df = pd.DataFrame(data)

# Получение списка из столбца
prices = df['Цена'].values.tolist()
print(prices)
# Вывод: [65000, 35000, 25000, 8000]

# Получение списка из строки
first_row = df.iloc[0].values.tolist()
print(first_row)
# Вывод: ['Ноутбук', 65000, 10]

# Получение списка списков (вся таблица)
all_data = df.values.tolist()
print(all_data)
# Вывод: [['Ноутбук', 65000, 10], ['Смартфон', 35000, 25], ['Планшет', 25000, 15], ['Наушники', 8000, 40]]

Особенности метода values.tolist():

• Может работать с целым DataFrame, возвращая список списков
• Позволяет легко извлекать данные из отдельных строк
• Преобразует все данные в одномерный или двумерный список в зависимости от исходного объекта
• Может быть применен к результатам сложных запросов и фильтраций

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

# Получение списка только из выбранных столбцов
selected_columns = df[['Продукт', 'Цена']].values.tolist()

# Фильтрация и преобразование в список
expensive_items = df[df['Цена'] > 30000].values.tolist()

# Преобразование результата GroupBy в список
grouped_data = df.groupby('Продукт').sum().values.tolist()

Преимущества и недостатки метода values.tolist() по сравнению с to_list():

Важно отметить, что метод values.tolist() преобразует pandas-объекты в numpy-массивы, прежде чем конвертировать их в списки Python. Это может привести к изменению типов данных в некоторых случаях, особенно для сложных типов или данных смешанных типов.

Применение numpy.ndarray и list() для конвертации данных

Третий подход использует прямую конвертацию numpy-массивов, полученных из DataFrame, в Python-списки с помощью встроенной функции list(). Этот метод предлагает больше гибкости, особенно при работе с многомерными данными, и может быть оптимальным в определённых сценариях. 📈

Рассмотрим основной синтаксис:

import pandas as pd
import numpy as np

# Создаем DataFrame
data = {
'Регион': ['Центр', 'Север', 'Юг', 'Запад', 'Восток'],
'Продажи_Q1': [150, 120, 180, 90, 110],
'Продажи_Q2': [160, 130, 200, 85, 115]
}

df = pd.DataFrame(data)

# Получаем numpy массив из столбца
sales_q1_array = df['Продажи_Q1'].values
print(type(sales_q1_array)) # <class 'numpy.ndarray'>

# Конвертируем numpy массив в список
sales_q1_list = list(sales_q1_array)
print(sales_q1_list) # [150, 120, 180, 90, 110]

# Одним выражением
regions_list = list(df['Регион'].values)
print(regions_list) # ['Центр', 'Север', 'Юг', 'Запад', 'Восток']

# Преобразование всего DataFrame в список списков
all_data_list = [list(row) for row in df.values]
print(all_data_list)
# [['Центр', 150, 160], ['Север', 120, 130], ['Юг', 180, 200], ['Запад', 90, 85], ['Восток', 110, 115]]

Этот подход особенно полезен в следующих сценариях:

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

Интересно, что метод values в Pandas возвращает не просто NumPy-массив, а специальный тип numpy.ndarray. Это даёт доступ к мощным функциям NumPy для манипуляции данными перед финальным преобразованием в список:

# Применение NumPy-функций к массиву перед конвертацией в список
normalized_sales = list((df['Продажи_Q1'].values – df['Продажи_Q1'].values.mean()) / df['Продажи_Q1'].values.std())
print(normalized_sales) # [0\.5345, -0.267, 1.336, -1.336, -0.267] (примерные значения)

# Фильтрация массива перед преобразованием
high_sales_regions = list(df['Регион'].values[df['Продажи_Q1'].values > 120])
print(high_sales_regions) # ['Центр', 'Юг']

# Математические операции с массивами
total_sales = list(df['Продажи_Q1'].values + df['Продажи_Q2'].values)
print(total_sales) # [310, 250, 380, 175, 225]

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

# Транспонирование матрицы данных
transposed_data = [list(column) for column in df.values.T]
print(transposed_data)
# [['Центр', 'Север', 'Юг', 'Запад', 'Восток'], [150, 120, 180, 90, 110], [160, 130, 200, 85, 115]]

# Извлечение подмножества данных
subset = df.iloc[:2, 1:].values
subset_list = [list(row) for row in subset]
print(subset_list) # [[150, 160], [120, 130]]

Стоит отметить, что при использовании numpy.ndarray и list() нужно внимательно следить за типами данных. NumPy может изменить типы некоторых элементов для оптимизации памяти, что иногда может привести к неожиданным результатам при последующем анализе или обработке.

Применение numpy.ndarray и list() для конвертации данных

Еще один мощный способ получения списков из DataFrame — использование метода apply() с функциями и генераторы списков. Эти методы особенно полезны, когда требуется выполнить дополнительные преобразования данных в процессе извлечения. 🛠️

Рассмотрим, как можно использовать метод apply() для конвертации данных:

import pandas as pd

# Создаем DataFrame
data = {
'Товар': ['Футболка', 'Джинсы', 'Куртка', 'Кроссовки'],
'Цена': [1500, 4500, 8000, 5500],
'Скидка': [10, 15, 20, 5]
}

df = pd.DataFrame(data)

# Получение списка с применением функции к каждому значению
# Рассчитываем цену со скидкой
discounted_prices = df.apply(lambda row: row['Цена'] * (1 – row['Скидка']/100), axis=1).tolist()
print(discounted_prices)
# [1350\.0, 3825.0, 6400.0, 5225.0]

# Использование apply для более сложной трансформации
product_info = df.apply(lambda row: f"{row['Товар']} – {row['Цена']} руб. (-{row['Скидка']}%)", axis=1).tolist()
print(product_info)
# ['Футболка – 1500 руб. (-10%)', 'Джинсы – 4500 руб. (-15%)', 'Куртка – 8000 руб. (-20%)', 'Кроссовки – 5500 руб. (-5%)']

Генераторы списков (list comprehension) также могут быть очень полезны для создания списков из DataFrame с дополнительной обработкой:

# Использование генератора списков для создания списка словарей
product_dicts = [{'name': row['Товар'], 'price': row['Цена']} for _, row in df.iterrows()]
print(product_dicts)
# [{'name': 'Футболка', 'price': 1500}, {'name': 'Джинсы', 'price': 4500}, {'name': 'Куртка', 'price': 8000}, {'name': 'Кроссовки', 'price': 5500}]

# Создание вложенных списков с помощью генератора
nested_lists = [[row['Товар'], row['Цена']] for _, row in df.iterrows()]
print(nested_lists)
# [['Футболка', 1500], ['Джинсы', 4500], ['Куртка', 8000], ['Кроссовки', 5500]]

# Фильтрация в процессе создания списка
expensive_items = [row['Товар'] for _, row in df.iterrows() if row['Цена'] > 4000]
print(expensive_items)
# ['Джинсы', 'Куртка', 'Кроссовки']

Преимущества этих подходов:

• Высокая гибкость — возможность выполнять практически любые преобразования данных
• Удобство для сложных трансформаций — можно объединять данные из разных столбцов
• Возможность фильтрации в процессе создания списка
• Поддержка создания сложных структур данных (словари, вложенные списки)

Недостатки:

• Более медленная работа по сравнению с векторизованными методами для больших данных
• Более многословный синтаксис
• Потенциально более высокое использование памяти

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

# Группировка и создание списков для каждой группы
grouped_by_discount = df.groupby('Скидка')['Товар'].apply(list).to_dict()
print(grouped_by_discount)
# {5: ['Кроссовки'], 10: ['Футболка'], 15: ['Джинсы'], 20: ['Куртка']}

# Создание сложных структур с помощью apply
price_ranges = df.apply(
lambda row: {
'товар': row['Товар'],
'диапазон': 'дорого' if row['Цена'] > 5000 else 'средне' if row['Цена'] > 2000 else 'дешево'
}, 
axis=1
).tolist()
print(price_ranges)
# [{'товар': 'Футболка', 'диапазон': 'дешево'}, {'товар': 'Джинсы', 'диапазон': 'средне'}, ...]

Сравнение эффективности методов извлечения списка из DataFrame

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

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

Как видно из таблицы, методы to_list(), values.tolist() и list(values) демонстрируют значительно лучшую производительность, особенно на больших датасетах, по сравнению с методами, использующими apply() или генераторы списков.

Кроме скорости, важно учитывать и другие факторы:

• Использование памяти — некоторые методы создают дополнительные промежуточные объекты
• Типы данных — разные методы могут по-разному обрабатывать специальные типы данных
• Работа с пропущенными значениями — не все методы одинаково обрабатывают NaN
• Читаемость кода — более краткий синтаксис обычно предпочтительнее

Вот несколько практических рекомендаций по выбору метода в зависимости от ситуации:

# Для извлечения одного столбца (лучший вариант по производительности)
df['column'].to_list()

# Для работы со строками DataFrame
df.iloc[0].values.tolist()

# Для извлечения всего DataFrame как списка списков
df.values.tolist()

# Когда нужны промежуточные операции с NumPy
list(df['column'].values * 2)

# Когда требуется сложная трансформация данных
[process(item) for item in df['column']]

Резюмируя вышесказанное, можно дать следующие рекомендации:

1. Для простых задач — используйте to_list() как самый читаемый и достаточно быстрый метод
2. Для работы с целыми строками или DataFrame — применяйте values.tolist()
3. Для сложной обработки числовых данных — комбинируйте NumPy операции с list()
4. Для сложных трансформаций с фильтрацией — используйте генераторы списков, несмотря на более низкую производительность
5. В критичных по производительности сценариях — избегайте методов apply() и итераций по строкам DataFrame

Извлечение списков из DataFrame — это базовая операция, но с глубоким влиянием на работу с данными в Python. Выбирая между различными методами, помните о балансе между читаемостью кода, производительностью и спецификой вашей задачи. Методы to_list() и values.tolist() оптимальны для большинства случаев, но иногда применение NumPy или генераторов списков может дать более гибкие результаты. Освоив эти техники, вы значительно расширите свой инструментарий для эффективной трансформации и анализа данных.