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

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

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

• Профессионалы, ищущие способы оптимизации работы с табличными данными и улучшения своих навыков программирования

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

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

Что такое pandas DataFrame: основы и преимущества

DataFrame — это двумерная структура данных с маркированными осями (строками и столбцами), которая может содержать данные различных типов. По сути, это электронная таблица или база данных SQL в памяти компьютера. Ключевое преимущество DataFrame — его гибкость: вы можете выполнять сложные операции с данными всего несколькими строками кода.

Александр Петров, ведущий аналитик данных

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

Помню случай, когда мне нужно было срочно подготовить отчёт по динамике заболеваемости, а данные были разбросаны по разным переменным. Использование правильного метода конструирования DataFrame сэкономило мне часы работы — я смог быстро объединить временные ряды из словарей с метаданными из списков, и затем применить групповые операции для анализа.

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

Основные характеристики DataFrame:

• Двумерность: данные представлены в формате строк и столбцов
• Разнотипность: каждый столбец может содержать данные своего типа
• Маркированные оси: как строки, так и столбцы имеют метки (индексы)
• Выравнивание данных: автоматическое выравнивание данных при операциях
• Интеграция с SQL: простота импорта/экспорта данных из/в SQL

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

Теперь, когда мы понимаем, что такое DataFrame и почему он так полезен, давайте перейдем к различным способам его создания из существующих переменных в Python. 🚀

Создание DataFrame из словарей: синтаксис и варианты

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

Давайте рассмотрим основные способы:

1. Словарь списков — самый распространенный метод, где каждому ключу соответствует список значений:

import pandas as pd

data = {
'имя': ['Анна', 'Борис', 'Вера', 'Григорий'],
'возраст': [25, 32, 28, 41],
'зарплата': [75000, 90000, 82000, 120000],
'опыт_работы': [2, 5, 3, 10]
}

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

Вывод будет иметь такую структуру:

имя возраст зарплата опыт_работы
0 Анна 25 75000 2
1 Борис 32 90000 5
2 Вера 28 82000 3
3 Григорий 41 120000 10

2. Список словарей — альтернативный подход, где каждый словарь представляет строку данных:

records = [
{'имя': 'Анна', 'возраст': 25, 'зарплата': 75000, 'опыт_работы': 2},
{'имя': 'Борис', 'возраст': 32, 'зарплата': 90000, 'опыт_работы': 5},
{'имя': 'Вера', 'возраст': 28, 'зарплата': 82000, 'опыт_работы': 3},
{'имя': 'Григорий', 'возраст': 41, 'зарплата': 120000, 'опыт_работы': 10}
]

df_from_records = pd.DataFrame(records)
print(df_from_records)

3. Словарь словарей — для создания DataFrame, где внешние ключи становятся индексами:

nested_dict = {
'работник1': {'имя': 'Анна', 'возраст': 25, 'зарплата': 75000},
'работник2': {'имя': 'Борис', 'возраст': 32, 'зарплата': 90000},
'работник3': {'имя': 'Вера', 'возраст': 28, 'зарплата': 82000}
}

df_nested = pd.DataFrame(nested_dict)
# Транспонируем для получения более привычного вида
df_nested = df_nested.T
print(df_nested)

Вывод будет таким:

имя возраст зарплата
работник1 Анна 25 75000
работник2 Борис 32 90000
работник3 Вера 28 82000

Дополнительные параметры при создании DataFrame из словарей:

• index: Установка пользовательских индексов строк
• columns: Явное задание порядка или названий столбцов
• dtype: Определение типов данных для столбцов

Пример с дополнительными параметрами:

df_with_params = pd.DataFrame(
data,
index=['employee1', 'employee2', 'employee3', 'employee4'],
columns=['имя', 'возраст', 'зарплата'], # исключаем столбец опыт_работы
dtype=float # преобразуем все числовые значения к типу float
)
print(df_with_params)

Вывод:

имя возраст зарплата
employee1 Анна 25.0 75000.0
employee2 Борис 32.0 90000.0
employee3 Вера 28.0 82000.0
employee4 Григорий 41.0 120000.0

Выбор конкретного метода зависит от структуры исходных данных и требований к конечному DataFrame. Словарные структуры особенно удобны при работе с данными из JSON-источников или при необходимости явного указания имён столбцов. 🧠

Преобразование списков и кортежей в DataFrame

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

Марина Соколова, старший специалист по машинному обучению

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

Долгое время я обрабатывала эти данные используя циклы и условные операторы, что делало код громоздким и трудным для отладки. Всё изменилось, когда я освоила методы преобразования списков в DataFrame.

Особенно полезным оказался метод с явным указанием столбцов. Благодаря одной строке кода: df = pd.DataFrame(data_list, columns=['время', 'температура', 'давление', 'влажность']) я смогла превратить сырые данные в структурированную таблицу и сразу же приступить к анализу корреляций между параметрами.

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

Рассмотрим различные способы преобразования списков и кортежей в DataFrame:

1. Список списков (двумерный массив)

Самый прямолинейный способ — передать двумерный список (список списков) в конструктор DataFrame. По умолчанию pandas создаст числовые индексы для строк и столбцов.

import pandas as pd

# Двумерный список (список списков)
data_list = [
['Яблоко', 120, 'Фрукт'],
['Банан', 80, 'Фрукт'],
['Морковь', 60, 'Овощ'],
['Картофель', 40, 'Овощ']
]

# Создание DataFrame без указания имен столбцов
df1 = pd.DataFrame(data_list)
print("DataFrame без имен столбцов:")
print(df1)

# Создание DataFrame с указанием имен столбцов
df2 = pd.DataFrame(data_list, columns=['Продукт', 'Калории', 'Категория'])
print("\nDataFrame с именами столбцов:")
print(df2)

Вывод будет выглядеть так:

DataFrame без имен столбцов:
0 1 2
0 Яблоко 120 Фрукт
1 Банан 80 Фрукт
2 Морковь 60 Овощ
3 Картофель 40 Овощ

DataFrame с именами столбцов:
Продукт Калории Категория
0 Яблоко 120 Фрукт
1 Банан 80 Фрукт
2 Морковь 60 Овощ
3 Картофель 40 Овощ

2. Список кортежей

Аналогично можно использовать список кортежей — это особенно удобно, когда данные уже структурированы и не требуют изменений.

# Список кортежей
data_tuples = [
('Москва', 12692466, 2561.5),
('Санкт-Петербург', 5398064, 1439.0),
('Новосибирск', 1612833, 502.7),
('Екатеринбург', 1493749, 468.0)
]

df_cities = pd.DataFrame(data_tuples, columns=['Город', 'Население', 'Площадь'])
print(df_cities)

3. Транспонирование списка

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

# Данные организованы по столбцам
names = ['Анна', 'Иван', 'Мария', 'Петр']
ages = [25, 30, 22, 35]
cities = ['Москва', 'Казань', 'Сочи', 'Омск']

# Транспонирование с помощью zip
transposed_data = list(zip(names, ages, cities))
df_transposed = pd.DataFrame(transposed_data, columns=['Имя', 'Возраст', 'Город'])
print(df_transposed)

4. Использование списка для одного столбца

Если у вас есть простой список, который нужно преобразовать в один столбец DataFrame:

# Простой список
temperatures = [22\.5, 23.1, 24.0, 22.8, 23.9]

# Преобразование в DataFrame с одним столбцом
df_temp = pd.DataFrame(temperatures, columns=['Температура'])
print(df_temp)

# Альтернативный способ с использованием словаря
df_temp_alt = pd.DataFrame({'Температура': temperatures})
print("\nТот же результат через словарь:")
print(df_temp_alt)

5. Работа с вложенными структурами

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

# Вложенная структура: список списков с неоднородной длиной
complex_data = [
['Проект A', 2021, ['Иван', 'Мария']],
['Проект B', 2022, ['Анна']],
['Проект C', 2021, ['Петр', 'Алексей', 'Елена']]
]

# Предобработка для создания однородной структуры
processed_data = []
for project, year, team in complex_data:
processed_data.append([project, year, ', '.join(team)])

df_projects = pd.DataFrame(processed_data, columns=['Проект', 'Год', 'Команда'])
print(df_projects)

Практические рекомендации при работе со списками и кортежами:

• Всегда указывайте имена столбцов для лучшей читаемости и документирования
• Используйте параметр dtype для явного контроля типов данных
• Для больших наборов данных предпочтительнее создавать DataFrame из словарей или numpy массивов
• При работе с неоднородными списками выполняйте предварительную обработку перед преобразованием
• Помните, что списки и кортежи в Python начинаются с индекса 0, так же как и строки в DataFrame

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

Использование numpy массивов для построения DataFrame

NumPy — фундаментальная библиотека для научных вычислений в Python, обеспечивающая высокопроизводительную работу с многомерными массивами. Интеграция numpy с pandas позволяет эффективно преобразовывать массивы в DataFrame, особенно когда речь идет о больших объемах данных или сложных математических операциях.

Давайте рассмотрим различные способы создания DataFrame из numpy массивов:

1. Базовое преобразование одномерного массива

Самый простой случай — преобразование одномерного массива в DataFrame с одним столбцом:

import pandas as pd
import numpy as np

# Создаем одномерный массив
array_1d = np.array([10, 20, 30, 40, 50])

# Преобразуем в DataFrame
df_1d = pd.DataFrame(array_1d, columns=['значение'])
print(df_1d)

Вывод:

значение
0 10
1 20
2 30
3 40
4 50

2. Двумерные массивы (матрицы)

Двумерные массивы естественным образом соответствуют структуре DataFrame:

# Создаем двумерный массив (матрицу)
array_2d = np.array([
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]
])

# Базовое преобразование
df_2d = pd.DataFrame(array_2d)
print("Базовое преобразование:")
print(df_2d)

# С заданием имен столбцов
df_2d_named = pd.DataFrame(
array_2d,
columns=['A', 'B', 'C', 'D']
)
print("\nС именами столбцов:")
print(df_2d_named)

# С заданием индексов и имен столбцов
df_2d_full = pd.DataFrame(
array_2d,
index=['row1', 'row2', 'row3'],
columns=['col1', 'col2', 'col3', 'col4']
)
print("\nС индексами и именами столбцов:")
print(df_2d_full)

3. Использование структурированных массивов numpy

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

# Создаем структурированный массив
structured_array = np.array([
('Анна', 28, 72.5),
('Борис', 34, 83.1),
('Вера', 29, 68.0),
('Григорий', 42, 90.2)
],
dtype=[('name', 'U10'), ('age', 'i4'), ('weight', 'f4')]
)

# Преобразуем в DataFrame
df_structured = pd.DataFrame(structured_array)
print(df_structured)

4. Генерация случайных данных с numpy

NumPy отлично подходит для генерации тестовых данных, которые затем можно преобразовать в DataFrame:

# Генерируем случайные числа
np.random.seed(42) # для воспроизводимости результатов
random_data = np.random.randn(5, 3) # 5 строк, 3 столбца

# Преобразуем в DataFrame
df_random = pd.DataFrame(
random_data,
columns=['A', 'B', 'C']
)
print("Случайные данные:")
print(df_random)

# Округление до 2 знаков после запятой для читаемости
df_random_rounded = df_random.round(2)
print("\nОкругленные значения:")
print(df_random_rounded)

5. Расширенные возможности с использованием функций numpy

Использование функций numpy перед преобразованием в DataFrame позволяет создавать сложные структуры данных:

# Создаем сетку значений с помощью meshgrid
x = np.linspace(0, 5, 6) # 6 равномерно распределенных точек от 0 до 5
y = np.linspace(0, 5, 6)
X, Y = np.meshgrid(x, y)

# Вычисляем значение функции z = sin(x) * cos(y)
Z = np.sin(X) * np.cos(Y)

# Преобразуем в "длинный" формат для DataFrame
points = np.column_stack([X.flatten(), Y.flatten(), Z.flatten()])
df_grid = pd.DataFrame(points, columns=['X', 'Y', 'Z'])
print("Первые 5 строк сетки значений:")
print(df_grid.head())

Сравнение производительности при работе с большими данными:

Когда стоит использовать numpy массивы для создания DataFrame:

• При работе с большими объемами числовых данных (миллионы строк)
• Когда требуется выполнить сложные векторизованные операции до создания DataFrame
• Если данные получены из научных приборов или библиотек, работающих с numpy
• При необходимости оптимизации памяти (numpy более эффективен по сравнению с обычными списками)
• Когда требуется генерация тестовых данных определенной структуры

NumPy и pandas прекрасно дополняют друг друга: NumPy обеспечивает эффективную работу с низкоуровневыми массивами данных, а pandas добавляет высокоуровневые функции для анализа данных. Такая интеграция делает процесс обработки данных более гибким и производительным. 🧮

Формирование pandas DataFrame из существующих Series

Series — это одномерная структура данных в pandas, подобная столбцу в DataFrame. Объединение нескольких Series в DataFrame — мощный и гибкий способ конструирования табличных данных, особенно когда информация поступает из разных источников или обрабатывается по частям.

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

1. Базовое объединение Series в DataFrame

Самый простой способ — использовать Series как значения в словаре:

import pandas as pd

# Создаем несколько Series
names = pd.Series(['Анна', 'Борис', 'Вера', 'Григорий', 'Дмитрий'])
ages = pd.Series([25, 32, 28, 41, 36])
salaries = pd.Series([75000, 90000, 82000, 120000, 95000])
departments = pd.Series(['Маркетинг', 'IT', 'Финансы', 'Управление', 'Продажи'])

# Объединяем Series в DataFrame
df = pd.DataFrame({
'Имя': names,
'Возраст': ages,
'Зарплата': salaries,
'Отдел': departments
})

print(df)

Вывод:

Имя Возраст Зарплата Отдел
0 Анна 25 75000 Маркетинг
1 Борис 32 90000 IT
2 Вера 28 82000 Финансы
3 Григорий 41 120000 Управление
4 Дмитрий 36 95000 Продажи

2. Использование функции concat для объединения Series в DataFrame

Функция pd.concat позволяет объединять Series по строкам (axis=0) или по столбцам (axis=1):

# Объединяем Series по столбцам с помощью concat
df_concat = pd.concat([names, ages, salaries, departments], axis=1)
df_concat.columns = ['Имя', 'Возраст', 'Зарплата', 'Отдел'] # Задаем имена столбцов

print(df_concat)

3. Работа с Series с разными индексами

Когда Series имеют разные индексы, pandas автоматически выравнивает данные, заполняя отсутствующие значения NaN:

# Создаем Series с разными индексами
s1 = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
s2 = pd.Series([4, 5, 6, 7], index=['b', 'c', 'd', 'e'])
s3 = pd.Series([8, 9], index=['a', 'e'])

# Объединяем в DataFrame
df_mixed = pd.DataFrame({'S1': s1, 'S2': s2, 'S3': s3})
print("DataFrame с разными индексами:")
print(df_mixed)

Вывод:

DataFrame с разными индексами:
S1 S2 S3
a 1.0 NaN 8.0
b 2.0 4.0 NaN
c 3.0 5.0 NaN
d NaN 6.0 NaN
e NaN 7.0 9.0

4. Добавление Series к существующему DataFrame

Можно добавить новый столбец к DataFrame, используя Series:

# Создаем базовый DataFrame
base_df = pd.DataFrame({
'A': [1, 2, 3, 4],
'B': [10, 20, 30, 40]
})

# Создаем Series для добавления
new_column = pd.Series([100, 200, 300, 400], name='C')

# Способ 1: Присваивание
base_df['C'] = new_column
print("После добавления столбца C:")
print(base_df)

# Способ 2: Использование join или merge
another_series = pd.Series([5, 6, 7, 8], index=base_df.index, name='D')
result_df = base_df.join(another_series)
print("\nПосле добавления столбца D с join:")
print(result_df)

5. Преобразование вложенных Series в DataFrame

Иногда Series может содержать структурированные данные, которые можно развернуть в DataFrame:

# Создаем Series, содержащую словари
complex_series = pd.Series([
{'name': 'Анна', 'age': 25, 'city': 'Москва'},
{'name': 'Борис', 'age': 32, 'city': 'Санкт-Петербург'},
{'name': 'Вера', 'age': 28, 'city': 'Казань'}
])

# Преобразуем в DataFrame
df_from_complex = pd.DataFrame(complex_series.tolist())
print("DataFrame из вложенной Series:")
print(df_from_complex)

Преимущества работы с Series перед преобразованием в DataFrame:

• Поэтапная обработка: Можно очищать и трансформировать каждую Series независимо
• Гибкость с индексами: Series позволяют использовать различные индексы до объединения
• Легкое добавление новых данных: Новые Series можно легко добавлять к существующему DataFrame
• Статистические операции: Над Series можно выполнять векторизованные операции перед объединением
• Обработка временных рядов: Series идеально подходят для временных рядов, которые затем можно объединить

Практические советы по работе с Series:

• Если Series будут объединены в DataFrame, стоит сразу задавать им имена с помощью параметра name
• При объединении Series с различными индексами используйте параметры join='inner' или join='outer' для контроля результата
• Для Series с временными метками полезно использовать методы resample() или asfreq() перед объединением
• При работе с большими данными рассмотрите возможность использования категориальных типов данных для Series
• Функция pd.concat() предоставляет больше контроля над процессом объединения, чем простое создание DataFrame из словаря

Формирование DataFrame из Series — это элегантный способ создания табличных структур из разрозненных данных. Такой подход особенно полезен при потоковой обработке данных или когда данные поступают асинхронно из разных источников. 📊

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