Учебник по Python pandas: полное руководство для начинающих

Установка pandas

Установите pandas командой pip install в терминале. pandas 3 требует Python 3.11 или новее; на более старом Python pip установит последнюю доступную для него версию pandas 2.x.

pip install pandasРаботает на

Либо установите через conda:

conda install pandasРаботает на

После установки pandas полезно проверить установленную версию, чтобы убедиться, что всё работает корректно:

import pandas as pd
print(pd.__version__)  # Prints the pandas versionРаботает на

Это подтверждает корректную установку pandas и позволяет проверить совместимость с другими пакетами.

Что изменилось в pandas 3.0 и 3.1

pandas 3.0, выпущенный в январе 2026 года, изменил поведение копий, строк и присваивания, а pandas 3.1 (октябрь 2026) объявил устаревшим большинство случаев использования inplace=True. Код из старых учебников в основном по-прежнему работает, но четыре изменения часто приводят к ошибкам:

• Copy-on-Write по умолчанию. Любое подмножество или результат метода ведёт себя как копия, поэтому изменение его не меняет исходный DataFrame. SettingWithCopyWarning исчез, как и необходимость в защитных вызовах .copy().
• Цепочное присваивание больше не работает. df["Age"][0] = 35 обновляет временную копию и оставляет df без изменений, при этом pandas выдаёт ChainedAssignmentError. Вместо этого используйте один вызов .loc[].
• Строки имеют собственный тип данных. Текстовые столбцы теперь определяются как str вместо object и используют PyArrow при его наличии.
• inplace=True устарел для sort_values(), reset_index(), dropna(), drop_duplicates(), rename() и ряда других методов. Вместо этого переназначайте результат: df = df.dropna().

Вот пример изменения цепочного присваивания на небольшом DataFrame:

import pandas as pd

patients = pd.DataFrame({"name": ["Ana", "Ben", "Chloe"], "age": [34, 51, 28]})

patients["age"][0] = 35      # chained assignment: patients is not changed
patients.loc[0, "age"] = 35  # a single .loc[] call: patients is updated
print(patients.dtypes)Работает на

name      str
age     int64
dtype: objectРаботает на

Каждый пример в этом руководстве следует правилам pandas 3. Полный список изменений см. в официальных заметках о выпуске для pandas 3.0 и pandas 3.1. Если вы поддерживаете старый код, наше руководство по SettingWithCopyWarning объясняет поведение, которое заменил Copy-on-Write.

Импорт данных в pandas

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

import pandas as pdРаботает на

Импорт CSV-файлов

Используйте read_csv() с путём к CSV-файлу для чтения файла с разделителями-запятыми (подробнее см. в нашем руководстве по импорту данных с помощью read_csv()).

df = pd.read_csv("diabetes.csv")Работает на

Эта операция загружает файл CSV diabetes.csv в DataFrame pandas с именем df. В течение этого учебника мы используем датасет Pima Indians Diabetes: 768 пациентов, восемь показателей здоровья, таких как Glucose, BMI и Age, и столбец Outcome, где 1 означает, что у пациента диагностирован диабет.

Импорт текстовых файлов

Чтение текстовых файлов похоже на CSV. Единственный нюанс — нужно указать разделитель аргументом sep, как показано ниже. Разделитель — это символ, который разделяет значения (столбцы) в каждой строке. Наиболее распространены запятая (sep=","), табуляция (sep="\t"), двоеточие (sep=":") и пробелы (sep=r"\s+"). r"\s+" — это регулярное выражение, соответствующее одному или более пробельным символам; префикс r делает это «сырым» строковым литералом, чтобы Python не трактовал \s как недопустимую escape-последовательность.

df = pd.read_csv("diabetes.txt", sep=r"\s+")Работает на

Импорт файлов Excel (один лист)

Читайте файлы Excel с помощью функции read_excel(), передавая путь к файлу. pandas нужен дополнительный движок для Excel: установите openpyxl для файлов .xlsx или xlrd для устаревших .xls.

df = pd.read_excel('diabetes.xlsx')Работает на

Можно указать и другие аргументы, например header — какая строка станет заголовком DataFrame. По умолчанию это 0, то есть первая строка — имена столбцов. Также можно явно задать имена столбцов списком в аргументе names. Аргумент index_col (по умолчанию None) используется, если в файле есть строковый индекс.

Примечание: В DataFrame или Series pandas индекс — это идентификатор, указывающий на расположение строки или столбца. Проще говоря, индекс подписывает строки или столбцы DataFrame и позволяет обращаться к конкретной строке или столбцу по индексу (вы увидите это далее). Индекс строк DataFrame может быть диапазоном (например, от 0 до 303), временным рядом (даты или метки времени), уникальным идентификатором (например, employee_ID в таблице employees) или другими типами данных. Для столбцов это обычно строка (имя столбца).

Импорт файлов Excel (несколько листов)

Чтение Excel с несколькими листами почти не отличается. Нужно лишь указать дополнительный аргумент sheet_name, куда можно передать строку с именем листа или целое число с позицией листа (учтите, что Python использует нумерацию с нуля, поэтому к первому листу обращаются как sheet_name = 0)

# Извлекаем второй лист, так как Python нумерует с нуля
df = pd.read_excel('diabetes_multi.xlsx', sheet_name=1)Работает на

Импорт JSON-файла

Аналогично функции read_csv() можно использовать read_json() для JSON-файлов, передавая имя JSON-файла в качестве аргумента (подробнее см. это руководство по импорту JSON и HTML в pandas). Код ниже читает JSON с диска и создаёт объект DataFrame df.

df = pd.read_json("diabetes.json")Работает на

Если хотите больше узнать об импорте данных с помощью pandas, посмотрите этот шпаргалку по импорту различных типов файлов в Python. 

Импорт данных из SQL-баз

Чтобы загрузить данные из реляционной базы, используйте pd.read_sql() вместе с соединением к базе.

import sqlite3

# Устанавливаем соединение с базой SQLite
conn = sqlite3.connect("my_database.db")

# Читаем данные из таблицы
df = pd.read_sql("SELECT * FROM my_table", conn)Работает на

Для других баз, таких как PostgreSQL или MySQL, передавайте движок SQLAlchemy вместо соединения sqlite3. Для больших таблиц установите аргумент chunksize, чтобы читать результат порциями.

Импорт данных из API (JSON)

Если ваши данные приходят из веб-API, pandas может читать их напрямую с помощью pd.read_json():

df = pd.read_json("https://api.example.com/data.json")Работает на

Если ответ API — вложенный JSON, расплющите его с помощью pd.json_normalize(), который превращает вложенные ключи в столбцы с точечной нотацией:

records = [
    {"id": 1, "vitals": {"glucose": 148, "bmi": 33.6}},
    {"id": 2, "vitals": {"glucose": 85, "bmi": 26.6}},
]
pd.json_normalize(records)Работает на

   id  vitals.glucose  vitals.bmi
0   1             148        33.6
1   2              85        26.6Работает на

Экспорт данных в pandas

Точно так же, как pandas может импортировать данные из разных форматов, он позволяет экспортировать их в различные форматы. Это особенно полезно, когда вы преобразовали данные с помощью pandas и хотите сохранить их локально. Ниже показано, как выгружать DataFrame pandas в разные форматы.

Выгрузка DataFrame в CSV

DataFrame pandas (здесь мы используем df) сохраняется в CSV-файл методом .to_csv(). Передайте путь к файлу и установите index=False, если вам не нужен индекс строк в файле (по умолчанию index=True запишет его отдельным безымянным столбцом). Наше руководство по сохранению DataFrame в CSV покрывает другие аргументы.

df.to_csv("diabetes_out.csv", index=False)Работает на

Выгрузка DataFrame в JSON

Экспортируйте объект DataFrame в JSON-файл, вызвав метод .to_json().

df.to_json("diabetes_out.json")Работает на

Примечание: JSON хранит табличный объект вроде DataFrame как набор пар ключ—значение. Поэтому в JSON-файле вы увидите повторяющиеся заголовки столбцов.

Выгрузка DataFrame в текстовый файл

Как и при записи DataFrame в CSV, можно вызвать .to_csv(). Отличия только в том, что формат вывода — .txt, и нужно указать разделитель аргументом sep.

df.to_csv('diabetes_out.txt', header=df.columns, index=None, sep=' ')Работает на

Выгрузка DataFrame в Excel

Вызовите .to_excel() у DataFrame, чтобы сохранить его в файл .xlsx (для этого нужен openpyxl). pandas больше не может записывать устаревшие файлы .xls.

df.to_excel("diabetes_out.xlsx", index=False)Работает на

Просмотр и понимание DataFrame в pandas

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

Как просматривать данные с помощью .head() и .tail()

Вы можете увидеть первые или последние несколько строк DataFrame с помощью методов .head() или .tail() соответственно. Число строк задаётся аргументом n (по умолчанию 5).

df.head()Работает на

Первые пять строк DataFrame 

df.tail(n = 10)Работает на

Последние 10 строк DataFrame

Понимание данных с помощью .describe()

Метод .describe() печатает сводную статистику по всем числовым столбцам: количество, среднее, стандартное отклонение, диапазон и квартиля числовых столбцов.

df.describe()Работает на

Получение сводной статистики с .describe()

Это даёт быстрый взгляд на масштаб, асимметрию и диапазон числовых данных.

Также можно изменить набор перцентилей с помощью аргумента percentiles. Здесь, например, мы смотрим на 30%, 50% и 70% перцентили числовых столбцов DataFrame df.

df.describe(percentiles=[0.3, 0.5, 0.7])Работает на

Получение сводной статистики для заданных перцентилей 

Можно изолировать конкретные типы данных в сводном выводе с помощью аргумента include. Здесь, например, мы суммируем только столбцы типа integer. 

df.describe(include=[int])Работает на

Сводная статистика только по целочисленным столбцам 

Аналогично, вы можете исключить определённые типы данных с помощью аргумента exclude.

df.describe(exclude=[int])Работает на

              BMI  DiabetesPedigreeFunction
count  768.000000                768.000000
mean    31.992578                  0.471876
std      7.884160                  0.331329
min      0.000000                  0.078000
25%     27.300000                  0.243750
50%     32.000000                  0.372500
75%     36.600000                  0.626250
max     67.100000                  2.420000Работает на

Часто практикам удобнее просматривать такую статистику в транспонированном виде с помощью атрибута .T.

df.describe().TРаботает на

Транспонирование сводной статистики с .T

Подробнее о методах описания DataFrame — в следующей шпаргалке.

Понимание данных с помощью .info()

Метод .info() — это быстрый способ посмотреть типы данных, пропуски и размер DataFrame. Здесь мы устанавливаем аргумент show_counts в True, чтобы показать количество непустых значений в каждом столбце. Также устанавливаем memory_usage в True, чтобы увидеть общий объём памяти, занимаемый элементами DataFrame. При verbose=True выводится полный отчёт .info(). 

df.info(show_counts=True, memory_usage=True, verbose=True)Работает на

<class 'pandas.DataFrame'>
RangeIndex: 768 entries, 0 to 767
Data columns (total 9 columns):
 #   Column                    Non-Null Count  Dtype  
---  ------                    --------------  -----  
 0   Pregnancies               768 non-null    int64  
 1   Glucose                   768 non-null    int64  
 2   BloodPressure             768 non-null    int64  
 3   SkinThickness             768 non-null    int64  
 4   Insulin                   768 non-null    int64  
 5   BMI                       768 non-null    float64
 6   DiabetesPedigreeFunction  768 non-null    float64
 7   Age                       768 non-null    int64  
 8   Outcome                   768 non-null    int64  
dtypes: float64(2), int64(7)
memory usage: 54.1 KBРаботает на

Понимание данных с помощью .shape

Число строк и столбцов DataFrame можно узнать через атрибут .shape. Он возвращает кортеж (строки, столбцы), и его можно индексировать, чтобы получить только количество строк или только количество столбцов.

df.shape # Получить число строк и столбцов
df.shape[0] # Получить только число строк
df.shape[1] # Получить только число столбцовРаботает на

(768,9)
768
9Работает на

Получение всех столбцов и их названий

Вызов атрибута .columns у объекта DataFrame возвращает имена столбцов в виде объекта Index. Напомним, индекс pandas — это адрес/метка строки или столбца.

df.columnsРаботает на

Index(['Pregnancies', 'Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI',
       'DiabetesPedigreeFunction', 'Age', 'Outcome'],
      dtype='str')Работает на

Его можно преобразовать в список функцией list().

list(df.columns)Работает на

['Pregnancies',
 'Glucose',
 'BloodPressure',
 'SkinThickness',
 'Insulin',
 'BMI',
 'DiabetesPedigreeFunction',
 'Age',
 'Outcome']Работает на

Проверка пропусков в pandas с помощью .isnull()

В примере DataFrame нет пропусков. Давайте введём несколько, чтобы было интереснее. Метод .copy() делает копию исходного DataFrame. Работа с копией сохраняет исходный df нетронутым для следующих примеров. С помощью .loc (рассмотрим позже) вы можете поставить пропуски в строках с метками с 2 по 5 в столбце Pregnancies. Поскольку пропуски хранятся как NaN (float), pandas конвертирует столбец из int64 в float64.

df2 = df.copy()
df2.loc[2:5,'Pregnancies'] = None
df2.head(7)Работает на

Как видно, теперь строки 2–5 содержат NaN

Вы можете проверить, является ли каждый элемент DataFrame пропущенным, с помощью метода .isnull().

df2.isnull().head(7)Работает на

Поскольку чаще полезнее знать объём пропусков, можно объединить .isnull() с .sum(), чтобы посчитать число пропусков в каждом столбце.

df2.isnull().sum()Работает на

Pregnancies                 4
Glucose                     0
BloodPressure               0
SkinThickness               0
Insulin                     0
BMI                         0
DiabetesPedigreeFunction    0
Age                         0
Outcome                     0
dtype: int64Работает на

Также можно сделать двойную сумму, чтобы получить общее число пропусков во всём DataFrame.

df2.isnull().sum().sum()Работает на

4Работает на

Сортировка, срезы и извлечение данных в pandas

Пакет pandas предлагает несколько способов сортировать, выделять подмножества, фильтровать и изолировать данные в ваших DataFrame. Здесь мы рассмотрим самые распространённые способы.

Сортировка данных

Чтобы отсортировать DataFrame по конкретному столбцу, используйте .sort_values(). Он возвращает новый отсортированный DataFrame и не меняет df, поэтому, если хотите сохранить результат, присвойте его переменной:

df.sort_values(by="Age", ascending=False)  # Сортировка по Age по убываниюРаботает на

Можно сортировать по нескольким столбцам:

df.sort_values(by=["Age", "Glucose"], ascending=[False, True])Работает на

Сброс индекса

Сортировка или фильтрация сохраняет исходные метки строк, поэтому индекс может оказаться не по порядку. Используйте .reset_index(), чтобы получить новый индекс, начинающийся с 0 (подробнее см. в нашем руководстве по сбросу индекса):

df_sorted = df.sort_values(by="Age", ascending=False).reset_index(drop=True)  # drop=True отбрасывает старый индекс
df_sorted[["Age", "Glucose", "Outcome"]].head(3)Работает на

   Age  Glucose  Outcome
0   81      134        0
1   72      119        0
2   70      145        1Работает на

Выделение одного столбца с помощью [ ] 

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

df['Outcome']Работает на

0      1
1      0
2      1
3      0
4      1
      ..
763    0
764    0
765    0
766    1
767    0
Name: Outcome, Length: 768, dtype: int64Работает на

Выделение двух и более столбцов с помощью [[ ]] 

Вы также можете передать список имён столбцов внутрь квадратных скобок, чтобы получить более одного столбца. Здесь квадратные скобки используются в двух целях. Внешние — для указания подмножества DataFrame, внутренние — для создания списка.

df[['Pregnancies', 'Outcome']]Работает на

     Pregnancies  Outcome
0              6        1
1              1        0
2              8        1
3              1        0
4              0        1
..           ...      ...
763           10        0
764            2        0
765            5        0
766            1        1
767            1        0

[768 rows x 2 columns]Работает на

Выделение одной строки с помощью [ ] 

Одну строку можно получить, передав булеву серию с одним значением True. В примере ниже возвращается вторая строка с index = 1. Здесь .index возвращает метки строк DataFrame, а сравнение превращает их в булев одномерный массив.

df[df.index==1]Работает на

Выделение одной строки в pandas

Выделение двух и более строк с помощью [ ] 

Аналогично, две и более строки можно вернуть с помощью метода .isin() вместо оператора ==.

df[df.index.isin(range(2,10))]Работает на

Выделение конкретных строк в pandas

Использование .loc[] и .iloc[] для выборки строк

Вы можете получать конкретные строки по меткам или условиям с помощью .loc[] и .iloc[] ("location" и "integer location"). .loc[] использует метки для обращения к строке, столбцу или ячейке, а .iloc[] — числовые позиции. Наше руководство по loc и iloc покрывает все различия; чтобы увидеть главное из них здесь, изменим индекс у ранее созданного df2, чтобы метки и позиции больше не совпадали.

df2.index = range(1,769)Работает на

Пример ниже возвращает объект pandas Series вместо DataFrame. В .loc[1] 1 — это метка, так что вернётся строка с меткой 1 (первая строка после переиндексации). В .iloc[1] 1 — нулевая позиция, поэтому вернётся вторая строка, у которой метка 2.

df2.loc[1]Работает на

Pregnancies                   6.000
Glucose                     148.000
BloodPressure                72.000
SkinThickness                35.000
Insulin                       0.000
BMI                          33.600
DiabetesPedigreeFunction      0.627
Age                          50.000
Outcome                       1.000
Name: 1, dtype: float64Работает на

df2.iloc[1]Работает на

Pregnancies                  1.000
Glucose                     85.000
BloodPressure               66.000
SkinThickness               29.000
Insulin                      0.000
BMI                         26.600
DiabetesPedigreeFunction     0.351
Age                         31.000
Outcome                      0.000
Name: 2, dtype: float64Работает на

Можно выбирать несколько строк, передавая диапазон в квадратных скобках. Два аксессора по-разному трактуют конец диапазона: .loc[100:110] включает метку 110 и возвращает 11 строк, тогда как .iloc[100:110] останавливается перед позицией 110 и возвращает 10 строк.

df2.loc[100:110]Работает на

Выделение строк в pandas с помощью .loc[]

df2.iloc[100:110]Работает на

Выделение строк в pandas с .iloc[]

Также можно выбирать подмножества с .loc[] и .iloc[], используя список вместо диапазона.

df2.loc[[100, 200, 300]]Работает на

Выделение строк с помощью списка в pandas с .loc[]

df2.iloc[[100, 200, 300]]Работает на

Выделение строк с помощью списка в pandas с .iloc[]

Можно также выбирать конкретные столбцы вместе со строками. Здесь .iloc[] отличается от .loc[] — ему требуются позиции столбцов, а не их метки.

df2.loc[100:110, ['Pregnancies', 'Glucose', 'BloodPressure']]Работает на

     Pregnancies  Glucose  BloodPressure
100          1.0      122             90
101          1.0      163             72
102          1.0      151             60
103          0.0      125             96
104          1.0       81             72
105          2.0       85             65
106          1.0      126             56
107          1.0       96            122
108          4.0      144             58
109          3.0       83             58
110          0.0       95             85Работает на

df2.iloc[100:110, :3]Работает на

     Pregnancies  Glucose  BloodPressure
101          1.0      163             72
102          1.0      151             60
103          0.0      125             96
104          1.0       81             72
105          2.0       85             65
106          1.0      126             56
107          1.0       96            122
108          4.0      144             58
109          3.0       83             58
110          0.0       95             85Работает на

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

df2.loc[760:, ['Pregnancies', 'Glucose', 'BloodPressure']]Работает на

     Pregnancies  Glucose  BloodPressure
760          6.0      190             92
761          2.0       88             58
762          9.0      170             74
763          9.0       89             62
764         10.0      101             76
765          2.0      122             70
766          5.0      121             72
767          1.0      126             60
768          1.0       93             70Работает на

df2.iloc[760:, :3]Работает на

     Pregnancies  Glucose  BloodPressure
761          2.0       88             58
762          9.0      170             74
763          9.0       89             62
764         10.0      101             76
765          2.0      122             70
766          5.0      121             72
767          1.0      126             60
768          1.0       93             70Работает на

Вы можете обновлять значения, комбинируя .loc[] с оператором присваивания =. Стройте условие на основе того же DataFrame, который вы обновляете: условие, построенное из df, больше не выравнивается с новым индексом df2, и pandas выдаст ошибку.

df2.loc[df2["Age"] == 81, "Age"] = 80Работает на

Фильтрация строк по условиям

pandas позволяет фильтровать данные по условиям над значениями строк/столбцов. Например, код ниже выбирает строку, где Blood Pressure ровно 122. Здесь мы выделяем строки с помощью скобок [ ], как в предыдущих разделах. Но вместо индексов строк или имён столбцов мы передаём условие, что столбец BloodPressure равен 122. Мы обозначаем это условие как df.BloodPressure == 122.

df[df.BloodPressure == 122]Работает на

Выделение строк по условию в pandas 

Пример ниже выбирает все строки, где Outcome равен 1. Здесь df.Outcome выбирает этот столбец, df.Outcome == 1 возвращает Series булевых значений, определяющих, какие Outcome равны 1, затем [] берёт подмножество df, где эта булева Series равна True.

df[df.Outcome == 1]Работает на

Выделение строк по условию в pandas 

Вы можете использовать оператор > для сравнений. Код ниже извлекает Pregnancies, Glucose и BloodPressure для всех записей, у которых BloodPressure больше 100.

df.loc[df['BloodPressure'] > 100, ['Pregnancies', 'Glucose', 'BloodPressure']]Работает на

     Pregnancies  Glucose  BloodPressure
43             9      171            110
84             5      137            108
106            1       96            122
177            0      129            110
207            5      162            104
362            5      103            108
369            1      133            102
440            0      189            104
549            4      189            110
658           11      127            106
662            8      167            106
672           10       68            106
691           13      158            114Работает на

Очистка данных в pandas

Очистка данных — одна из самых частых задач в дата-сайенсе. pandas позволяет предобрабатывать данные для любых целей, включая обучение моделей машинного и глубокого обучения. Давайте используем DataFrame df2 из предыдущего раздела с четырьмя пропусками, чтобы показать несколько приёмов очистки данных. Напомним, как посмотреть, сколько пропусков в DataFrame.

df2.isnull().sum()Работает на

Pregnancies                 4
Glucose                     0
BloodPressure               0
SkinThickness               0
Insulin                     0
BMI                         0
DiabetesPedigreeFunction    0
Age                         0
Outcome                     0
dtype: int64Работает на

Обработка пропусков, приём №1: удаление пропусков

Один из способов — удалить пропуски. Это особенно полезно, когда данных достаточно и потеря небольшой части не повлияет на дальнейший анализ. Можно использовать метод .dropna(), как показано ниже. Здесь мы сохраняем результаты .dropna() в DataFrame df3.

df3 = df2.copy()
df3 = df3.dropna()
df3.shapeРаботает на

(764, 9) # это на 4 строки меньше, чем в df2Работает на

Аргумент axis позволяет указать, удаляете ли вы строки или столбцы с пропусками. Значение по умолчанию — удалять строки, содержащие NaN. Используйте axis = 1, чтобы удалить столбцы, содержащие одно или более значений NaN. Как и во всех примерах в этом руководстве, мы переназначаем результат вместо передачи inplace=True, который в pandas 3.1 объявлен устаревшим для .dropna().

df3 = df2.dropna(axis=1)
list(df3.columns)Работает на

['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI', 'DiabetesPedigreeFunction', 'Age', 'Outcome']Работает на

По умолчанию .dropna() удаляет строку, если в ней отсутствует хотя бы одно значение. Установите аргумент how в 'all', чтобы удалять только строки, где отсутствуют все значения. В df2 нет полностью пустых строк, поэтому ничего не удаляется:

df3 = df2.dropna(how="all")
df3.shapeРаботает на

(768, 9)Работает на

Обработка пропусков, приём №2: замена пропусков

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

df3 = df2.copy()
# Получаем среднее по Pregnancies
mean_value = df3["Pregnancies"].mean()
# Заполняем пропуски только в этом столбце
df3["Pregnancies"] = df3["Pregnancies"].fillna(mean_value)
df3["Pregnancies"].head(7)Работает на

1    6.000000
2    1.000000
3    3.846859
4    3.846859
5    3.846859
6    3.846859
7    3.000000
Name: Pregnancies, dtype: float64Работает на

Обработка дубликатов

Давайте добавим дубликаты в исходные данные, чтобы научиться их удалять. Здесь мы используем функцию pd.concat(), чтобы конкатенировать строки DataFrame df2 с самим df2, добавив идеальные дубликаты каждой строки df2. 

df3 = pd.concat([df2, df2])
df3.shapeРаботает на

(1536, 9)Работает на

Вы можете удалить все дублирующиеся строки (по умолчанию) из DataFrame с помощью метода .drop_duplicates().

df3 = df3.drop_duplicates()
df3.shapeРаботает на

(768, 9)Работает на

Переименование столбцов

Распространённая задача очистки данных — переименование столбцов. Передайте методу .rename() словарь columns, сопоставляющий старые имена новым:

df3 = df3.rename(columns={"DiabetesPedigreeFunction": "DPF"})
df3[["Glucose", "BMI", "DPF", "Age"]].head()Работает на

   Glucose   BMI    DPF  Age
1      148  33.6  0.627   50
2       85  26.6  0.351   31
3      183  23.3  0.672   32
4       89  28.1  0.167   21
5      137  43.1  2.288   33Работает на

Можно также присвоить полный список имён атрибуту .columns. Список должен содержать имя для каждого столбца в текущем порядке: pandas назначает имена по позициям, поэтому список в неверном порядке тихо исказит метки ваших данных.

df3.columns = ["Pregnancies", "Glucose", "BloodPressure", "SkinThickness", "Insulin", "BMI", "DPF", "Age", "Outcome"]
list(df3.columns)Работает на

['Pregnancies', 'Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI', 'DPF', 'Age', 'Outcome']Работает на

Чтобы упростить очистку данных и сделать рабочие процессы предсказуемее, посмотрите следующий чек-лист, в котором собраны распространённые задачи по очистке данных. 

Объединение DataFrame в pandas

pandas объединяет DataFrame двумя способами: .merge() соединяет таблицы по общим ключевым столбцам, как SQL-join, а pd.concat() складывает таблицы друг над другом или бок о бок.

Слияние DataFrame с помощью .merge()

Используйте .merge(), когда две таблицы разделяют ключевой столбец. Допустим, во второй таблице каждому коду Outcome сопоставлен читаемый ярлык. Левое соединение по Outcome добавит этот ярлык к каждой строке пациента:

outcome_labels = pd.DataFrame({"Outcome": [0, 1], "Diagnosis": ["Non-diabetic", "Diabetic"]})

df_labeled = df.merge(outcome_labels, on="Outcome", how="left")
df_labeled[["Glucose", "Outcome", "Diagnosis"]].head(3)Работает на

   Glucose  Outcome     Diagnosis
0      148        1      Diabetic
1       85        0  Non-diabetic
2      183        1      DiabeticРаботает на

Аргумент how задаёт тип соединения: "left" сохраняет все строки df, "inner" — только строки с совпадениями в обеих таблицах, а "outer" — все строки из обеих. Наше руководство по объединению DataFrame в pandas подробно разбирает .join() и все типы соединений.

Конкатенация DataFrame с помощью pd.concat()

Используйте pd.concat(), когда у таблиц одинаковые столбцы, и вы хотите сложить их строки, например записи пациентов, пришедшие двумя партиями. Установите ignore_index=True, чтобы получить новый индекс с нуля вместо сохранения меток каждой партии:

batch_1 = df.iloc[:500]
batch_2 = df.iloc[500:]

df_combined = pd.concat([batch_1, batch_2], ignore_index=True)
df_combined.shapeРаботает на

(768, 9)Работает на

С axis=1 pd.concat() размещает таблицы рядом, сопоставляя строки по меткам индекса:

measurements = df[["Glucose", "BMI"]]
outcomes = df[["Outcome"]]

pd.concat([measurements, outcomes], axis=1).head(3)Работает на

   Glucose   BMI  Outcome
0      148  33.6        1
1       85  26.6        0
2      183  23.3        1Работает на

Для практики обоих методов попробуйте наш курс Joining Data with pandas.

Анализ данных в pandas

Главная ценность pandas — в быстром анализе данных. В этом разделе мы сосредоточимся на наборе приёмов анализа, доступных в pandas.

Операторные сводки (mean, mode, median)

Как вы уже видели, среднее по каждому столбцу можно получить методом .mean().

df.mean()Работает на

Pregnancies                   3.845052
Glucose                     120.894531
BloodPressure                69.105469
SkinThickness                20.536458
Insulin                      79.799479
BMI                          31.992578
DiabetesPedigreeFunction      0.471876
Age                          33.240885
Outcome                       0.348958
dtype: float64Работает на

Моду можно вычислить аналогично с помощью метода .mode(). 

df.mode()Работает на

Вывод мод столбцов в pandas

Аналогично медиану по каждому столбцу вычисляют методом .median()

df.median()Работает на

Pregnancies                   3.0000
Glucose                     117.0000
BloodPressure                72.0000
SkinThickness                23.0000
Insulin                      30.5000
BMI                          32.0000
DiabetesPedigreeFunction      0.3725
Age                          29.0000
Outcome                       0.0000
dtype: float64Работает на

Создание новых столбцов на основе существующих 

pandas обеспечивает быстрые и эффективные вычисления при комбинировании двух и более столбцов как скалярных переменных. Код ниже делит каждое значение столбца Glucose на соответствующее значение в столбце Insulin, создавая новый столбец Glucose_Insulin_Ratio.

df2['Glucose_Insulin_Ratio'] = df2['Glucose']/df2['Insulin']
df2.head()Работает на

Создание нового столбца из существующих в pandas

Строки, где Insulin равен 0, показывают inf, потому что деление на ноль даёт бесконечность. В этом наборе данных 0 в Insulin означает, что измерение отсутствует (374 из 768 строк), поэтому обработайте эти нули как пропуски перед делением:

df2["Glucose_Insulin_Ratio"] = df2["Glucose"] / df2["Insulin"].where(df2["Insulin"] > 0)
df2["Glucose_Insulin_Ratio"].head()Работает на

1         NaN
2         NaN
3         NaN
4    0.946809
5    0.815476
Name: Glucose_Insulin_Ratio, dtype: float64Работает на

.where() сохраняет значения, удовлетворяющие условию, и заменяет остальные на NaN, поэтому отношение для тех строк становится пропущенным, а не бесконечным. Наше руководство по добавлению столбцов в pandas показывает другие способы получения новых столбцов.

Подсчёт значений с помощью .value_counts()

Когда столбец хранит категории, часто нужно посчитать, сколько наблюдений приходится на каждую. Метод .value_counts() делает именно это. Здесь, например, мы считаем число наблюдений, где Outcome — диабет (1), и число наблюдений, где Outcome — не диабет (0).

df['Outcome'].value_counts()Работает на

Outcome
0    500
1    268
Name: count, dtype: int64Работает на

Добавление аргумента normalize возвращает доли вместо абсолютных значений.

df['Outcome'].value_counts(normalize=True)Работает на

Outcome
0    0.651042
1    0.348958
Name: proportion, dtype: float64Работает на

Отключите автоматическую сортировку результатов с помощью аргумента sort (по умолчанию True). По умолчанию сортировка идёт по убыванию значений.

df['Outcome'].value_counts(sort=False)Работает на

Outcome
1    268
0    500
Name: count, dtype: int64Работает на

Вы также можете применить .value_counts() к самому объекту DataFrame и к его конкретным столбцам, а не только к одному столбцу. Здесь, например, мы применяем value_counts() к df с аргументом subset, который принимает список столбцов. 

df.value_counts(subset=['Pregnancies', 'Outcome'])Работает на

Pregnancies  Outcome
1            0          106
2            0           84
0            0           73
3            0           48
4            0           45
0            1           38
5            0           36
6            0           34
1            1           29
3            1           27
7            1           25
4            1           23
8            1           22
5            1           21
7            0           20
2            1           19
9            1           18
6            1           16
8            0           16
10           0           14
             1           10
9            0           10
11           1            7
13           0            5
             1            5
12           0            5
11           0            4
12           1            4
14           1            2
15           1            1
17           1            1
Name: count, dtype: int64Работает на

Агрегирование данных с .groupby() в pandas

pandas позволяет агрегировать значения, группируя их по значениям конкретных столбцов. Это делается комбинацией метода .groupby() и выбранного вами метода сводки. Код ниже показывает среднее по каждому числовому столбцу в группах по Outcome.

df.groupby('Outcome').mean()Работает на

Агрегирование данных по одному столбцу в pandas

.groupby() позволяет группировать более чем по одному столбцу, если передать список имён столбцов, как показано ниже.

df.groupby(['Pregnancies', 'Outcome']).mean()Работает на

Агрегирование данных по двум столбцам в pandas

С .groupby() можно использовать любой метод сводки, включая .min(), .max(), .mean(), .median(), .sum() и другие. Наше руководство по GroupBy в pandas охватывает множественные агрегирования с .agg() и другие шаблоны.

Сводные таблицы 

pandas также позволяет вычислять описательную статистику в виде сводных таблиц (pivot tables). Это упрощает выводы по комбинации переменных. Код ниже выбирает строки как уникальные значения Pregnancies, столбцы — как уникальные значения Outcome, а ячейки содержат среднее значение BMI в соответствующей группе.

Например, для Pregnancies = 5 и Outcome = 0 средний BMI равен 31.1.

pd.pivot_table(df, values="BMI", index='Pregnancies', 
               columns=['Outcome'], aggfunc='mean')Работает на

Outcome              0          1
Pregnancies                      
0            31.727397  39.213158
1            29.616038  37.793103
2            29.679762  34.578947
3            29.231250  32.548148
4            31.255556  33.873913
5            31.100000  36.780952
6            29.591176  31.775000
7            29.975000  34.756000
8            30.693750  32.204545
9            28.840000  33.300000
10           30.114286  31.380000
11           37.125000  39.385714
12           30.560000  34.575000
13           33.280000  36.720000
14                 NaN  35.100000
15                 NaN  37.100000
17                 NaN  40.900000Работает на

Визуализация данных в pandas

pandas предоставляет удобные обёртки над функциями построения графиков Matplotlib, упрощающие визуализацию ваших DataFrame. Ниже вы увидите, как делать распространённые визуализации в pandas.

Линейные графики в pandas

pandas позволяет отобразить взаимосвязи между переменными с помощью линейных графиков. Ниже — линейный график BMI и Glucose по индексу строк.

df[['BMI', 'Glucose']].plot.line()Работает на

Базовый линейный график в pandas

Вы можете выбрать цвета с помощью аргумента color.

df[['BMI', 'Glucose']].plot.line(color={"BMI": "red", "Glucose": "blue"})Работает на

Базовый линейный график в pandas с пользовательскими цветами

Также можно построить все столбцы df на разных шкалах и осях, используя аргумент subplots.

df.plot.line(subplots=True)Работает на

Подграфики для линейных графиков в pandas

Столбчатые диаграммы в pandas

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

df['Outcome'].value_counts().plot.bar()Работает на

Столбчатые диаграммы в pandas

Боксплоты в pandas

Квартильное распределение непрерывных переменных можно визуализировать с помощью boxplot. Код ниже создаёт boxplot в pandas.

df.boxplot(column=['BMI'], by='Outcome')Работает на

Boxplot в pandas

Заключение

Теперь у вас есть базовый рабочий процесс в pandas: прочитать файл в DataFrame, осмотреть его с помощью .head(), .info() и .describe(), выбирать строки с .loc[] и .iloc[], очищать пропуски и дубликаты, объединять таблицы и суммировать данные с .groupby() и сводными таблицами.

Если вы изучали pandas до 2026 года, стоит поменять одну привычку: пере присваивайте результаты вместо передачи inplace=True и выполняйте каждое обновление одним вызовом .loc[]. Быстрее всего закрепить остальные приёмы — повторить рабочий процесс на наборе данных, который вам важен. Эти ресурсы помогут продвинуться дальше:

• [Шпаргалки] Множество шпаргалок по Python и pandas для постоянной опоры 
• [Живые тренинги] Наши бесплатные интерактивные сессии по коду, многие из которых используют pandas
• [Курсы] Манипулирование данными с pandas и Joining Data with pandas для интерактивной практики
• [Подготовка к собеседованию] Наши топовые вопросы на собеседовании по pandas, чтобы проверить свои знания
• [Больше учебников] Ознакомьтесь с остальными руководствами по pandas и экосистеме PyData, включая реализацию скользящих средних в pandas и использование метода pandas .apply()