Pandas руководство на русском

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

Для установки pandas выполним в командной строке команду:

pip install pandas

Во всех примерах предполагается, что библиотеки numpy и pandas импортированы следующим образом:

import numpy as np
import pandas as pd

В библиотеке pandas определены два класса объектов для работы с данными:

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

Создать объект класса Series можно следующим образом:

s = pd.Series(data, index=index)

В качестве data могут выступать: массив numpy, словарь, число. В аргумент index передаётся список меток осей. Метка может быть числом, но чаще используются метки-строки.

Если data является массивом numpy, то index должен иметь такую же длину, как и data. Если аргумент index не передаётся, то по умолчанию для index автоматически назначается список [0, …, len(data) — 1]:

s = pd.Series(np.arange(5), index=["a", "b", "c", "d", "e"])
print(s)
print()
s = pd.Series(np.linspace(0, 1, 5))
print(s)

Вывод программы:

a    0
b    1
c    2
d    3
e    4
dtype: int32

0    0.00
1    0.25
2    0.50
3    0.75
4    1.00
dtype: float64

Из вывода программы видно, что Series фактически является аналогом словаря, так как вместо числовых индексов может использовать метки в виде строк.

Если data задаётся словарём, а index не передаётся, то в качестве индекса используются ключи-словари. Если index передаётся, то его длина может не совпадать с длиной словаря data. В таком случае по индексам, для которых нет ключа с соответствующим значением в словаре, будут храниться значения NaN — стандартное обозначение отсутствия данных в библиотеке pandas.

d = {"a": 10, "b": 20, "c": 30, "g": 40}
print(pd.Series(d))
print()
print(pd.Series(d, index=["a", "b", "c", "d"]))

a    10
b    20
c    30
g    40
dtype: int64

a    10.0
b    20.0
c    30.0
d     NaN
dtype: float64

Если data задаётся числом, то index нужно обязательно передать. Количество элементов в Series будет равно числу меток в index, а значения будут равны data:

index = ["a", "b", "c"]
print(pd.Series(5, index=index))

Вывод программы:

a    5
b    5
c    5
dtype: int64

Для Series доступно взятие элемента по индексу, срезы, поэлементные математические операции аналогично массивам numpy.

s = pd.Series(np.arange(5), index=["a", "b", "c", "d", "e"])
print("Выбор одного элемента")
print(s["a"])
print("Выбор нескольких элементов")
print(s[["a", "d"]])
print("Срез")
print(s[1:])
print("Поэлементное сложение")
print(s + s)

Вывод программы:

Выбор одного элемента
0
Выбор нескольких элементов
a    0
d    3
dtype: int32
Срез
b    1
c    2
d    3
e    4
dtype: int32
Поэлементное сложение
a    0
b    2
c    4
d    6
e    8
dtype: int32

Для Series можно применять фильтрацию данных по условию, записанному в качестве индекса:

s = pd.Series(np.arange(5), index=["a", "b", "c", "d", "e"])
print("Фильтрация")
print(s[s > 2])

Вывод программы:

Фильтрация
d    3
e    4
dtype: int32

Объекты Series имеют атрибут name со значением имени набора данных, а также атрибут index.name с именем для индексов:

s = pd.Series(np.arange(5), index=["a", "b", "c", "d", "e"])
s.name = "Данные"
s.index.name = "Индекс"
print(s)

Вывод программы:

Индекс
a    0
b    1
c    2
d    3
e    4
Name: Данные, dtype: int32

Объект класса DataFrame работает с двумерными табличными данными. Создать DataFrame проще всего из словаря Python следующим образом:

students_marks_dict = {"student": ["Студент_1", "Студент_2", "Студент_3"],
                       "math": [5, 3, 4],
                       "physics": [4, 5, 5]}
students = pd.DataFrame(students_marks_dict)
print(students)

Вывод программы:

     student  math  physics
0  Студент_1     5        4
1  Студент_2     3        5
2  Студент_3     4        5

У объекта класса DataFrame есть индексы по строкам (index) и столбцам (columns):

print(students.index)
print(students.columns)

Вывод программы:

RangeIndex(start=0, stop=3, step=1)
Index(['student', 'math', 'physics'], dtype='object')

Для индекса по строке по умолчанию задаётся числовое значение. Значения индекса можно заменить путём записи списка в атрибут index:

students.index = ["A", "B", "C"]
print(students)

Вывод программы:

     student  math  physics
A  Студент_1     5        4
B  Студент_2     3        5
C  Студент_3     4        5

Для доступа к записям таблицы по строковой метке используется атрибут loc. При использовании строковой метки доступна операция среза:

print(students.loc["B":])

Вывод программы:

     student  math  physics
B  Студент_2     3        5
C  Студент_3     4        5

Убедимся, что столбцы у DataFrame являются объектами класса Series:

print(type(students["student"]))

Вывод программы:

<class 'pandas.core.series.Series'>

Обычно табличные данные хранятся в файлах. Такие наборы данных принято называть дата-сетами. Файлы с дата-сетом могут иметь различный формат. Pandas поддерживает операции чтения и записи для CSV, Excel 2007+, SQL, HTML, JSON, буфер обмена и др.

Несколько примеров, как получить дата-сет из файлов разных форматов:

• CSV. Используется функция read_csv(). Аргумент file является строкой, в которой записан путь до файла с дата-сетом. Для записи данных из DataFrame в CSV-файл используется метод to_csv(file).
• Excel. Используется функция read_excel(). Для записи данных из DataFrame в Excel-файл используется метод to_excel().
• JSON. Используется функция read_json(). Для записи данных из DataFrame в JSON используется метод to_json().

Для работы с другими форматами файлов в pandas есть функции, работающие аналогично рассмотренным. С ними можно ознакомиться в документации.

Одним из самых популярных форматов хранения табличных данных является CSV (Comma Separated Values, значения с разделителем-запятой). В файлах этого формата данные хранятся в текстовом виде. Строки таблицы записываются в файле с новой строки, а столбцы разделяются определённым символом, чаще всего запятой ‘,’ или точкой с запятой ‘;’. Первая строка, как правило, содержит заголовки столбцов таблицы. Пример части CSV-файла с информацией о результатах прохождения тестов студентами и некоторой дополнительной информацией:

"gender","race/ethnicity","parental level of education","lunch","test preparation course","math score","reading score","writing score"
"female","group B","bachelor's degree","standard","none","72","72","74"
"female","group C","some college","standard","completed","69","90","88"

Для дальнейшей работы скачайте данный файл с дата-сетом.

Получим дата-сет из CSV-файла с данными о студентах:

import numpy as np
import pandas as pd

students = pd.read_csv("StudentsPerformance.csv")

Полученный объект students относится к классу DataFrame.

Для получения первых n строк дата-сета используется метод head(n). По умолчанию возвращается пять первых строк:

print(students.head())

Вывод программы:

   gender race/ethnicity  ... reading score writing score
0  female        group B  ...            72            74
1  female        group C  ...            90            88
2  female        group B  ...            95            93
3    male        group A  ...            57            44
4    male        group C  ...            78            75

[5 rows x 8 columns]

Для получения последних n строк используется метод tail(n). По умолчанию возвращается пять последних строк:

print(student.tail(3))

Вывод программы:

     gender race/ethnicity  ... reading score writing score
997  female        group C  ...            71            65
998  female        group D  ...            78            77
999  female        group D  ...            86            86

[3 rows x 8 columns]

Для получения части дата-сета можно использовать срез:

print(students[10:13])

    gender race/ethnicity  ... reading score writing score
10    male        group C  ...            54            52
11    male        group D  ...            52            43
12  female        group B  ...            81            73

[3 rows x 8 columns]

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

print(students[students["test preparation course"] == "completed"]["math score"].head())

Вывод программы:

1     69
6     88
8     64
13    78
18    46
Name: math score, dtype: int64

Выведем пять лучших результатов тестов по трём дисциплинам для предыдущей выборки с помощью сортировки методом sort_values(). Сортировка по умолчанию производится в порядке возрастания значений. Для сортировки по убыванию в именованный аргумент ascending передаётся значение False.

with_course = students[students["test preparation course"] == "completed"]
print(with_course[["math score",
                   "reading score",
                   "writing score"]].sort_values(["math score",
                                                  "reading score",
                                                  "writing score"], ascending=False).head())

Вывод программы:

     math score  reading score  writing score
916         100            100            100
149         100            100             93
625         100             97             99
623         100             96             86
114          99            100            100

При сортировке сравнивались последовательно значения в перечисленных столбцах. Проведём сортировку по сумме баллов за тесты. Для этого создадим ещё один столбец total_score и произведём по нему сортировку:

with_course = students[students["test preparation course"] == "completed"]
students["total score"] = students["math score"] + students["reading score"] + students["writing score"]
print(students.sort_values(["total score"], ascending=False).head())

Вывод программы:

     gender race/ethnicity  ... writing score total score
916    male        group E  ...           100         300
458  female        group E  ...           100         300
962  female        group E  ...           100         300
114  female        group E  ...           100         299
179  female        group D  ...           100         297

[5 rows x 9 columns]

Чтобы в таблицу добавить колонку, подойдёт метод assign(). Данный метод даёт возможность создавать колонки при помощи лямбда-функции. Обратите внимание: данный метод возвращает новую таблицу, а не меняет исходную. Перепишем предыдущий пример с использованием assign():

scores = students.assign(total_score=lambda x: x["math score"] + x["reading score"] + x["writing score"])
print(scores.sort_values(["total_score"], ascending=False).head())

Вывод программы:

     gender race/ethnicity  ... writing score total_score
916    male        group E  ...           100         300
458  female        group E  ...           100         300
962  female        group E  ...           100         300
114  female        group E  ...           100         299
179  female        group D  ...           100         297

При анализе данных часто требуется сгруппировать записи по какому-то признаку. Для выполнения операции группировки в pandas используется метод groupby(). Сама по себе группировка для рассматриваемого дата-сета даёт мало информации. Поэтому воспользуемся методом count(), чтобы определить количество сгруппированных записей. Получим информацию о количестве студентов мужского и женского пола (поле «gender»), прошедших курс по подготовке к тестированию (поле «test preparation course»):

print(students.groupby(["gender", "test preparation course"])["writing score"].count())

Вывод программы:

gender  test preparation course
female  completed                  184
        none                       334
male    completed                  174
        none                       308
Name: race/ethnicity, dtype: int64

Если необходимо выполнить операцию, которая позволяет получить сводные данные, то такая операция называется агрегацией. Примерами функции агрегации являются сумма, среднее арифметическое, минимум, максимум и др. Для применения функции агрегации к нескольким столбцам подойдёт метод agg(), в который можно передать словарь с ключами — названиями столбцов, а значения по ключам могут быть списками функций агрегации.

Покажем использование агрегации на примере. Определим среднее арифметическое и медианное значения балла за тест по математике для студентов мужского и женского пола в зависимости от прохождения подготовительного курса:

agg_functions = {"math score": ["mean", "median"]}
print(students.groupby(["gender", "test preparation course"]).agg(agg_functions))

Вывод программы:

                               math score       
                                     mean median
gender test preparation course                  
female completed                67.195652   67.0
       none                     61.670659   62.0
male   completed                72.339080   73.0
       none                     66.688312   67.0

Для визуализации данных pandas использует библиотеку matplotlib. Для её установки выполните в командной строке следующую команду:

pip install matplotlib

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

import matplotlib.pyplot as plt

Построим гистограмму, которая показывает распределение количества студентов по баллам за тест по математике:

plt.hist(students["math score"], label="Тест по математике")
plt.xlabel("Баллы за тест")
plt.ylabel("Количество студентов")
plt.legend()
plt.show()

В результате работы программы получим следующую гистограмму:

Ещё по теме

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

При использовании библиотеки pandas для анализа маленьких наборов данных, размер которых не превышает 100 мегабайт, производительность редко становится проблемой. Но когда речь идёт об исследовании наборов данных, размеры которых могут достигать нескольких гигабайт, проблемы с производительностью могут приводить к значительному увеличению длительности анализа данных и даже могут становиться причиной невозможности проведения анализа из-за нехватки памяти.

В то время как инструменты наподобие Spark могут эффективно обрабатывать большие наборы данных (от сотен гигабайт до нескольких терабайт), для того чтобы полноценно пользоваться их возможностями обычно нужно достаточно мощное и дорогое аппаратное обеспечение. И, в сравнении с pandas, они не отличаются богатыми наборами средств для качественного проведения очистки, исследования и анализа данных. Для наборов данных средних размеров лучше всего попытаться более эффективно использовать pandas, а не переходить на другие инструменты.

В материале, перевод которого мы публикуем сегодня, мы поговорим об особенностях работы с памятью при использовании pandas, и о том, как, просто подбирая подходящие типы данных, хранящихся в столбцах табличных структур данных DataFrame, снизить потребление памяти почти на 90%.

Работа с данными о бейсбольных матчах

Мы будем работать с данными по бейсбольным играм Главной лиги, собранными за 130 лет и взятыми с Retrosheet.

Изначально эти данные были представлены в виде 127 CSV-файлов, но мы объединили их в один набор данных с помощью csvkit и добавили, в качестве первой строки получившейся таблицы, строку с названиями столбцов. Если хотите, можете загрузить нашу версию этих данных и экспериментировать с ними, читая статью.

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

import pandas as pd

gl = pd.read_csv('game_logs.csv')
gl.head()

Ниже приведены сведения о наиболее важных столбцах таблицы с этими данными. Если вы хотите почитать пояснения по всем столбцам — здесь вы можете найти словарь данных для всего набора данных.

• date — Дата проведения игры.
• v_name — Название команды гостей.
• v_league — Лига команды гостей.
• h_name — Название команды хозяев.
• h_league — Лига команды хозяев.
• v_score — Очки команды гостей.
• h_score — Очки команды хозяев.
• v_line_score — Сводка по очкам команды гостей, например — 010000(10)00.
• h_line_score — Сводка по очкам команды хозяев, например — 010000(10)0X.
• park_id — Идентификатор поля, на котором проводилась игра.
• attendance — Количество зрителей.

Для того чтобы узнать общие сведения об объекте DataFrame, можно воспользоваться методом DataFrame.info(). Благодаря этому методу можно узнать о размере объекта, о типах данных и об использовании памяти.

По умолчанию pandas, ради экономии времени, указывает приблизительные сведения об использовании памяти объектом DataFrame. Нас интересуют точные сведения, поэтому мы установим параметр memory_usage в значение 'deep'.

gl.info(memory_usage='deep')

Вот какие сведения нам удалось получить:

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 171907 entries, 0 to 171906
Columns: 161 entries, date to acquisition_info
dtypes: float64(77), int64(6), object(78)
memory usage: 861.6 MB

Как оказалось, у нас имеется 171,907 строк и 161 столбец. Библиотека pandas автоматически выяснила типы данных. Здесь присутствует 83 столбца с числовыми данными и 78 столбцов с объектами. Объектные столбцы используются для хранения строковых данных, и в тех случаях, когда столбец содержит данные разных типов.

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

Внутреннее представление объекта DataFrame

Внутри pandas столбцы данных группируются в блоки со значениями одинакового типа. Вот пример того, как в pandas хранятся первые 12 столбцов объекта DataFrame.

Внутреннее представление данных разных типов в pandas

Можно заметить, что блоки не хранят сведения об именах столбцов. Происходит это из-за того, что блоки оптимизированы для хранения значений, имеющихся в ячейках таблицы объекта DataFrame. За хранение сведений о соответствии между индексами строк и столбцов набора данных и того, что хранится в блоках однотипных данных, отвечает класс BlockManager. Он играет роль API, который предоставляет доступ к базовым данным. Когда мы читаем, редактируем или удаляем значения, класс DataFrame взаимодействует с классом BlockManager для преобразования наших запросов в вызовы функций и методов.

Каждый тип данных имеет специализированный класс в модуле pandas.core.internals. Например, pandas использует класс ObjectBlock для представления блоков, содержащих строковые столбцы, и класс FloatBlock для представления блоков, содержащих столбцы, хранящие числа с плавающей точкой. Для блоков, представляющих числовые значения, выглядящие как целые числа или числа с плавающей точкой, pandas комбинирует столбцы и хранит их в виде структуры данных ndarray библиотеки NumPy. Эта структура данных построена на основе массива C, значения хранятся в непрерывном блоке памяти. Благодаря такой схеме хранения данных доступ к фрагментам данных осуществляется очень быстро.

Так как данные разных типов хранятся раздельно, мы исследуем использование памяти разными типами данных. Начнём со среднего показателя использования памяти по разным типам данных.

for dtype in ['float','int','object']:
    selected_dtype = gl.select_dtypes(include=[dtype])
    mean_usage_b = selected_dtype.memory_usage(deep=True).mean()
    mean_usage_mb = mean_usage_b / 1024 ** 2
    print("Average memory usage for {} columns: {:03.2f} MB".format(dtype,mean_usage_mb))

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

Average memory usage for float columns: 1.29 MB
Average memory usage for int columns: 1.12 MB
Average memory usage for object columns: 9.53 MB

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

Подтипы

Как мы уже говорили, pandas представляет числовые значения в виде структур данных ndarray NumPy и хранит их в непрерывных блоках памяти. Эта модель хранения данных позволяет экономно расходовать память и быстро получать доступ к значениям. Так как pandas представляет каждое значение одного и того же типа, используя одинаковое число байт, и структуры ndarray хранят сведения о числе значений, pandas может быстро и точно выдать сведения об объёме памяти, потребляемых столбцами, хранящими числовые значения.

У многих типов данных в pandas есть множество подтипов, которые могут использовать меньшее число байт для представления каждого значения. Например тип float имеет подтипы float16, float32 и float64. Число в имени типа указывает на количество бит, которые подтип использует для представления значений. Например, в только что перечисленных подтипах для хранения данных используется, соответственно, 2, 4, 8 и 16 байт. В следующей таблице представлены подтипы наиболее часто используемых в pandas типов данных.

Значение типа int8 использует 1 байт (8 бит) для хранения числа и может представлять 256 двоичных значений (2 в 8 степени). Это означает, что этот подтип можно использовать для хранения значений в диапазоне от -128 до 127 (включая 0).

Для проверки минимального и максимального значения, подходящего для хранения с использованием каждого целочисленного подтипа, можно воспользоваться методом numpy.iinfo(). Рассмотрим пример:

import numpy as np
int_types = ["uint8", "int8", "int16"]
for it in int_types:
    print(np.iinfo(it))

Выполнив этот код, мы получаем следующие данные:

Machine parameters for uint8
---------------------------------------------------------------
min = 0
max = 255
---------------------------------------------------------------

Machine parameters for int8
---------------------------------------------------------------
min = -128
max = 127
---------------------------------------------------------------

Machine parameters for int16
---------------------------------------------------------------
min = -32768
max = 32767
---------------------------------------------------------------

Тут можно обратить внимание на различие между типами uint (беззнаковое целое) и int (целое число со знаком). Оба типа имеют одинаковую ёмкость, но, при хранении в столбцах только положительных значений, беззнаковые типы позволяют эффективнее расходовать память.

Оптимизация хранения числовых данных с использованием подтипов

Функцию pd.to_numeric() можно использовать для нисходящего преобразования числовых типов. Для выбора целочисленных столбцов воспользуемся методом DataFrame.select_dtypes(), затем оптимизируем их и сравним использование памяти до и после оптимизации.

# Мы будем часто выяснять то, сколько памяти используется,
# поэтому создадим функцию, которая поможет нам сэкономить немного времени.


def mem_usage(pandas_obj):
    if isinstance(pandas_obj,pd.DataFrame):
        usage_b = pandas_obj.memory_usage(deep=True).sum()
    else: # исходим из предположения о том, что если это не DataFrame, то это Series
        usage_b = pandas_obj.memory_usage(deep=True)
    usage_mb = usage_b / 1024 ** 2 # преобразуем байты в мегабайты
    return "{:03.2f} MB".format(usage_mb)

gl_int = gl.select_dtypes(include=['int'])
converted_int = gl_int.apply(pd.to_numeric,downcast='unsigned')

print(mem_usage(gl_int))
print(mem_usage(converted_int))

compare_ints = pd.concat([gl_int.dtypes,converted_int.dtypes],axis=1)
compare_ints.columns = ['before','after']
compare_ints.apply(pd.Series.value_counts)

Вот что получается в результате исследования потребления памяти:

7.87 MB
1.48 MB

В результате можно видеть падение использования памяти с 7.9 до 1.5 мегабайт, то есть — мы снизили потребление памяти больше, чем на 80%. Общее воздействие этой оптимизации на исходный объект DataFrame, однако, не является особенно сильным, так как в нём очень мало целочисленных столбцов.

Сделаем то же самое со столбцами, содержащими числа с плавающей точкой.

gl_float = gl.select_dtypes(include=['float'])
converted_float = gl_float.apply(pd.to_numeric,downcast='float')

print(mem_usage(gl_float))
print(mem_usage(converted_float))

compare_floats = pd.concat([gl_float.dtypes,converted_float.dtypes],axis=1)
compare_floats.columns = ['before','after']
compare_floats.apply(pd.Series.value_counts)

В результате получается следующее:

100.99 MB
50.49 MB

В результате все столбцы, хранившие числа с плавающей точкой с типом данных float64, теперь хранят числа типа float32, что дало нам 50% уменьшение использования памяти.

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

optimized_gl = gl.copy()

optimized_gl[converted_int.columns] = converted_int
optimized_gl[converted_float.columns] = converted_float

print(mem_usage(gl))
print(mem_usage(optimized_gl))

Вот что у нас получилось:

861.57 MB
804.69 MB

Хотя мы значительно уменьшили потребление памяти столбцами, хранящими числовые данные, в целом, по всему объекту DataFrame, потребление памяти снизилось лишь на 7%. Источником куда более серьёзного улучшения ситуации может стать оптимизация хранения объектных типов.

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

Сравнение механизмов хранения чисел и строк

Тип object представляет значения с использованием строковых объектов Python. Отчасти это так от того, что NumPy не поддерживает представление отсутствующих строковых значений. Так как Python — это высокоуровневый интерпретируемый язык, он не даёт программисту инструментов для тонкого управления тем, как данные хранятся в памяти.

Это ограничение ведёт к тому, что строки хранятся не в непрерывных фрагментах памяти, их представление в памяти фрагментировано. Это ведёт к увеличению потребления памяти и к замедлению скорости работы со строковыми значениями. Каждый элемент в столбце, хранящем объектный тип данных, на самом деле, представляет собой указатель, который содержит «адрес», по которому настоящее значение расположено в памяти.

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

Хранение числовых и строковых данных

Тут вы можете вспомнить о том, что выше, в одной из таблиц, было показано, что для хранения данных объектных типов используется переменный объём памяти. Хотя каждый указатель занимает 1 байт памяти, каждое конкретное строковое значение занимает тот же объём памяти, который использовался бы для хранения отдельно взятой строки в Python. Для того чтобы это подтвердить, воспользуемся методом sys.getsizeof(). Сначала взглянем на отдельные строки, а затем на объект Series pandas, хранящий строковые данные.

Итак, сначала исследуем обычные строки:

from sys import getsizeof

s1 = 'working out'
s2 = 'memory usage for'
s3 = 'strings in python is fun!'
s4 = 'strings in python is fun!'

for s in [s1, s2, s3, s4]:
    print(getsizeof(s))

Здесь данные по использованию памяти выглядят так:

60
65
74
74

Теперь посмотрим на то, как выглядит использование строк в объекте Series:

obj_series = pd.Series(['working out',
                          'memory usage for',
                          'strings in python is fun!',
                          'strings in python is fun!'])
obj_series.apply(getsizeof)

Здесь мы получаем следующее:

0    60
1    65
2    74
3    74
dtype: int64

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

Оптимизация хранения данных объектных типов с использованием категориальных переменных

Категориальные переменные появились в pandas версии 0.15. Соответствующий тип, category, использует в своих внутренних механизмах, вместо исходных значений, хранящихся в столбцах таблицы, целочисленные значения. Pandas использует отдельный словарь, устанавливающий соответствия целочисленных и исходных значений. Такой подход полезен в тех случаях, когда столбцы содержат значения из ограниченного набора. Когда данные, хранящиеся в столбце, конвертируют в тип category, pandas использует подтип int, который позволяет эффективнее всего распорядиться памятью и способен представить все уникальные значения, встречающиеся в столбце.

Исходные данные и категориальные данные, использующие подтип int8

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

gl_obj = gl.select_dtypes(include=['object']).copy()
gl_obj.describe()

То, что у нас получилось, вы может найти в этой таблице, на листе Количество уникальных значений в столбцах.

Например, в столбце day_of_week, представляющем собой день недели, в который проводилась игра, имеется 171907 значений. Среди них всего 7 уникальных. В целом же, одного взгляда на этот отчёт достаточно для того, чтобы понять, что во многих столбцах для представления данных примерно 172000 игр используется довольно-таки мало уникальных значений.

Прежде чем мы займёмся полномасштабной оптимизацией, давайте выберем какой-нибудь один столбец, хранящий объектные данные, да хотя бы day_of_week, и посмотрим, что происходит внутри программы при преобразовании его в категориальный тип.

Как уже было сказано, в этом столбце содержится всего 7 уникальных значений. Для преобразования его в категориальный тип воспользуемся методом .astype().

dow = gl_obj.day_of_week
print(dow.head())

dow_cat = dow.astype('category')
print(dow_cat.head())

Вот что у нас получилось:

0    Thu
1    Fri
2    Sat
3    Mon
4    Tue
Name: day_of_week, dtype: object
0    Thu
1    Fri
2    Sat
3    Mon
4    Tue
Name: day_of_week, dtype: category
Categories (7, object): [Fri, Mon, Sat, Sun, Thu, Tue, Wed]

Как видите, хотя тип столбца изменился, данные, хранящиеся в нём, выглядят так же, как и раньше. Посмотрим теперь на то, что происходит внутри программы.

В следующем коде мы используем атрибут Series.cat.codes для того, чтобы выяснить то, какие целочисленные значения тип category использует для представления каждого из дней недели:

dow_cat.head().cat.codes

Нам удаётся выяснить следующее:

0    4
1    0
2    2
3    1
4    5
dtype: int8

Тут можно заметить то, что каждому уникальному значению назначено целочисленное значение, и то, что столбец теперь имеет тип int8. Здесь нет отсутствующих значений, но если бы это было так, для указания таких значений использовалось бы число -1.

Теперь давайте сравним потребление памяти до и после преобразования столбца day_of_week к типу category.

print(mem_usage(dow))
print(mem_usage(dow_cat))

Вот что тут получается:

9.84 MB
0.16 MB

Как видно, сначала потреблялось 9.84 мегабайт памяти, а после оптимизации — лишь 0.16 мегабайт, что означает 98% улучшение этого показателя. Обратите внимание на то, что работа с этим столбцом, вероятно, демонстрирует один из наиболее выгодных сценариев оптимизации, когда в столбце, содержащем примерно 172000 элементов, используется лишь 7 уникальных значений.

Хотя идея преобразования всех столбцов к этому типу данных выглядит привлекательно, прежде чем это делать, стоит учитывать негативные побочные эффекты такого преобразования. Так, наиболее серьёзный минус этого преобразования заключается в невозможности выполнения арифметических операций над категориальными данными. Это касается и обычных арифметических операций, и использования методов наподобие Series.min() и Series.max() без предварительного преобразования данных к настоящему числовому типу.

Нам стоит ограничить использование типа category, в основном, столбцами, хранящими данные типа object, в которых уникальными являются менее 50% значений. Если все значения в столбце уникальны, то использование типа category приведёт к повышению уровня использования памяти. Это происходит из-за того, что в памяти приходится хранить, в дополнение к числовым кодам категорий, ещё и исходные строковые значения. Подробности об ограничениях типа category можно почитать в документации к pandas.

Создадим цикл, который перебирает все столбцы, хранящие данные типа object, выясняет, не превышает ли число уникальных значений в столбцах 50%, и если это так, преобразует их в тип category.

converted_obj = pd.DataFrame()

for col in gl_obj.columns:
    num_unique_values = len(gl_obj[col].unique())
    num_total_values = len(gl_obj[col])
    if num_unique_values / num_total_values < 0.5:
        converted_obj.loc[:,col] = gl_obj[col].astype('category')
    else:
        converted_obj.loc[:,col] = gl_obj[col]

Теперь сравним то, что получилось после оптимизации, с тем, что было раньше:

print(mem_usage(gl_obj))
print(mem_usage(converted_obj))

compare_obj = pd.concat([gl_obj.dtypes,converted_obj.dtypes],axis=1)
compare_obj.columns = ['before','after']
compare_obj.apply(pd.Series.value_counts)

Получим следующее:

752.72 MB
51.67 MB

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

Как видно, объём памяти, необходимый для работы со столбцами, хранящими данные типа object, снизился с 752 мегабайт до 52 мегабайт, то есть на 93%. Теперь давайте посмотрим на то, как нам удалось оптимизировать потребление памяти по всему набору данных. Проанализируем то, на какой уровень использования памяти мы вышли, если сравнить то, что получилось, с исходным показателем в 891 мегабайт.

optimized_gl[converted_obj.columns] = converted_obj

mem_usage(optimized_gl)

Вот что у нас получилось:

'103.64 MB'

Результат впечатляет. Но мы ещё можем кое-что улучшить. Как было показано выше, в нашей таблице имеются данные типа datetime, столбец, хранящий которые, можно использовать в качестве первого столбца набора данных.

date = optimized_gl.date
print(mem_usage(date))
date.head()

В плане использования памяти здесь получается следующее:

0.66 MB

Вот сводка по данным:

0    18710504
1    18710505
2    18710506
3    18710508
4    18710509
Name: date, dtype: uint32

Можно вспомнить, что исходные данные были представлены в целочисленном виде и уже оптимизированы с использованием типа uint32. Из-за этого преобразование этих данных в тип datetime приведёт к удвоению потребления памяти, так как этот тип использует для хранения данных 64 бита. Однако в преобразовании данных к типу datetime, всё равно, есть смысл, так как это позволит нам легче выполнять анализ временных рядов.

Преобразование выполняется с использованием функции to_datetime(), параметр format которой указывает на то, что данные хранятся в формате YYYY-MM-DD.

optimized_gl['date'] = pd.to_datetime(date,format='%Y%m%d')

print(mem_usage(optimized_gl))
optimized_gl.date.head()

В результате получается следующее:

104.29 MB

Данные теперь выглядят так:

0   1871-05-04
1   1871-05-05
2   1871-05-06
3   1871-05-08
4   1871-05-09
Name: date, dtype: datetime64[ns]

Выбор типов при загрузке данных

До сих пор мы исследовали способы уменьшения потребления памяти существующим объектом DataFrame. Мы сначала считывали данные в их исходном виде, затем, пошагово, занимались их оптимизацией, сравнивая то, что получилось, с тем, что было. Это позволило как следует разобраться с тем, чего можно ожидать от тех или иных оптимизаций. Как уже было сказано, часто для представления всех значений, входящих в некий набор данных, может попросту не хватить памяти. В связи с этим возникает вопрос о том, как применить методики экономии памяти в том случае, если нельзя даже создать объект DataFrame, который предполагается оптимизировать.

К счастью, оптимальные типы данных для отдельных столбцов можно указать ещё до фактической загрузки данных. Функция pandas.read_csv() имеет несколько параметров, позволяющих это сделать. Так, параметр dtype принимает словарь, в котором присутствуют, в виде ключей, строковые имена столбцов, и в виде значений — типы NumPy.

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

dtypes = optimized_gl.drop('date',axis=1).dtypes

dtypes_col = dtypes.index
dtypes_type = [i.name for i in dtypes.values]

column_types = dict(zip(dtypes_col, dtypes_type))

# вместо вывода всех 161 элементов, мы
# возьмём 10 пар ключ/значение из словаря
# и аккуратно их выведем

preview = first2pairs = {key:value for key,value in list(column_types.items())[:10]}
import pprint
pp = pp = pprint.PrettyPrinter(indent=4)
pp.pprint(preview)
Вот что у нас получится:
{   'acquisition_info': 'category',
    'h_caught_stealing': 'float32',
    'h_player_1_name': 'category',
    'h_player_9_name': 'category',
    'v_assists': 'float32',
    'v_first_catcher_interference': 'float32',
    'v_grounded_into_double': 'float32',
    'v_player_1_id': 'category',
    'v_player_3_id': 'category',
    'v_player_5_id': 'category'}

Теперь мы сможем воспользоваться этим словарём вместе с несколькими параметрами, касающимися данных о датах проведения игр, в ходе загрузки данных.

Соответствующий код получается довольно-таки компактным:

read_and_optimized = pd.read_csv('game_logs.csv',dtype=column_types,parse_dates=['date'],infer_datetime_format=True)

print(mem_usage(read_and_optimized))
read_and_optimized.head()

В результате объём использования памяти выглядит так:

104.28 MB

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

Внешне таблицы, приведённые на листах Фрагмент оптимизированного набора данных и Фрагмент исходного набора данных, за исключением столбца с датами, выглядят одинаково, но это касается лишь их внешнего вида. Благодаря оптимизации использования памяти в pandas нам удалось снизить потребление памяти с 861.6 Мбайт до 104.28 Мбайт, получив впечатляющий результат экономии 88% памяти.

Анализ бейсбольных матчей

Теперь, после того, как мы оптимизировали данные, мы можем заняться их анализом. Взглянем на распределение игровых дней.

optimized_gl['year'] = optimized_gl.date.dt.year
games_per_day = optimized_gl.pivot_table(index='year',columns='day_of_week',values='date',aggfunc=len)
games_per_day = games_per_day.divide(games_per_day.sum(axis=1),axis=0)

ax = games_per_day.plot(kind='area',stacked='true')
ax.legend(loc='upper right')
ax.set_ylim(0,1)
plt.show()

Дни, в которые проводились игры

Как видно, до 1920-х годов игры редко проводились по воскресеньям, после чего, примерно в течение 50 лет, игры в этот день постепенно проводились всё чаще.

Кроме того, можно заметить, что распределение дней недели, в которые проводились игры последние 50 лет, является практически неизменным.

Теперь взглянем на то, как со временем менялась длительность игр.

game_lengths = optimized_gl.pivot_table(index='year', values='length_minutes')
game_lengths.reset_index().plot.scatter('year','length_minutes')
plt.show()

Длительность игр

Возникает такое ощущение, что с 1940-х годов по настоящее время матчи становятся всё более длительными.

Итоги

В этом материале мы обсудили особенности хранения данных разных типов в pandas, после чего воспользовались полученными знаниями для уменьшения объёма памяти, необходимого для хранения объекта DataFrame, почти на 90%. Для этого мы применили две простые методики:

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

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

Уважаемые читатели! Перевести эту статью нам порекомендовал наш читатель eugene_bb. Если вам известны какие-нибудь интересные материалы, которые стоит перевести — расскажите нам о них.

import pandas as pd 

import pandas as pd #Импортируем библиотеку Pandas.
 
series_example = pd.Series([4, 7, -5, 3]) #Создаём объект Series, содержащий числа.
 
series_example #Выводим объект на экран.

import pandas as pd #Импортируем библиотеку Pandas.
 
city = {'Город': ['Москва', 'Санкт-Петербург', 'Новосибирск', 'Екатеринбург'],
        'Год основания': [1147, 1703, 1893, 1723], 
        'Население': [11.9, 4.9, 1.5, 1.4]} #Создаём словарь с нужной информацией о городах.
 
df = pd.DataFrame(city) #Превращаем словарь в DataFrame, используя стандартный метод библиотеки.
 
df #Выводим DataFrame на экран.

df = pd.read_csv('/content/Internet Speed 2022.csv')

df

df.head()

df.dtypes

df.describe()

df.sort_values('mobile', ascending=False).head()

df.dropna()

df_without_nan = df.dropna()

df_without_nan.sort_values('mobile', ascending=True)

Научитесь: Профессия Python-разработчик
Узнать больше

Pandas – это библиотека с открытым исходным кодом на Python. Она предоставляет готовые к использованию высокопроизводительные структуры данных и инструменты анализа данных.

• Модуль Pandas работает поверх NumPy и широко используется для обработки и анализа данных.
• NumPy – это низкоуровневая структура данных, которая поддерживает многомерные массивы и широкий спектр математических операций с массивами. Pandas имеет интерфейс более высокого уровня. Он также обеспечивает оптимизированное согласование табличных данных и мощную функциональность временных рядов.
• DataFrame – это ключевая структура данных в Pandas. Это позволяет нам хранить и обрабатывать табличные данные, как двумерную структуру данных.
• Pandas предоставляет богатый набор функций для DataFrame. Например, выравнивание данных, статистика данных, нарезка, группировка, объединение, объединение данных и т.д.

Для установки модуля Pandas вам потребуется Python 2.7 и выше.

Если вы используете conda, вы можете установить его, используя команду ниже.

conda install pandas

Если вы используете PIP, выполните команду ниже, чтобы установить модуль pandas.

pip3.7 install pandas

Чтобы импортировать Pandas и NumPy в свой скрипт Python, добавьте следующий фрагмент кода:

import pandas as pd
import numpy as np

Поскольку Pandas зависит от библиотеки NumPy, нам нужно импортировать эту зависимость.

Структуры данных

Модуль Pandas предоставляет 3 структуры данных, а именно:

• Series: это одномерный массив неизменного размера, подобный структуре, имеющей однородные данные.
• DataFrames: это двумерная табличная структура с изменяемым размером и неоднородно типизированными столбцами.
• Panel: это трехмерный массив с изменяемым размером.

DataFrame

DataFrame – самая важная и широко используемая структура данных, а также стандартный способ хранения данных. Она содержит данные, выровненные по строкам и столбцам, как в таблице SQL или в базе данных электронной таблицы.

Мы можем либо жестко закодировать данные в DataFrame, либо импортировать файл CSV, файл tsv, файл Excel, таблицу SQL и т.д.

Мы можем использовать приведенный ниже конструктор для создания объекта DataFrame.

pandas.DataFrame(data, index, columns, dtype, copy)

Ниже приводится краткое описание параметров:

• data – создать объект DataFrame из входных данных. Это может быть список, dict, series, Numpy ndarrays или даже любой другой DataFrame;
• index – имеет метки строк;
• columns – используются для создания подписей столбцов;
• dtype – используется для указания типа данных каждого столбца, необязательный параметр;
• copy – используется для копирования данных, если есть.

Есть много способов создать DataFrame. Мы можем создать объект из словарей или списка словарей. Мы также можем создать его из списка кортежей, CSV, файла Excel и т.д.

Давайте запустим простой код для создания DataFrame из списка словарей.

import pandas as pd
import numpy as np
df = pd.DataFrame({
    "State": ['Andhra Pradesh', 'Maharashtra', 'Karnataka', 'Kerala', 'Tamil Nadu'],
    "Capital": ['Hyderabad', 'Mumbai', 'Bengaluru', 'Trivandrum', 'Chennai'],
    "Literacy %": [89, 77, 82, 97,85],
    "Avg High Temp(c)": [33, 30, 29, 31, 32 ]
})
print(df)

Вывод:

Первый шаг – создать словарь. Второй шаг – передать словарь в качестве аргумента в метод DataFrame(). Последний шаг – распечатать DataFrame.

Как видите, DataFrame можно сравнить с таблицей, имеющей неоднородное значение. Кроме того, можно изменить размер.

Мы предоставили данные в виде карты, и ключи карты рассматриваются Pandas, как метки строк.

Индекс отображается в крайнем левом столбце и имеет метки строк. Заголовок столбца и данные отображаются в виде таблицы.

Также возможно создавать индексированные DataFrames. Это можно сделать, настроив параметр индекса.

Импорт данных из CSV

Мы также можем создать DataFrame, импортировав файл CSV. Файл CSV – это текстовый файл с одной записью данных в каждой строке. Значения в записи разделяются символом «запятая».

Pandas предоставляет полезный метод с именем read_csv() для чтения содержимого файла CSV.

Например, мы можем создать файл с именем «cities.csv», содержащий подробную информацию о городах Индии. Файл CSV хранится в том же каталоге, что и сценарии Python. Этот файл можно импортировать с помощью:

import pandas as pd
data =  pd.read_csv('cities.csv')
print(data)

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

Проверка данных

print(df.head(2))

print(df.tail(1))

Точно так же print (df.dtypes) печатает типы данных.

print (df.index) печатает index.

print (df.columns) печатает столбцы DataFrame.

print (df.values) отображает значения таблицы.

1. Получение статистической сводки записей

print(df['Literacy %'].describe())

Функция df.describe() отображает статистическую сводку вместе с типом данных.

2. Сортировка записей

print(df.sort_values('Literacy %', ascending=False))

3. Нарезка записей

df['Capital']

(df.Capital)

print(df[['State', 'Capital']])

df[0:3]

Интересной особенностью библиотеки Pandas является выбор данных на основе меток строк и столбцов с помощью функции iloc [0].

Часто для анализа может потребоваться всего несколько столбцов. Мы также можем выбрать по индексу, используя loc [‘index_one’]).

Например, чтобы выбрать вторую строку, мы можем использовать df.iloc [1 ,:].

Допустим, нам нужно выбрать второй элемент второго столбца. Это можно сделать с помощью функции df.iloc [1,1]. В этом примере функция df.iloc [1,1] отображает в качестве вывода «Мумбаи».

4. Фильтрация данных

print(df[df['Literacy %']>90])

Для фильтрации по условию можно использовать любой оператор сравнения.

print(df[df['State'].isin(['Karnataka', 'Tamil Nadu'])])

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

df.rename(columns = {'Literacy %':'Literacy percentage'}, inplace=True)
print(df.head())

Аргумент inplace = True вносит изменения в DataFrame.

6. Сбор данных

Наука о данных включает в себя обработку данных, чтобы данные могли хорошо работать с алгоритмами данных. Data Wrangling – это процесс обработки данных, такой как слияние, группировка и конкатенация.

Библиотека Pandas предоставляет полезные функции, такие как merge(), groupby() и concat() для поддержки задач Data Wrangling.

import pandas as pd

d = {  
    'Employee_id': ['1', '2', '3', '4', '5'],
    'Employee_name': ['Akshar', 'Jones', 'Kate', 'Mike', 'Tina']
}
df1 = pd.DataFrame(d, columns=['Employee_id', 'Employee_name'])  
print(df1)

import pandas as pd

data = {  
    'Employee_id': ['4', '5', '6', '7', '8'],
    'Employee_name': ['Meera', 'Tia', 'Varsha', 'Williams', 'Ziva']
}
df2 = pd.DataFrame(data, columns=['Employee_id', 'Employee_name'])  
print(df2)

а. merge()

print(pd.merge(df1, df2, on='Employee_id'))

Мы видим, что функция merge() возвращает строки из обоих DataFrames, имеющих то же значение столбца, которое использовалось при слиянии.

b. Группировка

import pandas as pd
import numpy as np

data = {
    'Employee_id': ['4', '5', '6', '7', '8'],
    'Employee_name': ['Meera', 'Meera', 'Varsha', 'Williams', 'Ziva']
}
df2 = pd.DataFrame(data)

group = df2.groupby('Employee_name')
print(group.get_group('Meera'))

Поле «Employee_name» со значением «Meera» сгруппировано по столбцу «Employee_name». Пример вывода приведен ниже:

c. Конкатенация

print(pd.concat([df1, df2]))

Создание DataFrame, переход Dict в Series

series_sample = pd.Series([100, 200, 300, 400])
print(series_sample)

Мы создали серию. Вы можете видеть, что отображаются 2 столбца. Первый столбец содержит значения индекса, начиная с 0. Второй столбец содержит элементы, переданные как серии.

Можно создать DataFrame, передав словарь Series. Давайте создадим DataFrame, который формируется путем объединения и передачи индексов ряда.

d = {'Matches played' : pd.Series([400, 300, 200], index=['Sachin', 'Kohli', 'Raina']),
'Position' : pd.Series([1, 2, 3, 4], index=['Sachin', 'Kohli', 'Raina', 'Dravid'])}
df = pd.DataFrame(d)
print(df)

Для первой серии, поскольку мы не указали метку ‘d’, возвращается NaN.

Выбор столбца, добавление и удаление

d = {'Matches played' : pd.Series([400, 300, 200], index=['Sachin', 'Kohli', 'Raina']),
 'Position' : pd.Series([1, 2, 3, 4], index=['Sachin', 'Kohli', 'Raina', 'Dravid'])}
df = pd.DataFrame(d)
print(df['Matches played'])

Приведенный выше код печатает только столбец «Matches played» в DataFrame.

d = {'Matches played' : pd.Series([400, 300, 200], index=['Sachin', 'Kohli', 'Raina']),
 'Position' : pd.Series([1, 2, 3, 4], index=['Sachin', 'Kohli', 'Raina', 'Dravid'])}
df = pd.DataFrame(d)
df['Runrate']=pd.Series([80, 70, 60, 50], index=['Sachin', 'Kohli', 'Raina', 'Dravid'])
print(df)

del df['Matches played']

df.pop('Matches played')

Заключение

В этом руководстве у нас было краткое введение в библиотеку Pandas в Python. Мы также сделали практические примеры, чтобы раскрыть возможности библиотеки, используемой в области науки о данных. Мы также рассмотрели различные структуры данных в библиотеке Python.

На главную

Анализ данных на языке Python

• Открытая наука и разработка программного обеспечения для исследований
• Введение в pandas (на русском языке)
• Уроки по работе с pandas (на русском языке)
• Уроки по визуализации данных (на русском языке)
• Кейсы и упражнения по pandas
• Полезные модули и сервисы для анализа данных
• Элементы науки о данных (на русском языке)
• Введение в байесовскую статистику с использованием Python (на русском языке)
• Модульные тесты для специалистов по данным (на русском языке)
• Шпаргалки по pandas и Python
• Учебники по анализу данных на Python (в оригинале)
• Справочники и учебники по визуализации в Python (в оригинале)
• Шпаргалки по Matplotlib (в оригинале)

Этапы анализа данных на языке Python:

Уроки по работе с pandas на русском языке

Уроки по визуализации данных на русском языке

Полезные модули и сервисы для анализа данных

Шаблон Cookiecutter на русском языке: позволяет автоматизировать создание структуры файлов и каталогов для проекта по анализу данных.

Открытая наука и разработка программного обеспечения для исследований

Исследовательская разработка программного обеспечения (перевод книги)

1. Введение [HTML]
2. Структура проекта [HTML]
3. Создание инструментов с помощью командной оболочки [HTML] [CoLab]

Полезные материалы по открытой науке

• Открытая наука как драйвер развития научно-исследовательской деятельности [HTML]
• Textbook manifesto by Allen B. Downey [HTML]
• Free Books, Why Not? by Allen B. Downey [HTML]
• Research Software Engineering with Python [HTML] [GitHub]

Элементы науки о данных на русском языке (Elements Of Data Science, professor Allen Downey)

Введение в байесовскую статистику с использованием Python на русском языке (Bite Size Bayes, professor Allen Downey)

Кейсы и упражнения по pandas

• Пример очистки данных titanic с помощью apply в [HTML]
• Задание про метод apply в pandas о классификации вин в [Colab]
• Регулярные выражения в Python и pandas [CoLab]
• Что добавляют в избранное на Ozon в 2020 году? [CoLab]
• Что не находят на Ozon в 2020 году? [CoLab]
• Вакансии и зарплаты в Тинькофф в 2019 году [CoLab]
• Анализ статистики COVID-19 в мире [CoLab]
• Анализ частоты запросов на Яндекс.Метрике с помощью модуля pymorphy2 [CoLab]

Шпаргалки по pandas и Python

• Основные функции загрузки и выгрузки данных в Python и pandas [HTML]
• Основные команды при работе с утилитой conda [PDF]
• Типы данных и операции в классическом Python [PDF]
• Операции над матрицами в NumPy [PDF]
• Официальная шпаргалка по pandas [PDF]
• Восхитительная шпаргалка по pandas [PDF]
• Шпаргалка по pandas от Enthought [PDF]
• Презентация по типу данных Series (на русском языке) [PDF]
• Презентация по типу данных DataFrame (на русском языке) [PDF]
• Категориальные данные (на русском языке) [PDF]
• Временные ряды (на русском языке) [PDF]
• Сводные таблицы (на русском языке) [PDF]
• Агрегирование и группировка (на русском языке) [PDF]
• Слияние и соединение (на русском языке) [PDF]
• Объединение наборов данных (на русском языке) [PDF]
• Иерархическая индексация (на русском языке) [PDF]
• Приведение данных в порядок (на русском языке) [PDF]
• Шпаргалка по Seaborn [PDF]
• Шпаргалка по plotly [PDF]
• Шпаргалка по git [PDF]
• Шпаргалка по git от Atlassian [PDF]
• Шпаргалка по git от GitHub Education [PDF]
• Шпаргалка по регулярным выражениям на Python [PDF]
• Шпаргалка по регулярным выражениям (на русском языке) [PDF]
• Шпаргалка по командам IPython [Ipython-quick-ref-sheets]

Учебники по анализу данных на Python / bash в оригинале

• Изучение науки о данных (Learning Data Science by Sam Lau, Joey Gonzalez, and Deb Nolan) [оригинал книги]
• Справочник по науке о данных на Python (Python Data Science Handbook, Jake VanderPlas) [оригинал книги] [GitHub]
• Книга Python для анализа данных, 3-издание (Wes McKinney) (Python for Data Analysis, 3E) [оригинал книги]
• Elements of Data Science by Allen B. Downey [оригинал книги]
• Scientific Computing in Python: Introduction to NumPy and Matplotlib by Sebastian Raschka [оригинал книги]
• Книга интервью по науке о данных (The Datascience Interview Project) [оригинал книги]
• Вычислительное и дедуктивное мышление: основы науки о данных (Data 8) (Computational and Inferential Thinking: The Foundations of Data Science) [оригинал книги]
• Программирование для экономистов (Coding for Economists) [оригинал книги]
• Программирование на Python для науки о данных (PY4DS) (Python Programming for Data Science) [оригинал книги]
• Введение в экономическое моделирование и науку о данных (Introduction to Economic Modeling and Data Science) [оригинал книги]
• The Turing Way project [оригинал книги]
• Введение в культурную аналитику и Python (Introduction to Cultural Analytics & Python) [оригинал книги]
• Введение в науку о Земле и окружающей среде (An Introduction to Earth and Environmental Data Science) [оригинал книги]
• Введение в науку о данных о Земле (Introduction to Earth Data Science) [оригинал книги]
• Воспроизводимая наука о данных с Python (Reproducible Data Science with Python) [оригинал книги]
• Воспроизводимые и надежные рабочие процессы для науки о данных (Reproducible and Trustworthy Workflows for Data Science) [оригинал книги]
• The Programming Historian [оригинал книги]
• Наука о данных в командной строке (Data Science at the Command Line) [оригинал книги]
• Воспроизводимая наука о данных. Инструменты воспроизводимых исследований [лекции на русском языке]

Справочники и учебники по визуализации в Python в оригинале

• Изучите Streamlit [оригинал на сайте автора]
• Картирование и визуализация данных с помощью Python [оригинал на сайте автора]
• Графические библиотеки (автор José Carlos Soage) [оригинальный сайт]
• Поваренная книга по визуализации данных на Python (Pandas, Matplotlib, Seaborn, Plotly Express) [оригинальный сайт]
• Учебная программа по визуализации данных (Vega-Lite, Altair) [оригинальный сайт]
• Данные в стране чудес [оригинальная статья]
• Шаблоны проектирования информационных панелей [оригинальный сайт]

Шпаргалки по Matplotlib

• Шпаргалка по Matplotlib [PDF]
• Шпаргалка Быстрый старт 1 [PNG]
• Шпаргалка Быстрый старт 2 [PNG]
• Шпаргалка для начинающих [PNG]
• Шпаргалка для продвинутых пользователей [PNG]

Источники данных

• PySport [сайт проекта]

Модульные тесты для специалистов по данным на русском языке

• Возможности pytest [блокнот в Colab]

Python и кибербезопасность

• Блокноты переехали на [отдельную страницу]

Pandas — главная Python—библиотека для анализа данных. Она быстрая и мощная: в ней можно работать с таблицами, в которых миллионы строк. Вместе с Марией Жаровой, ментором проекта на курсе по Data Science, рассказываем про команды, которые позволят начать работать с реальными данными.

Среда разработки

Pandas работает как в IDE (средах разработки), так и в облачных блокнотах для программирования. Как установить библиотеку в конкретную IDE, читайте тут. Мы для примера будем работать в облачной среде Google Colab. Она удобна тем, что не нужно ничего устанавливать на компьютер: файлы можно загружать и работать с ними онлайн, к тому же есть совместный режим для работы с коллегами. Про Colab мы писали в этом обзоре.

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

На сайте Google Colab сразу появляется экран с доступными блокнотами. Создадим новый блокнот:

Импортирование библиотеки

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

pd — это распространенное сокращенное название библиотеки. Далее будем обращаться к ней именно так.

Загрузка данных

В качестве тренировочного набора данных будем использовать «Отчет об уровне счастья» в разных странах за 2019 год (World Happiness Report). Открыть его можно двумя способами.

1. Загрузить в сессионное хранилище:

И прочитать с помощью такой команды: df = pd.read_csv('WHR_2019.csv')

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

Это можно сделать через словарь и через преобразование вложенных списков (фактически таблиц).

Через словарь: my_df = pd.DataFrame({'id': [1, 2, 3], 'name': ['Bob', 'Alice', 'Scott'], 'age': [21, 15, 30]})

Через вложенные списки: df = pd.DataFrame([[1,'Bob', 21], [2,'Alice', 15], [3,'Scott', 30]], columns = ['id','name', 'age'])

Результаты будут эквивалентны.

Просмотр данных

Загруженный файл преобразован во фрейм и теперь хранится в переменной df. Посмотрим, как он выглядит, с помощью метода .head(), который по умолчанию выводит пять первых строк: df.head()

Если нужно посмотреть на другое количество строк, оно указывается в скобках, например df.head(12). Последние строки фрейма выводятся методом .tail().

Также чтобы просто полностью красиво отобразить датасет, используется функция display(). По умолчанию в Jupyter Notebook, если написать имя переменной на последней строке какой-либо ячейки (даже без ключевого слова display), ее содержимое будет отображено.

display(df) #эквивалентно команде df, если это последняя строка ячейки

Размеры датасета

Количество строк и столбцов в датафрейме можно узнать, используя метод .shape: df.shape #покажет размеры сразу по двум осям df.shape[0] #размер по горизонтали - то есть количество строк df.shape[1] #размер по горизонтали - то есть количество столбцов

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

Названия столбцов можно переименовать под себя с помощью команды rename: df.rename(columns = {'Overall rank':'Место в рейтинге', 'Country or region':'Страна или регион', 'Score':'Баллы', 'GDP per capita':'ВВП на душу населения', 'Social support':'Социальная поддержка', 'Healthy life expectancy':'Ожидаемая продолжительность здоровой жизни', 'Freedom to make life choices':'Свобода жизненных выборов', 'Generosity':'Щедрость', 'Perceptions of corruption':'Восприятие коррупции'}, inplace = True) df.head()

Характеристики датасета

Чтобы получить первичное представление о статистических характеристиках нашего датасета, достаточно этой команды: df.describe()

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

Еще одна команда показывает другую справку: сколько значений в каждом столбце (в нашем случае в столбцах нет пропущенных значений) и формат данных: df.info()

Работа с отдельными столбцами или строками

Выделить несколько столбцов можно разными способами.

1. Сделать срез фрейма df[['Место в рейтинге', 'Ожидаемая продолжительность здоровой жизни']]

Срез можно сохранить в новой переменной: data_new = df[['Место в рейтинге', 'Ожидаемая продолжительность здоровой жизни']]

Теперь можно выполнить любое действие с этим сокращенным фреймом.

2. Использовать метод loc

Если столбцов очень много, можно использовать метод loc, который ищет значения по их названию: df.loc [:, 'Место в рейтинге':'Социальная поддержка']

В этом случае мы оставили все столбцы от Места в рейтинге до Социальной поддержки.

3. Использовать метод iloc

Если нужно вырезать одновременно строки и столбцы, можно сделать это с помощью метода iloc:df.iloc[0:100, 0:5]

Первый параметр показывает индексы строк, которые останутся, второй — индексы столбцов. Получаем такой фрейм:

В методе iloc значения в правом конце исключаются, поэтому последняя строка, которую мы видим, — 99.

4. Использовать метод tolist()

Можно выделить какой-либо столбец в отдельный список при помощи метода tolist(). Это упростит задачу, если необходимо извлекать данные из столбцов: df['Баллы'].tolist()

Часто бывает нужно получить в виде списка названия столбцов датафрейма. Это тоже можно сделать с помощью метода tolist(): df.columns.tolist()

Добавление новых строк и столбцов

В исходный датасет можно добавлять новые столбцы, создавая новые «признаки», как говорят в машинном обучении. Например, создадим столбец «Сумма», в который просуммируем значения колонок «ВВП на душу населения» и «Социальная поддержка» (сделаем это в учебных целях, практически суммирование этих показателей не имеет смысла): df['Сумма'] = df['ВВП на душу населения'] + df['Социальная поддержка']

Можно добавлять и новые строки: для этого нужно составить словарь с ключами — названиями столбцов. Если вы не укажете значения в каких-то столбцах, они по умолчанию заполнятся пустыми значениями NaN. Добавим еще одну страну под названием Country: new_row = {'Место в рейтинге': 100, 'Страна или регион': 'Country', 'Баллы': 100} df = df.append(new_row, ignore_index=True)

Важно: при добавлении новой строки методом .append() не забывайте указывать параметр ignore_index=True, иначе возникнет ошибка.

Иногда бывает полезно добавить строку с суммой, медианой или средним арифметическим) по столбцу. Сделать это можно с помощью агрегирующих (aggregate (англ.) — группировать, объединять) функций: sum(), mean(), median(). Для примера добавим в конце строку с суммами значений по каждому столбцу: df = df.append(df.sum(axis=0), ignore_index = True)

Удаление строк и столбцов

Удалить отдельные столбцы можно при помощи метода drop() — это целесообразно делать, если убрать нужно небольшое количество столбцов. df = df.drop(['Сумма'], axis = 1)

В других случаях лучше воспользоваться описанными выше срезами.

Обратите внимание, что этот метод требует дополнительного сохранения через присваивание датафрейма с примененным методом исходному. Также в параметрах обязательно нужно указать axis = 1, который показывает, что мы удаляем именно столбец, а не строку.

Соответственно, задав параметр axis = 0, можно удалить любую строку из датафрейма: для этого нужно написать ее номер в качестве первого аргумента в методе drop(). Удалим последнюю строчку (указываем ее индекс — это будет количество строк): df = df.drop(df.shape[0]-1, axis = 0)

Копирование датафрейма

Можно полностью скопировать исходный датафрейм в новую переменную. Это пригодится, если нужно преобразовать много данных и при этом работать не с отдельными столбцами, а со всеми данными: df_copied = df.copy()

Уникальные значения

Уникальные значения в какой-либо колонке датафрейма можно вывести при помощи метода .unique(): df['Страна или регион'].unique()

Чтобы дополнительно узнать их количество, можно воспользоваться функцией len():len(df['Страна или регион'].unique())

Подсчет количества значений

Отличается от предыдущего метода тем, что дополнительно подсчитывает количество раз, которое то или иное уникальное значение встречается в колонке, пишется как .value_counts(): df['Страна или регион'].value_counts()

Группировка данных

Некоторым обобщением .value_counts() является метод .groupby() — он тоже группирует данные какого-либо столбца по одинаковым значениям. Отличие в том, что при помощи него можно не просто вывести количество уникальных элементов в одном столбце, но и найти для каждой группы сумму / среднее значение / медиану по любым другим столбцам.

Рассмотрим несколько примеров. Чтобы они были более наглядными, округлим все значения в столбце «Баллы» (тогда в нем появятся значения, по которым мы сможем сгруппировать данные): df['Баллы_new'] = round(df['Баллы'])

1) Сгруппируем данные по новому столбцу баллов и посчитаем, сколько уникальных значений для каждой группы содержится в остальных столбцах. Для этого в качестве агрегирующей функции используем .count():df.groupby('Баллы_new').count()

Получается, что чаще всего страны получали 6 баллов (таких было 49):

2) Получим более содержательный для анализа данных результат — посчитаем сумму значений в каждой группе. Для этого вместо .count() используем sum():df.groupby('Баллы_new').sum()

3) Теперь рассчитаем среднее значение по каждой группе, в качестве агрегирующей функции в этом случае возьмем mean():df.groupby('Баллы_new').mean()

4) Рассчитаем медиану. Для этого пишем команду median():df.groupby('Баллы_new').median()

Это самые основные агрегирующие функции, которые пригодятся на начальном этапе работы с данными.

Вот пример синтаксиса, как можно сагрегировать значения по группам при помощи сразу нескольких функций: df_agg = df.groupby('Баллы_new').agg({ 'Баллы_new': 'count', 'Баллы_new': 'sum', 'Баллы_new': 'mean', 'Баллы_new': 'median' })

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

Бывает, что нужно сделать группировку сразу по двум параметрам. Для этого в Pandas используются сводные таблицы или pivot_table(). Они составляются на основе датафреймов, но, в отличие от них, группировать данные можно не только по значениям столбцов, но и по строкам.

В ячейки такой таблицы помещаются сгруппированные как по «координате» столбца, так и по «координате» строки значения. Соответствующую агрегирующую функцию указываем отдельным параметром.

Разберемся на примере. Сгруппируем средние значения из столбца «Социальная поддержка» по баллам в рейтинге и значению ВВП на душу населения. В прошлом действии мы уже округлили значения баллов, теперь округлим и значения ВВП: df['ВВП_new'] = round(df['ВВП на душу населения'])

Теперь составим сводную таблицу: по горизонтали расположим сгруппированные значения из округленного столбца «ВВП» (ВВП_new), а по вертикали — округленные значения из столбца «Баллы» (Баллы_new). В ячейках таблицы будут средние значения из столбца «Социальная поддержка», сгруппированные сразу по этим двум столбцам: pd.pivot_table(df, index = ['Баллы_new'], columns = ['ВВП_new'], values = 'Социальная поддержка', aggfunc = 'mean')

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

Строки датасета можно сортировать по значениям любого столбца при помощи функции sort_values(). По умолчанию метод делает сортировку по убыванию. Например, отсортируем по столбцу значений ВВП на душу населения: df.sort_values(by = 'ВВП на душу населения').head()

Видно, что самые высокие ВВП совсем не гарантируют высокое место в рейтинге.

Чтобы сделать сортировку по убыванию, можно воспользоваться параметром ascending (от англ. «по возрастанию») = False: df.sort_values(by = 'ВВП на душу населения', ascending=False)

Фильтрация

Иногда бывает нужно получить строки, удовлетворяющие определенному условию; для этого используется «фильтрация» датафрейма. Условия могут быть самые разные, рассмотрим несколько примеров и их синтаксис:

1) Получение строки с конкретным значением какого-либо столбца (выведем строку из датасета для Норвегии): df[df['Страна или регион'] == 'Norway']

2) Получение строк, для которых значения в некотором столбце удовлетворяют неравенству. Выведем строки для стран, у которых «Ожидаемая продолжительность здоровой жизни» больше единицы: df[df['Ожидаемая продолжительность здоровой жизни'] > 1]

3) В условиях фильтрации можно использовать не только математические операции сравнения, но и методы работы со строками. Выведем строки датасета, названия стран которых начинаются с буквы F, — для этого воспользуемся методом .startswith(): df[df['Страна или регион'].str.startswith('F')]

4) Можно комбинировать несколько условий одновременно, используя логические операторы. Выведем строки, в которых значение ВВП больше 1 и уровень социальной поддержки больше 1,5: df[(df['ВВП на душу населения'] > 1) & (df['Социальная поддержка'] > 1.5)]

Таким образом, если внутри внешних квадратных скобок стоит истинное выражение, то строка датасета будет удовлетворять условию фильтрации. Поэтому в других ситуациях можно использовать в условии фильтрации любые функции/конструкции, возвращающие значения True или False.

Применение функций к столбцам

Зачастую встроенных функций и методов для датафреймов из библиотеки бывает недостаточно для выполнения той или иной задачи. Тогда мы можем написать свою собственную функцию, которая преобразовывала бы строку датасета как нам нужно, и затем использовать метод .apply() для применения этой функции ко всем строкам нужного столбца.

Рассмотрим пример: напишем функцию, которая преобразует все буквы в строке к нижнему регистру, и применим к столбцу стран и регионов: def my_lower(row): return row.lower() df['Страна или регион'].apply(lower)

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

Это целый этап работы с данными при подготовке их к построению моделей и нейронных сетей. Рассмотрим основные приемы и функции.

1) Удаление дубликатов из датасета делается при помощи функции drop_duplucates(). По умолчанию удаляются только полностью идентичные строки во всем датасете, но можно указать в параметрах и отдельные столбцы. Например, после округления у нас появились дубликаты в столбцах «ВВП_new» и «Баллы_new», удалим их: df_copied = df.copy() df_copied.drop_duplicates(subset = ['ВВП_new', 'Баллы_new'])

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

Строки-дубликаты удаляются полностью, таким образом, их количество уменьшается. Чтобы заменить их на пустые, можно использовать параметр inplace = True.df_copied.drop_duplicates(subset = ['ВВП_new', 'Баллы_new'], inplace = True)

2) Для замены пропусков NaN на какое-либо значение используется функция fillna(). Например, заполним появившиеся после предыдущего пункта пропуски в последней строке нулями: df_copied.fillna(0)

3) Пустые строки с NaN можно и вовсе удалить из датасета, для этого используется функция dropna() (можно также дополнительно указать параметр inplace = True): df_copied.dropna()

Построение графиков

В Pandas есть также инструменты для простой визуализации данных.

1) Обычный график по точкам.

Построим зависимость ВВП на душу населения от места в рейтинге: df.plot(x = 'Место в рейтинге', y = 'ВВП на душу населения')

2) Гистограмма.

Отобразим ту же зависимость в виде столбчатой гистограммы: df.plot.hist(x = 'Место в рейтинге', y = 'ВВП на душу населения')

3) Точечный график.
df.plot.scatter(x = 'Место в рейтинге', y = 'ВВП на душу населения')

Мы видим предсказуемую тенденцию: чем выше ВВП на душу населения, тем ближе страна к первой строчке рейтинга.

Сохранение датафрейма на компьютер

Сохраним наш датафрейм на компьютер: df.to_csv('WHR_2019.csv')

Теперь с ним можно работать и в других программах.

Блокнот с кодом можно скачать здесь (формат .ipynb).

Впервые в Pandas? Вы пришли в нужное место.

Эту статью можно использовать в качестве справочника по библиотеке python pandas. Мы рассмотрим основные функции, необходимые для загрузки / хранения файлов различных форматов, очистки наборов данных и управления ими. Мы также рассмотрим преобразование фреймов данных в несколько массивов, которые будут использоваться для передачи в модель машинного обучения библиотеки sklearn.

Давайте начнем.

Вы можете установить pandas, используя:

pip3 install pandas

И обычно импортируется так:

import pandas as pd

Структуры данных

В пандах есть две структуры данных:

1. Серия

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

Пример:

In [2]: obj = pd.Series(['a','b','c','d'])
In [3]: obj
Out[3]:
0    a
1    b
2    c
3    d
dtype: object

Pandas автоматически присваивает индекс, начиная с 0. Вы можете вызвать конкретную строку с помощью obj.loc[index]. Перейдите в это для документации.

In [4]: obj.loc[0]
Out[4]: 'a'

2. DataFrame

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

Пример:

In [5]: df = pd.DataFrame({'c1':['a','b'],'c2':['c','d'],'c3':['e','f']})  #as a dict of series
In [6]: df
Out[6]:
       c1      c2      c3
0       a       c       e
1       b       d       f
In [10]: df.loc[1] #outputs a series datatype
Out[10]:
c1    b
c2    d
c3    f
Name: 1, dtype: object

Вы также можете указать индекс следующим образом:

In [8]: df = pd.DataFrame({'c1':['a','b'],'c2':['c','d'],'c3':['e','f']}, index=['zero','one'])
In [9]: df
Out[9]:
          c1      c2      c3
zero       a       c       e
one        b       d       f

Объект DataFrame может быть инициализирован множеством параметров. Перейдите в это для документации.

Фрейм данных Pandas имеет две оси. Строки — axis=0, столбцы — axis=1.

Чтение файлов / сохранение фреймов данных

Допустим, у вас есть файл данных. Он может быть любого формата (csv, xlsx, xls, json, html или sql-запрос). Pandas предоставляет функции для чтения всех типов файлов. Вы также можете читать данные с URL-адреса, указывающего на файл данных.

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

file_type     read                          save
csv           pd.read_csv('file.csv')       df.to_csv('name.csv')
xlsx          pd.read_excel('file.xlsx')    df.to_excel('name.xlsx')  
xls           pd.read_excel('file.xls')     df.to_excel('name.xls')
json          pd.read_json('file.json')     df.to_json('name.json')
html          pd.read_html(html_file)       df.to_html(html_file)
sql           pd.read_sql(sql_query)        df.to_sql(sql)
              or corresponding file urls

Все вышеперечисленные функции имеют разные параметры при чтении. Для подробного описания параметра перейдите в это.

В этой статье мы будем использовать набор данных о характеристиках автомобиля, чтобы продемонстрировать использование Pandas. Давайте прочитаем CSV-файл.

df=pd.read_csv('cars.csv')
df.head()

Названия столбцов

Теперь наш первый шаг — получить имена столбцов, чтобы знать, что каждый из них представляет. Мы можем получить список имен столбцов, используя:

df.columns

Pandas автоматически устанавливает имена столбцов в качестве первой строки набора данных, если для параметра header в функции чтения не указано значениеNone.

Проверка типов данных

Типы данных каждого столбца можно получить, используя:

df.dtypes

Вы также можете использовать:

df.summary()

Удаление дубликатов

Повторяющиеся строки можно удалить drop_duplicates методом:

df.drop_duplicates()

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

Уникальные значения:

Вы можете получить уникальные значения каждого столбца, используя df[column].unique(), а также получить счетчики, используя df[column].value_counts(). Посмотрим, как это работает.

df['Make'].unique()

df['Make'].value_counts()[:5] #get only top 5

Сортировка

Предположим, вы хотите отсортировать таблицу по highway MPG в порядке убывания, это можно сделать с помощью:

df.sort_values(by='highway MPG', ascending = False).head()

Условное извлечение

Допустим, вы хотите получить автомобили с расходом топлива на галлон больше 100 на шоссе. Это можно сделать с помощью:

df[df['highway MPG']>100].head(10)

Вы также можете добавить несколько условий. Предположим, вам нужны строки с highway MPG больше 100 Make Fiat. Это можно сделать с помощью:

df[(df['highway MPG']>100) & (df['Make']=='FIAT')]

За три года подряд появилось три автомобиля FIAT с одинаковой ценой и понижающейся ценой на галлон.

ПРИМЕЧАНИЕ. Эти методы не вносят изменений в исходный фрейм данных. Он просто извлекает отфильтрованные данные и отображает их. Вам необходимо назначить его обратно исходной переменной фрейма данных или новой переменной, чтобы использовать ее.

Удаление / фильтрация столбцов

Допустим, вам нужно удалить столбцы Engine Cylinders и Engine HP, это можно сделать с помощью:

df = df.drop(['Engine Cylinder', 'Engine HP'], axis=1)

Это отбрасывает столбцы и снова присваивает им df. Мы также можем поместить столбцы на место следующим образом:

df.drop(['Engine Cylinder', 'Engine HP'] , axis=1, inplace=True)

Оба приведенных выше кода делают то же самое. В последнем случае вам не нужно возвращать его переменной. Вместо этого набор данных с отброшенным столбцом изменяется в переменной df.

Вы также можете отбросить строки, введя соответствующие индексы строк и установив axis=0.

Теперь предположим, что вам нужно отбросить много столбцов, а вам нужны только Make, Model and Year столбцы, вы можете использовать метод drop или отфильтровать нужные столбцы следующим образом:

new_df = df[['Make','Model','Year']] 

Замена значений

Давайте посмотрим на уникальные значения в столбце Vehicle Size.

>>> df['Vehicle Size'].unique()
array(['Compact', 'Midsize', 'Large'], dtype=object)

При передаче функций данных в модель машинного обучения все категориальные строковые значения должны быть преобразованы в числа (целые числа). Столбец Vehicle Size имеет 3 категории. Заменим их на 0, 1 and 2.

#create dict to replace values
key_val = {'Compact':0,'Midsize':1,'Large':2}
df['Vehicle Size'] = df['Vehicle Size'].replace(key_val)
#Or use the inplace parameter
df['Vehicle Size'].replace(key_val, inplace=True)

Отсутствующие значения

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

df.isna().sum()

Вы можете заполнить отсутствующие значения определенным значением следующим образом:

#filling all missing values in dataframe
df.fillna(value)
#for filling values in a particular column
df[column].fillna(value, inplace=True)

Преобразование в Numpy

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

df.values

Это возвращает массив numpy с каждой строкой в ​​DataFrame в качестве элемента. Мы можем отфильтровать функции и цели по отдельности, так как они должны передаваться отдельно в модель машинного обучения.

X = df[list_of_feature_columns].values
y = df[target_column].values
model=some_model()
model.fit(X,y)

Заключение

Эта статья не охватывает все функции библиотеки Pandas, но охватывает основные операции, необходимые для очистки данных и управления ими.