pandas и DataFrame: быстрое руководство

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

Перейти к разделам

• Что такое pandas?
• Что такое DataFrame?
• Как создать DataFrame
• Импорт DataFrame из файлов
• Просмотр и изучение DataFrame
• Добавление и удаление колонок
• Операции над колонками
• Визуализация простых результатов
• Когда pandas не подходит
• Альтернативы
• Методология исследования данных
• Чеклисты для ролей
• Быстрый справочник и примеры кода
• Советы по производительности и совместимости
• Краткая глоссарий и факты

Что такое pandas?

pandas — это популярный модуль Python для анализа и обработки табличных данных. Он предоставляет удобные структуры (Series и DataFrame) и набор методов для импорта, очистки, агрегации и подготовки данных к анализу или визуализации. pandas привлекает специалистов по данным из-за простоты API и интеграции с NumPy, Matplotlib, Seaborn и другими библиотеками.

Краткое определение: DataFrame — двухмерная таблица с индексами строк и именованными колонками. Series — одномерный массив с индексом.

Установка через PyPI:

pip install pandas

Лучше работать в Jupyter Notebook или в интерактивной сессии: это сохраняет историю вычислений и удобнее для экспериментов. IPython полезен в терминале, но ноутбуки дают заметки и визуализации рядом с кодом.

Что такое DataFrame?

DataFrame — основная структура данных в pandas. По структуре это таблица, похожая на лист электронной таблицы или таблицу в базе данных:

• строки — наблюдения (записи);
• колонки — признаки (атрибуты) с именами;
• колонки могут содержать числовые, строковые, булевы значения или временные метки.

DataFrame поддерживает индексирование по меткам и по позициям, объединение таблиц (join/merge), группировки (groupby), фильтрацию и применение функций (apply).

Как создать DataFrame

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

import numpy as np
x = np.linspace(-10, 10)

y = 2 * x + 5

import pandas as pd

df = pd.DataFrame({'x': x, 'y': y})

Советы:

• Используйте короткий псевдоним pd для pandas и np для NumPy.
• Для повторяемости задавайте seed для генераторов случайных чисел, если создаёте случайные наборы.
• Если столбцы имеют разную длину — предварительно приведите их к одной длине или используйте словари Series.

Импорт DataFrame из файлов

Чаще DataFrame создают из внешних источников: CSV, Excel, базы данных, API.

Чтение CSV:

df = pd.read_csv('/path/to/data.csv')

Чтение Excel:

df = pd.read_excel('/path/to/spreadsheet.xls')

Чтение из буфера обмена (удобно для небольших таблиц копирования из таблиц в GUI):

df = pd.read_clipboard()

Чтение конкретного листа в Excel:

df = pd.read_excel('file.xlsx', sheet_name='Sheet1')

Чтение из базы данных (пример с SQLAlchemy):

from sqlalchemy import create_engine
engine = create_engine('sqlite:///my.db')
df = pd.read_sql('SELECT * FROM table_name', engine)

Поддерживаемые форматы включают CSV, Excel, JSON, HTML, SQL, Parquet, Feather. Для больших объёмов стоит рассматривать бинарные форматы (Parquet/Feather) — они быстрее и компактнее.

Просмотр и изучение DataFrame

Основные методы для быстрого знакомства с набором данных:

• df.head(n) — первые n строк (по умолчанию 5);
• df.tail(n) — последние n строк;
• df.shape — кортеж (число строк, число колонок);
• df.columns — список названий колонок;
• df.info() — информация о типах данных и заполненности;
• df.describe() — базовая статистика по числовым колонкам;
• df.dtypes — типы столбцов.

Примеры:

df.head()
df.tail(10)
print(df.shape)
print(df.columns)
df.info()
df.describe()

Доступ к одной колонке:

df['Name']

Если вывод обрезается, используйте:

pd.set_option('display.max_rows', None)

Для точечной выборки значений:

df.loc[5, 'Age']    # по метке индекса

df.iloc[0:3, 1:3]   # по позициям

Срезы строк работают как в обычных списках:

df[1:3]

Примеры с датасетом Titanic

Пример: загрузка и первичный осмотр датасета пассажиров Титаника (часто встречается в примерах и на Kaggle).

titanic = pd.read_csv('data/Titanic-Dataset.csv')

titanic.head()
titanic.columns
titanic.describe()

Интерпретация describe():

• count — количество непустых значений;
• mean — среднее;
• std — стандартное отклонение;
• min, 25%, 50%, 75%, max — пятичисленная сводка (John Tukey).

Выбор одной колонки и её статистика:

titanic['Age'].describe()
titanic['Age'].mean()
titanic['Age'].median()

Если нужно вывести весь столбец (например, длинный список имён):

titanic['Name'].to_string()

Добавление и удаление колонок

Вы можете создавать новые колонки на основе существующих выражений.

Возведение столбца в квадрат:

df['x2'] = df['x'] ** 2

Удаление колонки:

df = df.drop('x2', axis=1)  # axis=1 — по колонкам

Или удалить на месте:

df.drop('x2', axis=1, inplace=True)

Создание колонки с условием:

df['is_positive'] = df['x'] > 0

Преобразования с помощью apply, map, vectorized-подход:

df['log_y'] = np.log(df['y'])
df['category'] = df['value'].map({0: 'zero', 1: 'one'})

Совет: избегайте циклов по строкам. Используйте векторные операции и встроенные методы — это быстрее.

Операции над колонками

Арифметика и статистика по столбцам просты:

df['sum_xy'] = df['x'] + df['y']

subset = titanic[['Name', 'Age']]

Фильтрация (Boolean selection):

adults = titanic[titanic['Age'] > 30]

Это эквивалент SQL-запросу:

SELECT * FROM titanic WHERE Age > 30

Локальный выбор по меткам:

titanic.loc[titanic['Age'] > 30]

Группировка и агрегации:

embarked_counts = titanic['Embarked'].value_counts()
embarked_counts = embarked_counts.rename({'S': 'Southampton', 'C': 'Cherbourg', 'Q': 'Queenstown'})
embarked_counts.plot(kind='bar')

Параметры plot возвращают matplotlib-объект, который можно настраивать дальше.

Визуализация простых результатов

pandas интегрирован с Matplotlib и Seaborn. Для быстрых графиков используйте методы .plot().

Пример столбчатой диаграммы точек посадки пассажиров:

embarked = titanic['Embarked'].value_counts()
embarked = embarked.rename({'S': 'Southampton', 'C': 'Cherbourg', 'Q': 'Queenstown'})
embarked.plot(kind='bar')

Для более продвинутых графиков подключите Seaborn:

import seaborn as sns
sns.histplot(titanic['Age'].dropna(), bins=30)

Когда pandas не подходит — примеры и ограничения

pandas очень удобен, но не всегда отвечает требованиям:

• Очень большие наборы данных (десятки гигабайт и больше) не поместятся в память; pandas работает в памяти и может упираться в RAM.
• Параллельная обработка на нескольких ядрах ограничена GIL и архитектурой; для тяжёлых параллельных задач стоит выбирать другие инструменты.
• Некоторые операции чтения/записи в форматах скин-процессинга (streaming) неудобны.

Контрпримеры:

• Если у вас потоковые данные или данные превышают RAM, использование pandas на локальной машине приведёт к OOM.
• Для операций в режиме реального времени с миллионами событий в секунду нужен стриминговый подход.

Альтернативы и когда выбирать каждую

• Dask — API, совместимый с pandas, поддерживает распределённую обработку и ленивое выполнение. Подходит, если вы хотите переносимость кода pandas на кластеры.
• Polars — современная библиотека на Rust. Быстрее и экономнее по памяти в ряде сценариев. API частично отличается, но есть обёртки.
• Vaex — ориентирован на большие наборы данных, ленивые преобразования и визуализацию без загрузки в RAM.
• Базы данных SQL (Postgres, DuckDB) — удобны для аналитики на диске и для объединения больших таблиц.

Короткая рекомендация:

• До 2–5 ГБ данных на рабочей станции — pandas обычно подходит.
• От 5–50+ ГБ — рассмотрите Dask, Polars или аналитические движки (DuckDB/SQLite) и форматы Parquet.
• Для потоковой обработки — Kafka + stream processing.

Методология исследования данных (мини-метод)

1. Понять задачу и исходные форматы.
2. Загрузить небольшую выборку и посмотреть на df.head() и df.info().
3. Оценить пропуски и типы данных (df.isna().sum(), df.dtypes).
4. Привести типы к подходящим (to_datetime, astype).
5. Удалить/заполнить пропуски и аномальные значения.
6. Создать вспомогательные признаки (feature engineering).
7. Провести агрегаты и визуализации для проверки гипотез.
8. Сохранить итог в подходящем формате (Parquet/CSV/SQL).

Чеклисты для ролей

Аналитик:

• Загрузил данные, посмотрел на df.info().
• Проверил пропуски и распределения.
• Составил краткий отчёт с графиками.

Инженер данных:

• Автоматизировал загрузку и валидацию.
• Настроил хранение в Parquet и версионирование.
• Обеспечил тесты качества данных.

Data Scientist:

• Подготовил обучающую выборку.
• Сделал feature engineering и трансформации.
• Обеспечил воспроизводимость (seed, ноутбук, скрипты).

Быстрый справочник и приёмы (cheat sheet)

Основные операции:

df.columns            # список колонок

df.shape              # (n_rows, n_cols)

df.head(10)

df.info()

df.describe()

# Фильтрация
adults = df[df['Age'] > 30]

# Группировка
sales_by_month = df.groupby('month')['amount'].sum()

# Объединение таблиц
merged = pd.merge(left, right, on='id', how='inner')

# Сохранение
df.to_parquet('out.parquet')

Советы по отладке:

• Используйте df.sample(n=5) чтобы посмотреть случайные строки.
• df.value_counts() для частотных распределений категорий.
• df.drop_duplicates() для удаления дубликатов.

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

• Уменьшите память, приведя типы: astype('category') для категорий, точные типы для целых чисел.
• Читайте только нужные колонки pd.read_csv(usecols=['a','b']).
• Для больших наборов используйте Parquet/Feather — бинарные форматы работают быстрее.
• Применяйте векторные операции вместо .apply() с Python-функциями.
• Рассмотрите chunked reading (chunksize=) для построчной обработки больших CSV.
• Для многопоточной или распределённой обработки рассматривайте Dask/Polars.

Совместимость и миграция

• Файлы CSV совместимы почти везде, но могут быть медленными и терять метаданные типов.
• Parquet сохраняет схемы и эффективен для аналитики; хорошо подходит для передачи между системами.
• При миграции на Polars или Dask проверяйте корректность типов и поведения groupby.
• pandas API эволюционирует — проверяйте релиз-ноты при обновлении (особенно для pd.concat, merge и groupby).

Конфиденциальность и безопасность данных

• При работе с персональными данными соблюдайте локальные правила и GDPR: минимизируйте хранение персональных сведений, анонимизируйте или псевдонимизируйте данные.
• Не коммитьте личные или секретные данные в публичные репозитории.
• Шифруйте резервные копии баз данных и файлов.

Краткая галерея часто встречающихся ошибок

• Ошибка MemoryError при чтении большого CSV — использовать chunksize или Parquet.
• Неправильное сравнение строк с NaN — NaN != NaN, используйте pd.isna().
• Ошибка при конкатенации с разными типами столбцов — приведите к общему типу.

Факт-бокс: что важно помнить

• DataFrame — двумерная таблица (строки × колонки).
• pandas хранит данные в памяти; ограничение — объём RAM.
• Parquet и Feather — рекомендуемые форматы для больших наборов.
• Dask и Polars — основные альтернативы для масштабирования.

Короткий глоссарий (1 строка на термин)

• Series — одномерный массив с индексом в pandas.
• DataFrame — двумерная таблица с индексом строк и именованными колонками.
• index — метки строк в DataFrame.
• groupby — операция группировки и агрегации.
• parquet — колонно-ориентированный бинарный формат для аналитики.

Decision tree для выбора инструмента

flowchart TD
  A[Набор данных] --> B{Размер данных}
  B -->|Меньше RAM| C[pandas]
  B -->|Больше RAM| D{Понадобится ли распределение}
  D -->|Нет| E[Polars / DuckDB]
  D -->|Да| F[Dask / Spark]
  C --> G[Использовать Parquet для хранения]
  E --> G
  F --> G

Шаблон рабочего процесса (SOP) для исследования набора данных

1. Скопировать исходный файл в безопасное место и версионировать.
2. Загрузить небольшой сэмпл (1–10%) и выполнить df.info() и df.describe().
3. Проверить пропуски, типы и дубликаты.
4. Записать план трансформаций (обрезать колонки, заполнение пропусков).
5. Реализовать трансформации в ноутбуке/скрипте и сохранить результирующие данные в Parquet.
6. Провести визуализации и документировать наблюдения.
7. Подготовить итоговый набор для моделирования или отчёта.

Примеры кода и приёмы (полезные сниппеты)

Фильтрация и вывод нескольких колонок:

titanic[['Name','Age']][titanic['Age'] > 30]

Удаление колонок на месте:

df.drop(['col1', 'col2'], axis=1, inplace=True)

Сохранение итогового датафрейма:

df.to_parquet('cleaned_data.parquet')

Чтение частями:

for chunk in pd.read_csv('big.csv', chunksize=100000):
    process(chunk)

Итог и рекомендации

pandas остаётся универсальным инструментом для интерактивного исследования данных и подготовки входа для моделей и визуализаций. Он удобен для среднего объёма данных и прост в изучении. Для больших объёмов и требований к параллельности рассмотрите Dask, Polars или базы данных (DuckDB, Postgres). Всегда проверяйте типы данных, пропуски и конфиденциальность перед публикацией или совместным использованием результатов.

Важно

• Сохраняйте промежуточные результаты в надежном формате (Parquet).
• Документируйте шаги очистки и трансформации.

Надеюсь, это руководство поможет вам быстро начать работу с pandas и эффективно исследовать ваши наборы данных.