Что такое pandas в python

Введение в pandas: анализ данных на Python

4 Март 2017 , Python, 740231 просмотров, Introduction to pandas: data analytics in Python

pandas это высокоуровневая Python библиотека для анализа данных. Почему я её называю высокоуровневой, потому что построена она поверх более низкоуровневой библиотеки NumPy (написана на Си), что является большим плюсом в производительности. В экосистеме Python, pandas является наиболее продвинутой и быстроразвивающейся библиотекой для обработки и анализа данных. В своей работе мне приходится пользоваться ею практически каждый день, поэтому я пишу эту краткую заметку для того, чтобы в будущем ссылаться к ней, если вдруг что-то забуду. Также надеюсь, что читателям блога заметка поможет в решении их собственных задач с помощью pandas, и послужит небольшим введением в возможности этой библиотеки.

DataFrame и Series

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

Series

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

>>> import pandas as pd >>> my_series = pd.Series([5, 6, 7, 8, 9, 10]) >>> my_series 0 5 1 6 2 7 3 8 4 9 5 10 dtype: int64 >>> 

В строковом представлении объекта Series, индекс находится слева, а сам элемент справа. Если индекс явно не задан, то pandas автоматически создаёт RangeIndex от 0 до N-1, где N общее количество элементов. Также стоит обратить, что у Series есть тип хранимых элементов, в нашем случае это int64, т.к. мы передали целочисленные значения.

У объекта Series есть атрибуты через которые можно получить список элементов и индексы, это values и index соответственно.

>>> my_series.index RangeIndex(start=0, stop=6, step=1) >>> my_series.values array([ 5, 6, 7, 8, 9, 10], dtype=int64) 

Доступ к элементам объекта Series возможны по их индексу (вспоминается аналогия со словарем и доступом по ключу).

>>> my_series[4] 9 

Индексы можно задавать явно:

>>> my_series2 = pd.Series([5, 6, 7, 8, 9, 10], index=['a', 'b', 'c', 'd', 'e', 'f']) >>> my_series2['f'] 10 

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

>>> my_series2[['a', 'b', 'f']] a 5 b 6 f 10 dtype: int64 >>> my_series2[['a', 'b', 'f']] = 0 >>> my_series2 a 0 b 0 c 7 d 8 e 9 f 0 dtype: int64 

Фильтровать Series как душе заблагорассудится, а также применять математические операции и многое другое:

>>> my_series2[my_series2 > 0] c 7 d 8 e 9 dtype: int64 >>> my_series2[my_series2 > 0] * 2 c 14 d 16 e 18 dtype: int64 

Если Series напоминает нам словарь, где ключом является индекс, а значением сам элемент, то можно сделать так:

>>> my_series3 = pd.Series() >>> my_series3 a 5 b 6 c 7 d 8 dtype: int64 >>> 'd' in my_series3 True 

У объекта Series и его индекса есть атрибут name, задающий имя объекту и индексу соответственно.

>>> my_series3.name = 'numbers' >>> my_series3.index.name = 'letters' >>> my_series3 letters a 5 b 6 c 7 d 8 Name: numbers, dtype: int64 

Индекс можно поменять «на лету», присвоив список атрибуту index объекта Series

>>> my_series3.index = ['A', 'B', 'C', 'D'] >>> my_series3 A 5 B 6 C 7 D 8 Name: numbers, dtype: int64 

Имейте в виду, что список с индексами по длине должен совпадать с количеством элементов в Series.

DataFrame

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

DataFrame проще всего сконструировать на примере питоновского словаря:

>>> df = pd.DataFrame(< . 'country': ['Kazakhstan', 'Russia', 'Belarus', 'Ukraine'], . 'population': [17.04, 143.5, 9.5, 45.5], . 'square': [2724902, 17125191, 207600, 603628] . >) >>> df country population square 0 Kazakhstan 17.04 2724902 1 Russia 143.50 17125191 2 Belarus 9.50 207600 3 Ukraine 45.50 603628 

Чтобы убедиться, что столбец в DataFrame это Series, извлекаем любой:

 >>> df['country'] 0 Kazakhstan 1 Russia 2 Belarus 3 Ukraine Name: country, dtype: object >>> type(df['country'])

Объект DataFrame имеет 2 индекса: по строкам и по столбцам. Если индекс по строкам явно не задан (например, колонка по которой нужно их строить), то pandas задаёт целочисленный индекс RangeIndex от 0 до N-1, где N это количество строк в таблице.

>>> df.columns Index([u'country', u'population', u'square'], dtype='object') >>> df.index RangeIndex(start=0, stop=4, step=1) 

В таблице у нас 4 элемента от 0 до 3.

Доступ по индексу в DataFrame

Индекс по строкам можно задать разными способами, например, при формировании самого объекта DataFrame или «на лету»:

>>> df = pd.DataFrame(< . 'country': ['Kazakhstan', 'Russia', 'Belarus', 'Ukraine'], . 'population': [17.04, 143.5, 9.5, 45.5], . 'square': [2724902, 17125191, 207600, 603628] . >, index=['KZ', 'RU', 'BY', 'UA']) >>> df country population square KZ Kazakhstan 17.04 2724902 RU Russia 143.50 17125191 BY Belarus 9.50 207600 UA Ukraine 45.50 603628 >>> df.index = ['KZ', 'RU', 'BY', 'UA'] >>> df.index.name = 'Country Code' >>> df country population square Country Code KZ Kazakhstan 17.04 2724902 RU Russia 143.50 17125191 BY Belarus 9.50 207600 UA Ukraine 45.50 603628 

Как видно, индексу было задано имя — Country Code. Отмечу, что объекты Series из DataFrame будут иметь те же индексы, что и объект DataFrame:

>>> df['country'] Country Code KZ Kazakhstan RU Russia BY Belarus UA Ukraine Name: country, dtype: object 

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

• .loc — используется для доступа по строковой метке
• .iloc — используется для доступа по числовому значению (начиная от 0)

>>> df.loc['KZ'] country Kazakhstan population 17.04 square 2724902 Name: KZ, dtype: object >>> df.iloc[0] country Kazakhstan population 17.04 square 2724902 Name: KZ, dtype: object 

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

>>> df.loc[['KZ', 'RU'], 'population'] Country Code KZ 17.04 RU 143.50 Name: population, dtype: float64 

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

>>> df.loc['KZ':'BY', :] country population square Country Code KZ Kazakhstan 17.04 2724902 RU Russia 143.50 17125191 BY Belarus 9.50 207600 

Фильтровать DataFrame с помощью т.н. булевых массивов:

>>> df[df.population > 10][['country', 'square']] country square Country Code KZ Kazakhstan 2724902 RU Russia 17125191 UA Ukraine 603628 

Кстати, к столбцам можно обращаться, используя атрибут или нотацию словарей Python, т.е. df.population и df[‘population’] это одно и то же.

Сбросить индексы можно вот так:

>>> df.reset_index() Country Code country population square 0 KZ Kazakhstan 17.04 2724902 1 RU Russia 143.50 17125191 2 BY Belarus 9.50 207600 3 UA Ukraine 45.50 603628 

pandas при операциях над DataFrame, возвращает новый объект DataFrame.

Добавим новый столбец, в котором население (в миллионах) поделим на площадь страны, получив тем самым плотность:

>>> df['density'] = df['population'] / df['square'] * 1000000 >>> df country population square density Country Code KZ Kazakhstan 17.04 2724902 6.253436 RU Russia 143.50 17125191 8.379469 BY Belarus 9.50 207600 45.761079 UA Ukraine 45.50 603628 75.377550 

Не нравится новый столбец? Не проблема, удалим его:

>>> df.drop(['density'], axis='columns') country population square Country Code KZ Kazakhstan 17.04 2724902 RU Russia 143.50 17125191 BY Belarus 9.50 207600 UA Ukraine 45.50 603628 

Особо ленивые могут просто написать del df[‘density’].

Переименовывать столбцы нужно через метод rename:

 >>> df = df.rename(columns=) >>> df country_code country population square 0 KZ Kazakhstan 17.04 2724902 1 RU Russia 143.50 17125191 2 BY Belarus 9.50 207600 3 UA Ukraine 45.50 603628 

В этом примере перед тем как переименовать столбец Country Code, убедитесь, что с него сброшен индекс, иначе не будет никакого эффекта.

Чтение и запись данных

pandas поддерживает все самые популярные форматы хранения данных: csv, excel, sql, буфер обмена, html и многое другое:

Чаще всего приходится работать с csv-файлами. Например, чтобы сохранить наш DataFrame со странами, достаточно написать:

>>> df.to_csv('filename.csv')

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

Считать данные из csv-файла и превратить в DataFrame можно функцией read_csv.

>>> df = pd.read_csv('filename.csv', sep=',') 

Аргумент sep указывает разделитесь столбцов. Существует ещё масса способов сформировать DataFrame из различных источников, но наиболее часто используют CSV, Excel и SQL. Например, с помощью функции read_sql, pandas может выполнить SQL запрос и на основе ответа от базы данных сформировать необходимый DataFrame. За более подробной информацией стоит обратиться к официальной документации.

Группировка и агрегирование в pandas

Группировка данных один из самых часто используемых методов при анализе данных. В pandas за группировку отвечает метод .groupby. Я долго думал какой пример будет наиболее наглядным, чтобы продемонстрировать группировку, решил взять стандартный набор данных (dataset), использующийся во всех курсах про анализ данных — данные о пассажирах Титаника. Скачать CSV файл можно тут.

>>> titanic_df = pd.read_csv('titanic.csv') >>> print(titanic_df.head()) PassengerID Name PClass Age \ 0 1 Allen, Miss Elisabeth Walton 1st 29.00 1 2 Allison, Miss Helen Loraine 1st 2.00 2 3 Allison, Mr Hudson Joshua Creighton 1st 30.00 3 4 Allison, Mrs Hudson JC (Bessie Waldo Daniels) 1st 25.00 4 5 Allison, Master Hudson Trevor 1st 0.92 Sex Survived SexCode 0 female 1 1 1 female 0 1 2 male 0 0 3 female 0 1 4 male 1 0 

Необходимо подсчитать, сколько женщин и мужчин выжило, а сколько нет. В этом нам поможет метод .groupby.

>>> print(titanic_df.groupby(['Sex', 'Survived'])['PassengerID'].count()) Sex Survived female 0 154 1 308 male 0 709 1 142 Name: PassengerID, dtype: int64 

А теперь проанализируем в разрезе класса кабины:

>>> print(titanic_df.groupby(['PClass', 'Survived'])['PassengerID'].count()) PClass Survived * 0 1 1st 0 129 1 193 2nd 0 160 1 119 3rd 0 573 1 138 Name: PassengerID, dtype: int64 

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

Термин «сводная таблица» хорошо известен тем, кто не по наслышке знаком с инструментом Microsoft Excel или любым иным, предназначенным для обработки и анализа данных. В pandas сводные таблицы строятся через метод .pivot_table. За основу возьмём всё тот же пример с Титаником. Например, перед нами стоит задача посчитать сколько всего женщин и мужчин было в конкретном классе корабля:

>>> titanic_df = pd.read_csv('titanic.csv') >>> pvt = titanic_df.pivot_table(index=['Sex'], columns=['PClass'], values='Name', aggfunc='count') 

В качестве индекса теперь у нас будет пол человека, колонками станут значения из PClass, функцией агрегирования будет count (подсчёт количества записей) по колонке Name.

>>> print(pvt.loc['female', ['1st', '2nd', '3rd']]) PClass 1st 143.0 2nd 107.0 3rd 212.0 Name: female, dtype: float64 

Всё очень просто.

Анализ временных рядов

В pandas очень удобно анализировать временные ряды. В качестве показательного примера я буду использовать цену на акции корпорации Apple за 5 лет по дням. Файл с данными можно скачать тут.

>>> import pandas as pd >>> df = pd.read_csv('apple.csv', index_col='Date', parse_dates=True) >>> df = df.sort_index() >>> print(df.info()) DatetimeIndex: 1258 entries, 2017-02-22 to 2012-02-23 Data columns (total 6 columns): Open 1258 non-null float64 High 1258 non-null float64 Low 1258 non-null float64 Close 1258 non-null float64 Volume 1258 non-null int64 Adj Close 1258 non-null float64 dtypes: float64(5), int64(1) memory usage: 68.8 KB 

Здесь мы формируем DataFrame с DatetimeIndex по колонке Date и сортируем новый индекс в правильном порядке для работы с выборками. Если колонка имеет формат даты и времени отличный от ISO8601, то для правильного перевода строки в нужный тип, можно использовать метод pandas.to_datetime.

Давайте теперь узнаем среднюю цену акции (mean) на закрытии (Close):

>>> df.loc['2012-Feb', 'Close'].mean() 528.4820021999999 

А если взять промежуток с февраля 2012 по февраль 2015 и посчитать среднее:

>>> df.loc['2012-Feb':'2015-Feb', 'Close'].mean() 430.43968317018414 

А что если нам нужно узнать среднюю цену закрытия по неделям?!

>>> df.resample('W')['Close'].mean() Date 2012-02-26 519.399979 2012-03-04 538.652008 2012-03-11 536.254004 2012-03-18 576.161993 2012-03-25 600.990001 2012-04-01 609.698003 2012-04-08 626.484993 2012-04-15 623.773999 2012-04-22 591.718002 2012-04-29 590.536005 2012-05-06 579.831995 2012-05-13 568.814001 2012-05-20 543.593996 2012-05-27 563.283995 2012-06-03 572.539994 2012-06-10 570.124002 2012-06-17 573.029991 2012-06-24 583.739993 2012-07-01 574.070004 2012-07-08 601.937489 2012-07-15 606.080008 2012-07-22 607.746011 2012-07-29 587.951999 2012-08-05 607.217999 2012-08-12 621.150003 2012-08-19 635.394003 2012-08-26 663.185999 2012-09-02 670.611995 2012-09-09 675.477503 2012-09-16 673.476007 . 2016-08-07 105.934003 2016-08-14 108.258000 2016-08-21 109.304001 2016-08-28 107.980000 2016-09-04 106.676001 2016-09-11 106.177498 2016-09-18 111.129999 2016-09-25 113.606001 2016-10-02 113.029999 2016-10-09 113.303999 2016-10-16 116.860000 2016-10-23 117.160001 2016-10-30 115.938000 2016-11-06 111.057999 2016-11-13 109.714000 2016-11-20 108.563999 2016-11-27 111.637503 2016-12-04 110.587999 2016-12-11 111.231999 2016-12-18 115.094002 2016-12-25 116.691998 2017-01-01 116.642502 2017-01-08 116.672501 2017-01-15 119.228000 2017-01-22 119.942499 2017-01-29 121.164000 2017-02-05 125.867999 2017-02-12 131.679996 2017-02-19 134.978000 2017-02-26 136.904999 Freq: W-SUN, Name: Close, dtype: float64 

Resampling мощный инструмент при работе с временными рядами (time series), помогающий переформировать выборку так, как удобно вам. Метод resample первым аргументом принимает строку rule. Все доступные значения можно найти в документации.

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

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

Берём цену закрытия в промежутке между 2012 и 2017.

>>> import matplotlib.pyplot as plt >>> new_sample_df = df.loc['2012-Feb':'2017-Feb', ['Close']] >>> new_sample_df.plot() >>> plt.show() 

И видим вот такую картину:

По оси X, если не задано явно, всегда будет индекс. По оси Y в нашем случае цена закрытия. Если внимательно посмотреть, то в 2014 году цена на акцию резко упала, это событие было связано с тем, что Apple проводила сплит 7 к 1. Так мало кода и уже более-менее наглядный анализ 😉

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

Полезные ссылки

• pandas cheatsheet
• Официальная документация pandas
• Почему Python
• Python Data Science Handbook

Интересные записи:

• Обзор Python 3.9
• Django Channels: работа с WebSocket и не только
• Pyenv: удобный менеджер версий python
• Руководство по работе с HTTP в Python. Библиотека requests
• Что нового появилось в Django Channels?
• Почему Python?
• Celery: начинаем правильно
• Введение в logging на Python
• Работа с MySQL в Python
• FastAPI, asyncio и multiprocessing
• Python-RQ: очередь задач на базе Redis
• Работа с PostgreSQL в Python
• Как написать Telegram бота: практическое руководство
• Разворачиваем Django приложение в production на примере Telegram бота
• Авторизация через Telegram в Django и Python
• Django, RQ и FakeRedis
• Итоги первой встречи Python программистов в Алматы
• Обзор Python 3.8
• Интеграция Trix editor в Django
• Участие в подкасте TalkPython
• Строим Data Pipeline на Python и Luigi
• Видео презентации ETL на Python
• Авторизация через Telegram в Django приложении

Аналитикам: большая шпаргалка по Pandas

Привет. Я задумывал эту заметку для студентов курса Digital Rockstar, на котором мы учим маркетологов автоматизировать свою работу с помощью программирования, но решил поделиться шпаргалкой по Pandas со всеми. Я ожидаю, что читатель умеет писать код на Python хотя бы на минимальном уровне, знает, что такое списки, словари, циклы и функции.

1. Что такое Pandas и зачем он нужен
2. Структуры данных: серии и датафреймы
3. Создаем датафреймы и загружаем в них данные
4. Исследуем загруженные данные
5. Получаем данные из датафреймов
6. Считаем производные метрики
7. Объединяем несколько датафреймов
8. Решаем задачу

Что такое Pandas и зачем он нужен

Pandas — это библиотека для работы с данными на Python. Она упрощает жизнь аналитикам: где раньше использовалось 10 строк кода теперь хватит одной.

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

> with open('file.csv') as f: . content = f.readlines() . content = [x.split(',').replace('\n','') for x in content]

В Pandas всё проще. Во-первых, не нужно думать, как будут храниться данные — они лежат в датафрейме. Во-вторых, достаточно написать одну команду:

> data = pd.read_csv('file.csv')

Pandas добавляет в Python новые структуры данных — серии и датафреймы. Расскажу, что это такое.

Структуры данных: серии и датафреймы

Серии — одномерные массивы данных. Они очень похожи на списки, но отличаются по поведению — например, операции применяются к списку целиком, а в сериях — поэлементно.

То есть, если список умножить на 2, получите тот же список, повторенный 2 раза.

> vector = [1, 2, 3] > vector * 2 [1, 2, 3, 1, 2, 3]

А если умножить серию, ее длина не изменится, а вот элементы удвоятся.

> import pandas as pd > series = pd.Series([1, 2, 3]) > series * 2 0 2 1 4 2 6 dtype: int64

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

> series = pd.Series(['foo', 'bar']) > series[0] 'foo'

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

> months = ['jan', 'feb', 'mar', 'apr'] > sales = [100, 200, 300, 400] > data = pd.Series(data=sales, index=months) > data jan 100 feb 200 mar 300 apr 400 dtype: int64

Теперь можем получать значения каждого месяца:

> data['feb'] 200

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

Датафреймы — это таблицы. У их есть строки, колонки и ячейки.

Технически, колонки датафреймов — это серии. Поскольку в колонках обычно описывают одни и те же объекты, то все колонки делят один и тот же индекс:

> months = ['jan', 'feb', 'mar', 'apr'] > sales = < . 'revenue': [100, 200, 300, 400], . 'items_sold': [23, 43, 55, 65], . 'new_clients': [10, 20, 30, 40] . >> sales_df = pd.DataFrame(data=sales, index=months) > sales_df revenue items_sold new_clients jan 100 23 10 feb 200 43 20 mar 300 55 30 apr 400 65 40

Объясню, как создавать датафреймы и загружать в них данные.

Создаем датафреймы и загружаем данные

Бывает, что мы не знаем, что собой представляют данные, и не можем задать структуру заранее. Тогда удобно создать пустой датафрейм и позже наполнить его данными.

> df = pd.DataFrame()

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

> df = pd.DataFrame(data=sales, index=months))

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

> goods_sold = [ . , . , . . ]

Если загрузить данные в датафрейм, Pandas создаст колонки для всех товарных категорий и, где это возможно, заполнит их данными:

> pd.DataFrame(goods_sold) bicycles cars computers soft 0 NaN 1.0 10 3 1 1.0 NaN 4 5 2 NaN 2.0 6 3

Обратите внимание, продажи велосипедов в первом и третьем месяце равны NaN — расшифровывается как Not a Number. Так Pandas помечает отсутствующие значения.

Теперь разберем, как загружать данные из файлов. Чаще всего данные хранятся в экселевских таблицах или csv-, tsv- файлах.

Экселевские таблицы читаются с помощью команды pd.read_excel() . Параметрами нужно передать адрес файла на компьютере и название листа, который нужно прочитать. Команда работает как с xls, так и с xlsx:

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

Файлы формата csv и tsv — это текстовые файлы, в которых данные отделены друг от друга запятыми или табуляцией:

# CSV month,customers,sales feb,10,200 # TSV month\tcustomers\tsales feb\t10\t200

Оба читаются с помощью команды .read_csv() , символ табуляции передается параметром sep (от англ. separator — разделитель):

> pd.read_csv('file.csv') > pd.read_csv('file.tsv', sep='\t')

При загрузке можно назначить столбец, который будет индексом. Представьте, что мы загружаем таблицу с заказами. У каждого заказа есть свой уникальный номер, Если назначим этот номер индексом, сможем выгружать данные командой df[order_id] . Иначе придется писать фильтр df[df[‘id’] == order_id ] .

О том, как получать данные из датафреймов, я расскажу в одном из следующих разделов. Чтобы назначить колонку индексом, добавим в команду read_csv() параметр index_col , равный названию нужной колонки:

> pd.read_csv('file.csv', index_col='id')

После загрузки данных в датафрейм, хорошо бы их исследовать — особенно, если они вам незнакомы.

Исследуем загруженные данные

Представим, что мы анализируем продажи американского интернет-магазина. У нас есть данные о заказах и клиентах. Загрузим файл с продажами интернет-магазина в переменную orders . Раз загружаем заказы, укажем, что колонка id пойдет в индекс:

> orders = pd.read_csv('orders.csv', index_col='id')

Расскажу о четырех атрибутах, которые есть у любого датафрейма: .shape , .columns , .index и .dtypes .

.shape показывает, сколько в датафрейме строк и колонок. Он возвращает пару значений (n_rows, n_columns) . Сначала идут строки, потом колонки.

> orders.shape (5009, 5)

В датафрейме 5009 строк и 5 колонок.

Окей, масштаб оценили. Теперь посмотрим, какая информация содержится в каждой колонке. С помощью .columns узнаем названия колонок:

> orders.columns Index(['order_date', 'ship_mode', 'customer_id', 'sales'], dtype='object')

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

С помощью .dtypes узнаем типы данных, находящихся в каждой колонке и поймем, надо ли их обрабатывать. Бывает, что числа загружаются в виде текста. Если мы попробуем сложить две текстовых значения ‘1’ + ‘1’ , то получим не число 2, а строку ’11’ :

> orders.dtypes order_date object ship_mode object customer_id object sales float64 dtype: object

Тип object — это текст, float64 — это дробное число типа 3,14.

C помощью атрибута .index посмотрим, как называются строки:

> orders.index Int64Index([100006, 100090, 100293, 100328, 100363, 100391, 100678, 100706, 100762, 100860, . 167570, 167920, 168116, 168613, 168690, 168802, 169320, 169488, 169502, 169551], dtype='int64', name='id', length=5009)

Ожидаемо, в индексе датафрейма номера заказов: 100762, 100860 и так далее.

В колонке sales хранится стоимость каждого проданного товара. Чтобы узнать разброс значений, среднюю стоимость и медиану, используем метод .describe() :

> orders.describe() sales count 5009.0 mean 458.6 std 954.7 min 0.6 25% 37.6 50% 152.0 75% 512.1 max 23661.2

Наконец, чтобы посмотреть на несколько примеров записей датафрейма, используем команды .head() и .sample() . Первая возвращает 6 записей из начала датафрейма. Вторая — 6 случайных записей:

> orders.head() order_date ship_mode customer_id sales id 100006 2014-09-07 Standard DK-13375 377.970 100090 2014-07-08 Standard EB-13705 699.192 100293 2014-03-14 Standard NF-18475 91.056 100328 2014-01-28 Standard JC-15340 3.928 100363 2014-04-08 Standard JM-15655 21.376

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

Получаем данные из датафреймов

Данные из датафреймов можно получать по-разному: указав номера колонок и строк, использовав условные операторы или язык запросов. Расскажу подробнее о каждом способе.

Указываем нужные строки и колонки

Продолжаем анализировать продажи интернет-магазина, которые загрузили в предыдущем разделе. Допустим, я хочу вывести столбец sales . Для этого название столбца нужно заключить в квадратные скобки и поставить после них названия датафрейма: orders[‘sales’] :

> orders['sales'] id 100006 377.970 100090 699.192 100293 91.056 100328 3.928 100363 21.376 100391 14.620 100678 697.074 100706 129.440 . 

Обратите внимание, результат команды — новый датафрейм с таким же индексом.

Если нужно вывести несколько столбцов, в квадратные скобки нужно вставить список с их названиями: orders[[‘customer_id’, ‘sales’]] . Будьте внимательны: квадратные скобки стали двойными. Первые — от датафрейма, вторые — от списка:

> orders[['customer_id', 'sales']] customer_id sales id 100006 DK-13375 377.970 100090 EB-13705 699.192 100293 NF-18475 91.056 100328 JC-15340 3.928 100363 JM-15655 21.376 100391 BW-11065 14.620 100363 KM-16720 697.074 100706 LE-16810 129.440 . 

Перейдем к строкам. Их можно фильтровать по индексу и по порядку. Например, мы хотим вывести только заказы 100363, 100391 и 100706, для этого есть команда .loc[] :

> show_these_orders = ['100363', '100363', '100706'] > orders.loc[show_these_orders] order_date ship_mode customer_id sales id 100363 2014-04-08 Standard JM-15655 21.376 100363 2014-04-08 Standard JM-15655 21.376 100706 2014-12-16 Second LE-16810 129.440

А в другой раз бывает нужно достать просто заказы с 1 по 3 по порядку, вне зависимости от их номеров в таблицемы. Тогда используют команду .iloc[] :

> show_these_orders = [1, 2, 3] > orders.iloc[show_these_orders] order_date ship_mode customer_id sales id 100090 2014-04-08 Standard JM-15655 21.376 100293 2014-04-08 Standard JM-15655 21.376 100328 2014-12-16 Second LE-16810 129.440

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

> columns = ['customer_id', 'sales'] > rows = ['100363', '100363', '100706'] > orders.loc[rows][columns] customer_id sales id 100363 JM-15655 21.376 100363 JM-15655 21.376 100706 LE-16810 129.440 . 

Часто вы не знаете заранее номеров заказов, которые вам нужны. Например, если задача — получить заказы, стоимостью более 1000 рублей. Эту задачу удобно решать с помощью условных операторов.

Если — то. Условные операторы

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

> filter_large = orders['sales'] > 1000 > orders.loc[filter_slarge] order_date ship_mode customer_id sales id 101931 2014-10-28 First TS-21370 1252.602 102673 2014-11-01 Standard KH-16630 1044.440 102988 2014-04-05 Second GM-14695 4251.920 103100 2014-12-20 First AB-10105 1107.660 103310 2014-05-10 Standard GM-14680 1769.784 . 

Помните, в начале статьи я упоминал, что в сериях все операции применяются по-элементно? Так вот, операция orders[‘sales’] > 1000 идет по каждому элементу серии и, если условие выполняется, возвращает True . Если не выполняется — False . Получившуюся серию мы сохраняем в переменную filter_large .

Вторая команда фильтрует строки датафрейма с помощью серии. Если элемент filter_large равен True , заказ отобразится, если False — нет. Результат — датафрейм с заказами, стоимостью более 1000 долларов.

Интересно, сколько дорогих заказов было доставлено первым классом? Добавим в фильтр ещё одно условие:

> filter_large = df['sales'] > 1000 > filter_first_class = orders['ship_mode'] == 'First' > orders.loc[filter_large & filter_first_class] order_date ship_mode customer_id sales id 101931 2014-10-28 First TS-21370 1252.602 103100 2014-12-20 First AB-10105 1107.660 106726 2014-12-06 First RS-19765 1261.330 112158 2014-12-02 First DP-13165 1050.600 116666 2014-05-08 First KT-16480 1799.970 . 

Логика не изменилась. В переменную filter_large сохранили серию, удовлетворяющую условию orders[‘sales’] > 1000 . В filter_first_class — серию, удовлетворяющую orders[‘ship_mode’] == ‘First’ .

Затем объединили обе серии с помощью логического ‘И’: filter_first_class & filter_first_class . Получили новую серию той же длины, в элементах которой True только у заказов, стоимостью больше 1000, доставленных первым классом. Таких условий может быть сколько угодно.

Язык запросов

Еще один способ решить предыдущую задачу — использовать язык запросов. Все условия пишем одной строкой ‘sales > 1000 & ship_mode == ‘First’ и передаем ее в метод .query() . Запрос получается компактнее.

> orders.query('sales > 1000 & ship_mode == First') order_date ship_mode customer_id sales id 101931 2014-10-28 First TS-21370 1252.602 103100 2014-12-20 First AB-10105 1107.660 106726 2014-12-06 First RS-19765 1261.330 112158 2014-12-02 First DP-13165 1050.600 116666 2014-05-08 First KT-16480 1799.970 . 

Отдельный кайф: значения для фильтров можно сохранить в переменной, а в запросе сослаться на нее с помощью символа @: sales > @sales_filter .

> sales_filter = 1000 > ship_mode_filter = 'First' > orders.query('sales > @sales_filter & ship_mode > @ship_mode_filter') order_date ship_mode customer_id sales id 101931 2014-10-28 First TS-21370 1252.602 103100 2014-12-20 First AB-10105 1107.660 106726 2014-12-06 First RS-19765 1261.330 112158 2014-12-02 First DP-13165 1050.600 116666 2014-05-08 First KT-16480 1799.970 . 

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

Считаем производные метрики

Задача: посчитаем, сколько денег магазин заработал с помощью каждого класса доставки. Начнем с простого — просуммируем выручку со всех заказов. Для этого используем метод .sum() :

> orders['sales'].sum() 2297200.8603000003

Добавим класс доставки. Перед суммированием сгруппируем данные с помощью метода .groupby() :

> orders.groupby('ship_mode')['sales'].sum() ship_mode First 3.514284e+05 Same Day 1.283631e+05 Second 4.591936e+05 Standard 1.358216e+06

3.514284e+05 — научный формат вывода чисел. Означает 3.51 * 10 5 . Нам такая точность не нужна, поэтому можем сказать Pandas, чтобы округлял значения до сотых:

> pd.options.display.float_format = ''.format > orders.groupby('ship_mode')['sales'].sum() ship_mode First 351,428.4 Same Day 128,363.1 Second 459,193.6 Standard 1,358,215.7

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

> orders.groupby(['ship_mode', 'order_date'])['sales'].sum() ship_mode order_date First 2014-01-06 12.8 2014-01-11 9.9 2014-01-14 62.0 2014-01-15 149.9 2014-01-19 378.6 2014-01-26 152.6 . 

Видно, что выручка прыгает ото дня ко дню: иногда 10 долларов, а иногда 378. Интересно, это меняется количество заказов или средний чек? Добавим к выборке количество заказов. Для этого вместо .sum() используем метод .agg() , в который передадим список с названиями нужных функций.

> orders.groupby(['ship_mode', 'order_date'])['sales'].agg(['sum', 'count']) sum count ship_mode order_date First 2014-01-06 12.8 1 2014-01-11 9.9 1 2014-01-14 62.0 1 2014-01-15 149.9 1 2014-01-19 378.6 1 2014-01-26 152.6 1 . 

Ого, получается, что это так прыгает средний чек. Интересно, а какой был самый удачный день? Чтобы узнать, отсортируем получившийся датафрейм: выведем 10 самых денежных дней по выручке:

> orders.groupby(['ship_mode', 'order_date'])['sales'].agg(['sum']).sort_values(by='sum', ascending=False).head(10) sum ship_mode order_date Standard 2014-03-18 26,908.4 2016-10-02 18,398.2 First 2017-03-23 14,299.1 Standard 2014-09-08 14,060.4 First 2017-10-22 13,716.5 Standard 2016-12-17 12,185.1 2017-11-17 12,112.5 2015-09-17 11,467.6 2016-05-23 10,561.0 2014-09-23 10,478.6 

Команда разрослась, и её теперь неудобно читать. Чтобы упростить, можно разбить её на несколько строк. В конце каждой строки ставим обратный слеш \ :

> orders \ . .groupby(['ship_mode', 'order_date'])['sales'] \ . .agg(['sum']) \ . .sort_values(by='sum', ascending=False) \ . .head(10) sum ship_mode order_date Standard 2014-03-18 26,908.4 2016-10-02 18,398.2 First 2017-03-23 14,299.1 Standard 2014-09-08 14,060.4 First 2017-10-22 13,716.5 Standard 2016-12-17 12,185.1 2017-11-17 12,112.5 2015-09-17 11,467.6 2016-05-23 10,561.0 2014-09-23 10,478.6 

В самый удачный день — 18 марта 2014 года — магазин заработал 27 тысяч долларов с помощью стандартного класса доставки. Интересно, откуда были клиенты, сделавшие эти заказы? Чтобы узнать, надо объединить данные о заказах с данными о клиентах.

Объединяем несколько датафреймов

До сих пор мы смотрели только на таблицу с заказами. Но ведь у нас есть еще данные о клиентах интернет-магазина. Загрузим их в переменную customers и посмотрим, что они собой представляют:

> customers = pd.read_csv('customers.csv', index='id') > customers.head() name segment state city id CG-12520 Claire Gute Consumer Kentucky Henderson DV-13045 Darrin Van Huff Corporate California Los Angeles SO-20335 Sean O'Donnell Consumer Florida Fort Lauderdale BH-11710 Brosina Hoffman Consumer California Los Angeles AA-10480 Andrew Allen Consumer North Carolina Concord

Мы знаем тип клиента, место его проживания, его имя и имя контактного лица. У каждого клиента есть уникальный номер id . Этот же номер лежит в колонке customer_id таблицы orders . Значит мы можем найти, какие заказы сделал каждый клиент. Например, посмотрим, заказы пользователя CG-12520 :

> cust_filter = 'CG-12520' > orders.query('customer_id == @cust_filter') order_date ship_mode customer_id sales id CA-2016-152156 2016-11-08 Second CG-12520 993.90 CA-2017-164098 2017-01-26 First CG-12520 18.16 US-2015-123918 2015-10-15 Same Day CG-12520 136.72

Вернемся к задаче из предыдущего раздела: узнать, что за клиенты, которые сделали 18 марта заказы со стандартной доставкой. Для этого объединим таблицы с клиентами и заказами. Датафреймы объединяют с помощью методов .concat() , .merge() и .join() . Все они делают одно и то же, но отличаются синтаксисом — на практике достаточно уметь пользоваться одним из них.

Покажу на примере .merge() :

> new_df = pd.merge(orders, customers, how='inner', left_on='customer_id', right_index=True) > new_df.columns Index(['order_date', 'ship_mode', 'customer_id', 'sales', 'name', 'segment', 'state', 'city'], dtype='object')

В .merge() я сначала указал названия датафреймов, которые хочу объединить. Затем уточнил, как именно их объединить и какие колонки использовать в качестве ключа.

Ключ — это колонка, связывающая оба датафрейма. В нашем случае — номер клиента. В таблице с заказами он в колонке customer_id , а таблице с клиентами — в индексе. Поэтому в команде мы пишем: left_on=’customer_id’, right_index=True .

Решаем задачу

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

Для начала отфильтруем заказы из 2016 года:

> orders_2016 = orders.query("order_date >= '2016-01-01' & order_date orders_2016.head() order_date ship_mode customer_id sales id 100041 2016-11-20 Standard BF-10975 328.5 100083 2016-11-24 Standard CD-11980 24.8 100153 2016-12-13 Standard KH-16630 63.9 100244 2016-09-20 Standard GM-14695 475.7 100300 2016-06-24 Second MJ-17740 4,823.1

Город — это атрибут пользователей, а не заказов. Добавим информацию о пользователях:

> with_customers_2016 = pd.merge(customers, orders_2016, how='inner', left_index=True, right_on='customer_id')

Cруппируем получившийся датафрейм по городам и посчитаем выручку:

> grouped_2016 = with_customers_2016.groupby('city')['sales'].sum() > grouped_2016.head() city Akron 1,763.0 Albuquerque 692.9 Amarillo 197.2 Arlington 5,672.1 Arlington Heights 14.1 Name: sales, dtype: float64

Отсортируем по убыванию продаж и оставим топ-5:

> top5 = grouped_2016.sort_values(ascending=False).head(5) > print(top5) city New York City 53,094.1 Philadelphia 39,895.5 Seattle 33,955.5 Los Angeles 33,611.1 San Francisco 27,990.0 Name: sales, dtype: float64

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

1. Сколько заказов, отправлено первым классом за последние 5 лет?
2. Сколько в базе клиентов из Калифорнии?
3. Сколько заказов они сделали?
4. Постройте сводную таблицу средних чеков по всем штатам за каждый год.

Через некоторое время выложу ответы в Телеграме. Подписывайтесь, чтобы не пропустить ответы и новые статьи.

Кстати, большое спасибо Александру Марфицину за то, что помог отредактировать статью.

Pandas

Pandas — это библиотека Python для обработки и анализа структурированных данных, её название происходит от «panel data» («панельные данные»). Панельными данными называют информацию, полученную в результате исследований и структурированную в виде таблиц. Для работы с такими массивами данных и создан Pandas.

Освойте профессию «Аналитик данных»

Работа с открытым кодом

Pandas — это opensource-библиотека, то есть ее исходный код в открытом доступе размещен на GitHub. Пользователи могут добавлять туда свой код: вносить пояснения, дополнять методы работы и обновлять разделы. Для работы потребуется компилятор (программа, которая переводит текст с языка программирования в машинный код) C/C++ и среда разработки Python. Подробный процесс установки компилятора С для разных операционных систем можно найти в документации Pandas.

Профессия / 12 месяцев
Аналитик данных

Находите закономерности и делайте выводы, которые помогут бизнесу

В каких профессиях понадобится библиотека?

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

Как установить Pandas

Пошаговая инструкция по установке библиотеки Pandas

Скачать библиотеку На официальном сайте Pandas указан самый простой способ начать работу с библиотекой. Для этого потребуется установить Anaconda — дистрибутив (форма распространения программного обеспечения, набор библиотек или программного кода для установки программы) для Python с набором библиотек. Безопасно скачать его можно на официальном сайте.

Настройка установки Вот несколько советов по установке Anaconda для новичков:

— Выбирайте рекомендованные настройки, на первое время этого будет достаточно. Например, Install for: Just me (recommended).

— Но если не поставить галочку «Add Anaconda to my PATH environment variable», то Anaconda не будет запускаться по умолчанию, каждый раз ее нужно будет запускать отдельно.

— На вопрос: «Do you wish to initialize Anaconda3?» (Хотите ли вы инициализировать Anaconda3?) отвечайте «Да».

— После завершения установки перезагрузите компьютер.

Запуск JupyterLab В командной строке Anaconda запустите JupyterLab — это интерактивная среда для работы с кодом, данными и блокнотами, которая входит в пакет дистрибутива. Для этого введите jupyter-lab .

Открытие блокнота Создайте в JupyterLab новый блокнот Python3. Для его создания надо щелкнуть на значке «+», расположенном в верхней левой части интерфейса. В появившемся меню выбрать «Python 3» для создания блокнота.

Импорт библиотеки В первой ячейке пропишите: import pandas as pd , после этого в следующих ячейках можно писать код.

Читайте также Как выбрать IT-специальность в новых реалиях?

DataFrame и Series

Чтобы анализировать данные с помощью Pandas, нужно понять, как устроены структуры этих данных внутри библиотеки. В первую очередь разберем, что такое DataFrame и Series.

Series

Pandas Series (серия) — это одномерный массив. Визуально он похож на пронумерованный список: слева в колонке находятся индексы элементов, а справа — сами элементы.

my_series = pd.Series([5, 6, 7, 8, 9, 10])

Индексом может быть числовой показатель (0, 1, 2…), буквенные значения (a, b, c…) или другие данные, выбранные программистом. Если особое значение не задано, то числовые индексы проставляются автоматически. Например, от 0 до 5 как в примере выше.

Такая нумерация называется RangeIndex, в ней всегда содержатся числа от 0 до определенного числа N, которое обозначает количество элементов в серии. Собственные значения индексов задаются в квадратных скобках через index, как в примере ниже:

my_series2 = pd.Series([5, 6, 7, 8, 9, 10]), index=['a', 'b', 'c', 'd', 'e', 'f'])

Индексы помогают обращаться к элементам серии и менять их значения. Например, чтобы в нашей серии [5, 6, 7, 8, 9, 10] заменить значения некоторых элементов на 0, мы прописываем индексы нужных элементов и указываем, что они равны нулю:

my_series2[['a', 'b', 'f']] = 0

Можно сделать выборку по нескольким индексам, чтобы ненужные элементы в серии не отображались:

my_series2[['a', 'b', 'f']]

a 5 b 6 f 10 dtype: int64

DataFrame

Pandas DataFrame — это двумерный массив, похожий на таблицу/лист Excel (кстати, данные из Excel можно читать с помощью команды pandas.read_excel(‘file.xls’)) . В нем можно проводить такие же манипуляции с данными: объединять в группы, сортировать по определенному признаку, производить вычисления. Как любая таблица, датафрейм состоит из столбцов и строк, причем столбцами будут уже известные объекты — Series.

Чтобы проверить, действительно ли серии — это части датафрейма, можно извлечь любую колонку из таблицы. Возьмем набор данных о нескольких странах СНГ, их площади и населении и выберем колонку country:

df = pd.DataFrame(< 'country': ['Kazakhstan', 'Russia', 'Belarus', 'Ukraine'], 'population': [17.04, 143.5, 9.5, 45.5], 'square': [2724902, 17125191, 207600, 603628] >)

В итоге получится простая серия, в которой сохранятся те же индексы по строкам, что и в исходном датафрейме:

df['country']

type(df['country'])

Станьте аналитиком данных и получите востребованную специальность

Кроме этого, у датафрейма есть индексы по столбцам, которые задаются вручную. Для простоты написания кода обозначим страны индексами из двух символов: Kazakhstan — KZ, Russia — RU и так далее:

# Создаем датафрейм с заданными индексами df = pd.DataFrame(< 'country': ['Kazakhstan', 'Russia', 'Belarus', 'Ukraine'], 'population': [17.04, 143.5, 9.5, 45.5], 'square': [2724902, 17125191, 207600, 603628] >, index=['KZ', 'RU', 'BY', 'UA'])

# Изменяем индексы df.index = ['KZ', 'RU', 'BY', 'UA'] df.index.name = 'Country Code'

По индексам можно искать объекты и делать выборку, как в Series . Возьмем тот же датафрейм и сделаем выборку по индексам KZ, RU и колонке population методом .loc (в случае .loc мы используем квадратные скобки, а не круглые, как с другими методами), чтобы сравнить население двух стран:

df.loc[['KZ', 'RU'], 'population']

Anaconda выведет следующее:

Country Code
KZ 17.04
RU 143.50
Name: population, dtype: float64

Также в DataFrame производят математические вычисления. Например, рассчитаем плотность населения каждой страны в нашем датафрейме. Данные в колонке population (численность населения) делим на square (площадь) и получаем новые данные в колонке density, которые показывают плотность населения:

# Вычисление плотности населения df['density'] = df['population'] / df['square'] * 1000000

Станьте аналитиком данных и получите востребованную специальность

Чтение и запись данных

В Pandas работают с форматами csv, excel, sql, html, hdf и другими. Полный список можно посмотреть с помощью метода .read, где через нижнее подчеркивание «_» будут указаны все доступные форматы.

Ниже представлены примеры чтения и записи данных на Python с использованием Pandas:

Чтение данных:

1. Чтение данных из CSV файла:

import pandas as pd # Чтение CSV файла data = pd.read_csv('data.csv') # Вывод первых нескольких строк датафрейма print(data.head())

1. Чтение данных из Excel файла:

# Чтение данных из Excel файла data = pd.read_excel('data.xlsx') # Вывод первых нескольких строк датафрейма print(data.head())

1. Чтение данных из SQL базы данных:

from sqlalchemy import create_engine # Создание подключения к базе данных engine = create_engine('sqlite:///database.db') # Чтение данных с помощью SQL запроса query = "SELECT * FROM table_name" data = pd.read_sql(query, engine) # Вывод первых нескольких строк датафрейма print(data.head())

Запись данных:

1. Запись данных в CSV или Exсel файл:

# Создание датафрейма data = pd.DataFrame(< 'name': ['Alice', 'Bob', 'Charlie'], 'age': [25, 30, 22] >) # Запись в CSV файл (или Exсel, нужно будет поменять расширение ниже) data.to_csv('output.csv', index=False)

1. Запись данных в SQL базу данных:

import pandas as pd from sqlalchemy import create_engine # Создание датафрейма data = pd.DataFrame(< 'name': ['Alice', 'Bob', 'Charlie'], 'age': [25, 30, 22] >) # Создание подключения к базе данных engine = create_engine('sqlite:///new_database.db') # Запись данных в базу данных data.to_sql('new_table', engine, index=False, if_exists='replace')

Доступ по индексу в DataFrame

Для поиска данных в библиотеке Pandas используются два метода: .loc и .iloc . Рассмотрим их функциональность и применение.

Метод .loc:

Метод .loc предоставляет доступ к данным по заданному имени строки (индексу) в DataFrame. Рассмотрим пример с набором данных о скорости и ядовитости нескольких видов змей:

data = index = ['cobra', 'viper', 'sidewinder'] df = pd.DataFrame(data, index=index) # Вывод датафрейма print(df)

Используя метод .loc , мы можем получить информацию о конкретном виде змеи, например, гадюке (viper):

# Получение данных о гадюке (viper) viper_data = df.loc['viper'] print(viper_data)

Метод .iloc:

Метод .iloc позволяет осуществлять доступ к данным по порядковому номеру строки в DataFrame. Рассмотрим пример с набором данных, имеющим числовые индексы:

mydict = [, , ] df = pd.DataFrame(mydict) # Вывод датафрейма print(df)

 a b c d 0 1 2 3 4 1 100 200 300 400 2 1000 2000 3000 4000 

Используя метод .iloc , можно получить данные из первой строки с индексом 0:

first_row = df.iloc[0] first_row

Читайте также Что нужно знать, чтобы стать дата-сайентистом?

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

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

Используем .groupby и указываем название колонки title, на основе которой Pandas объединит все данные. После этого используем метод .agregate – он поможет провести математические вычисления, то есть суммировать стоимость внутри каждой группы.

import pandas as pd # Создание DataFrame с данными о курсах data = < 'title': ['Курс A', 'Курс B', 'Курс C', 'Курс D', 'Курс E'], 'income': [100, 150, 200, 120, 180] >df = pd.DataFrame(data) # Группировка данных по названию курса и агрегирование дохода grouped = df.groupby('title', as_index=False).aggregate() grouped

Обратите внимание на as_index=False , эта часть кода отвечает за то, чтобы сохранить числовые индексы в результатах группировки и вычисления.

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

Их используют для обобщения информации, собранной об объекте исследования. Когда исходных данных много и все они разного типа, составление таблиц помогает упорядочить информацию. Чтобы создавать на Python сводные таблицы, тоже используют библиотеку Pandas, а именно — метод .pivot_table .

Для примера возьмем условный набор данных с простыми категориями one / two, small / large и числовыми значениями. В столбце A две категории foo / bar складываются в слово foobar — текст, который используется в программировании для условного обозначения. В этом случае он указывает, что мы делим данные на две группы по неопределенному признаку.

df = pd.DataFrame() df

Результат выполнения кода:

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

table = pd.pivot_table(df, values='D', index=['A', 'B'], columns=['C'], aggfunc=np.sum) table

Мы разбиваем данные на две категории: bar и foo, в каждой из них будут подгруппы со значениями one и two, которые в свою очередь делятся на small и large. В сводной таблице мы вычисляем, сколько объектов будет в каждой группе. Для этого используем методы values, index, columns и aggfunc:

• values — метод для агрегации, объединяет элементы в одну систему;
• index и columns — методы, отвечающие за группировку столбцов;
• aggfunc — метод, который передает список функций, необходимых для расчета.

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

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

Посмотрим на данные о продажах в одной из компаний:

Число покупок на одного покупателя	Количество покупателей
7000	4
3755	6
2523	13
541	16
251	21
1	31

В таблице видно, что одни пользователи совершили уже более 7 000 покупок, а некоторые — сделали первую. Чтобы увидеть подробную картину, составляем график sns.distplot. На горизонтальной оси будет отображаться число покупок на одного покупателя, а на вертикальной — количество покупателей, которые совершили именно столько покупок в этой компании. Так по графику можно определить, что самой многочисленной оказалась группа клиентов, которая совершила всего несколько покупок, а группа постоянных клиентов немногочисленная.

import seaborn as sns import matplotlib.pyplot as plt # Создание данных purchase_counts = [7000, 3755, 2523, 541, 251, 1] customer_counts = [4, 6, 13, 16, 21, 31] # Создание графика sns.set(style="whitegrid") sns.distplot(purchase_counts, bins=20, kde=False, hist_kws=) plt.xlabel('Число покупок на одного покупателя') plt.ylabel('Количество покупателей') plt.title('Распределение числа покупок') plt.show()

distplot — это график, который визуализирует гистограммы, то есть распределяет данные по столбцам. Каждому столбцу соответствует доля количества объектов в данной группе. Также distplot показывает плотность распределения — плавный линейный график, в котором самая высокая точка указывает на наибольшее количество объектов.

Кроме этого, в Pandas есть другие виды графиков:

• kdeplot — график плотности распределения, который останется, если убрать гистограммы из distplot;
• jointplot — график, показывающий распределение данных между двумя переменными. Каждая строка из набора данных в исходном файле отображается на графике как точка внутри системы координат. У точек на графике jointplot будет два заданных значения: одно по оси X, другое по оси Y.

Например, можно отследить взаимосвязь между тем, сколько минут посетитель проводит в торговом центре и сколько магазинов успевает посетить за это время: кто-то за 30 минут успеет зайти в 5 бутиков, а кто-то обойдет 16. При этом каждый посетитель на графике будет отображаться отдельной точкой.

Аналитик данных

Аналитики влияют на рост бизнеса. Они выясняют, какой товар и в какое время больше покупают. Считают юнит-экономику. Оценивают окупаемость рекламной кампании. Поэтому компании ищут и переманивают таких специалистов.

Статьи по теме:

Библиотека Pandas для работы с данными

Pandas — программная библиотека на языке Python для обработки и анализа данных. Работа pandas с данными строится поверх библиотеки NumPy, являющейся инструментом более низкого уровня. Предоставляет специальные структуры данных и операции для манипулирования числовыми таблицами и временны́ми рядами.

Главный элемент пандаса — DataFrame (датафрейм, df), с которым можно производить необходимые преобразования. df — “таблица”, состоящая из строк и столбцов. По умолчанию, строчки таблицы — это объекты, а столбцы — признаки (фичи) объектов.

import pandas as pd import numpy as np 

Создание DataFrame

d = 'feature1': [4,3,2,1,0], 'feature2': ['x', 'z', 'y', 'x', 'z'], 'feature3': [2,3,4,1,0]> df = pd.DataFrame(d) df 

feature1	feature2	feature3
0	4	x	2
1	3	z	3
2	2	y	4
3	1	x	1
4	0	z	0

data = [['tom', 10], ['nick', 15], ['juli', 14]] df = pd.DataFrame(data, columns = ['Name', 'Age']) df 

Name	Age
0	tom	10
1	nick	15
2	juli	14

data = 'Name':['Tom', 'Jack', 'nick', 'juli'], 'marks':[99, 98, 95, 90]> df = pd.DataFrame(data, index =['rank1', 'rank2', 'rank3', 'rank4']) df 

Name	marks
rank1	Tom	99
rank2	Jack	98
rank3	nick	95
rank4	juli	90

data = ['a': 1, 'b': 2, 'c':3>, 'a':10, 'b': 20>] df = pd.DataFrame(data) df 

a	b	c
0	1	2	3.0
1	10	20	NaN

d = 'one' : pd.Series([10, 20, 30, 40], index =['a', 'b', 'c', 'd']), 'two' : pd.Series([10, 20, 30, 40], index =['a', 'b', 'c', 'd'])> df = pd.DataFrame(d) df 

one	two
a	10	10
b	20	20
c	30	30
d	40	40

Первичный анализ данных с Pandas

Pandas — это библиотека Python, предоставляющая широкие возможности для анализа данных. С ее помощью очень удобно загружать, обрабатывать и анализировать табличные данные с помощью SQL-подобных запросов. В связке с библиотеками Matplotlib и Seaborn появляется возможность удобного визуального анализа табличных данных.

Данные, с которыми работают датсаентисты и аналитики, обычно хранятся в виде табличек — например, в форматах .csv, .tsv или .xlsx. Для того, чтобы считать нужные данные из такого файла, отлично подходит библиотека Pandas.

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

pd.read_csv('beauty.csv', nrows=2) 

wage;exper;union;goodhlth;black;female;married;service;educ;looks
0	5.73;30;0;1;0;1;1;1;14;4
1	4.28;28;0;1;0;1;1;0;12;3

#help(pd.read_csv) path_to_file = 'beauty.csv' data = pd.read_csv(path_to_file, sep=';') print(data.shape) #df.tail() data.head() 

(1260, 10)

wage	exper	union	goodhlth	black	female	married	service	educ	looks
0	5.73	30	0	1	0	1	1	1	14	4
1	4.28	28	0	1	0	1	1	0	12	3
2	7.96	35	0	1	0	1	0	0	10	4
3	11.57	38	0	1	0	0	1	1	16	3
4	11.42	27	0	1	0	0	1	0	16	3

Мы считали данные по модельному бизнесу 80-90е года в США

type(data) 

pandas.core.frame.DataFrame

#data.shape len(data) 

1260

Чтобы посмотреть общую информацию по датафрейму и всем признакам, воспользуемся методом info:

data.info() 

 RangeIndex: 1260 entries, 0 to 1259 Data columns (total 10 columns): wage 1260 non-null float64 exper 1260 non-null int64 union 1260 non-null int64 goodhlth 1260 non-null int64 black 1260 non-null int64 female 1260 non-null int64 married 1260 non-null int64 service 1260 non-null int64 educ 1260 non-null int64 looks 1260 non-null int64 dtypes: float64(1), int64(9) memory usage: 98.6 KB

int64 и float64 — это типы признаков. Видим, что 1 признак — float64 и 9 признаков имеют тип int64.

Метод describe показывает основные статистические характеристики данных по каждому числовому признаку (типы int64 и float64): число непропущенных значений, среднее, стандартное отклонение, диапазон, медиану, 0.25 и 0.75 квартили.

data.describe() 

wage	exper	union	goodhlth	black	female	married	service	educ	looks
count	1260.000000	1260.000000	1260.000000	1260.000000	1260.000000	1260.000000	1260.000000	1260.000000	1260.000000	1260.000000
mean	6.306690	18.206349	0.272222	0.933333	0.073810	0.346032	0.691270	0.273810	12.563492	3.185714
std	4.660639	11.963485	0.445280	0.249543	0.261564	0.475892	0.462153	0.446089	2.624489	0.684877
min	1.020000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	0.000000	5.000000	1.000000
25%	3.707500	8.000000	0.000000	1.000000	0.000000	0.000000	0.000000	0.000000	12.000000	3.000000
50%	5.300000	15.000000	0.000000	1.000000	0.000000	0.000000	1.000000	0.000000	12.000000	3.000000
75%	7.695000	27.000000	1.000000	1.000000	0.000000	1.000000	1.000000	1.000000	13.000000	4.000000
max	77.720000	48.000000	1.000000	1.000000	1.000000	1.000000	1.000000	1.000000	17.000000	5.000000

Посмотрим на признак “exper” — рабочий стаж

data['exper'].head() #data.exper.head() # 2-ой вариант 

0 30 1 28 2 35 3 38 4 27 Name: exper, dtype: int64

Как описывалось ранее — тип данных в колонке является Series, что по сути является проиндексированным массивом

type(data['exper']) 

pandas.core.series.Series

loc и iloc

С помощью loc и iloc — можно из начального датафрейма зафиксировать определённые интервал строк и интересующих столбцов и работать/смотреть только их

#data.loc[1:5, ['wage']] data.wage.loc[1:5] 

1 4.28 2 7.96 3 11.57 4 11.42 5 3.91 Name: wage, dtype: float64

#data.iloc[0,1] # первое число - номер столбца (начинается с 0). Второе - индекс строчки data['wage'].iloc[1:5] 

1 4.28 2 7.96 3 11.57 4 11.42 Name: wage, dtype: float64

Условия

Посмотрим на наш датафрейм, на соответствие какому-то условию

(data['exper'] >= 15) 

0 True 1 True 2 True 3 True 4 True . 1255 True 1256 False 1257 True 1258 True 1259 True Name: exper, Length: 1260, dtype: bool

Посмотрим только те строки, в датафрейме, которые удовлетворяют определённому условию, и выведем первые 5 из них

data[(data['female'] == 1) & (data['black'] == 1)].head(10) 

wage	exper	union	goodhlth	black	female	married	service	educ	looks
44	4.95	20	0	1	1	1	0	1	14	3
85	10.12	40	0	1	1	1	0	1	10	3
110	3.37	36	0	1	1	1	0	1	13	3
148	7.21	20	1	0	1	1	1	1	17	3
167	2.81	14	0	1	1	1	1	0	13	3
211	2.88	7	0	1	1	1	0	1	13	4
497	7.07	8	1	1	1	1	0	0	13	3
499	3.89	4	0	1	1	1	0	0	16	4
504	6.54	8	0	1	1	1	0	0	13	3
507	7.69	16	0	1	1	1	1	0	13	3

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

data[data['female'] == 1]['wage'].head(10) 

0 5.73 1 4.28 2 7.96 5 3.91 8 5.00 9 3.89 10 3.45 18 10.44 19 7.69 44 4.95 Name: wage, dtype: float64

data[(data['female'] == 0) & (data['married'] == 1)].head(10) 

wage	exper	union	goodhlth	black	female	married	service	educ	looks
3	11.57	38	0	1	0	0	1	1	16	3
4	11.42	27	0	1	0	0	1	0	16	3
6	8.76	12	0	1	0	0	1	0	16	3
11	4.03	6	0	1	0	0	1	0	16	4
12	5.14	19	0	1	0	0	1	1	17	2
14	7.99	12	0	1	0	0	1	0	16	4
15	6.01	17	0	1	0	0	1	0	16	4
16	5.16	7	0	1	0	0	1	0	17	3
17	11.54	12	0	1	0	0	1	1	17	4
21	6.79	19	0	1	0	0	1	1	14	3

# Метод describe для сложного условия data[(data['female'] == 0) & (data['married'] == 1)].describe() 

wage	exper	union	goodhlth	black	female	married	service	educ	looks
count	658.000000	658.000000	658.000000	658.000000	658.000000	658.0	658.0	658.000000	658.000000	658.000000
mean	7.716778	22.136778	0.308511	0.937690	0.037994	0.0	1.0	0.194529	12.495441	3.164134
std	4.798763	11.714753	0.462230	0.241902	0.191327	0.0	0.0	0.396139	2.716007	0.655469
min	1.050000	1.000000	0.000000	0.000000	0.000000	0.0	1.0	0.000000	5.000000	1.000000
25%	4.810000	12.000000	0.000000	1.000000	0.000000	0.0	1.0	0.000000	12.000000	3.000000
50%	6.710000	20.500000	0.000000	1.000000	0.000000	0.0	1.0	0.000000	12.000000	3.000000
75%	8.890000	32.000000	1.000000	1.000000	0.000000	0.0	1.0	0.000000	13.000000	4.000000
max	41.670000	48.000000	1.000000	1.000000	1.000000	0.0	1.0	1.000000	17.000000	5.000000

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

data[data['female'] == 1]['wage'].mean(), data[data['female'] == 0]['wage'].mean() # .std, .min, .max, .count 

(4.299357798165136, 7.3688228155339734)

Вывод медианного значения, для данных, удовлетворяющих сложному условию

data[(data['female'] == 0) & (data['married'] == 1)]['wage'].median(), \ data[(data['female'] == 0) & (data['married'] == 0)]['wage'].median() 

(6.710000000000001, 5.0649999999999995)

data['wage'].nunique() 

Ниже приводятся примеры использования метода groupby для отображения информации по сгруппированному признаку

data.groupby('looks').wage.count() 

looks 1 13 2 142 3 722 4 364 5 19 Name: wage, dtype: int64

for look, sub_df in data.drop(['goodhlth'],axis=1).groupby('looks'): print(look) print(sub_df.head()) print() 

1 wage exper union black female married service educ looks 28 8.35 41 0 0 0 1 1 16 1 200 3.75 36 0 0 0 0 0 12 1 248 10.99 40 0 0 0 1 0 12 1 327 1.65 24 0 0 1 0 1 13 1 751 7.93 39 1 0 0 1 0 12 1 2 wage exper union black female married service educ looks 12 5.14 19 0 0 0 1 1 17 2 33 8.17 18 0 0 0 1 0 16 2 35 9.62 37 0 0 0 1 0 13 2 37 7.69 10 1 0 0 1 0 13 2 57 6.56 17 0 0 0 1 0 13 2 3 wage exper union black female married service educ looks 1 4.28 28 0 0 1 1 0 12 3 3 11.57 38 0 0 0 1 1 16 3 4 11.42 27 0 0 0 1 0 16 3 5 3.91 20 0 0 1 1 0 12 3 6 8.76 12 0 0 0 1 0 16 3 4 wage exper union black female married service educ looks 0 5.73 30 0 0 1 1 1 14 4 2 7.96 35 0 0 1 0 0 10 4 7 7.69 5 1 0 0 0 0 16 4 10 3.45 3 0 0 1 0 0 12 4 11 4.03 6 0 0 0 1 0 16 4 5 wage exper union black female married service educ looks 26 14.84 29 0 0 0 0 1 13 5 27 19.08 17 0 0 0 0 0 17 5 76 23.32 15 0 0 0 1 1 17 5 112 6.11 7 0 0 1 1 0 12 5 316 3.92 12 0 0 0 1 1 12 5

for look, sub_df in data.groupby('looks'): print(look) print(sub_df['wage'].median()) print() 

1 3.46 2 4.595000000000001 3 5.635 4 5.24 5 4.81

for look, sub_df in data.groupby('looks'): print(look) print(round(sub_df['female'].mean(), 3)) print() 

1 0.385 2 0.38 3 0.323 4 0.374 5 0.421

for look, sub_df in data.groupby(['looks', 'female']): print(look) print(sub_df['goodhlth'].mean()) print() 

(1, 0) 0.75 (1, 1) 1.0 (2, 0) 0.9431818181818182 (2, 1) 0.9259259259259259 (3, 0) 0.9304703476482618 (3, 1) 0.9012875536480687 (4, 0) 0.9649122807017544 (4, 1) 0.9411764705882353 (5, 0) 1.0 (5, 1) 1.0

С помощью .agg метод groupby может применять различные функции к данным, что он получает

data.groupby('looks')[['wage', 'exper']].max() 

wage	exper
looks
1	10.99	41
2	26.24	45
3	38.86	48
4	77.72	47
5	23.32	32

Декартово произведение признаков из столбцов и их отображение

pd.crosstab(data['female'], data['married']) 

married	0	1
female
0	166	658
1	223	213

pd.crosstab(data['female'], data['looks']) 

looks	1	2	3	4	5
female
0	8	88	489	228	11
1	5	54	233	136	8

Создание нового признака из наложения дополнительных условий на основе старых данных

data['exp'] = (data['exper'] >=15).astype(int) data.head(10) 

wage	exper	union	goodhlth	black	female	married	service	educ	looks	exp
0	5.73	30	0	1	0	1	1	1	14	4	1
1	4.28	28	0	1	0	1	1	0	12	3	1
2	7.96	35	0	1	0	1	0	0	10	4	1
3	11.57	38	0	1	0	0	1	1	16	3	1
4	11.42	27	0	1	0	0	1	0	16	3	1
5	3.91	20	0	0	0	1	1	0	12	3	1
6	8.76	12	0	1	0	0	1	0	16	3	0
7	7.69	5	1	1	0	0	0	0	16	4	0
8	5.00	5	0	1	0	1	0	0	16	3	0
9	3.89	12	0	1	0	1	0	0	12	3	0

new = data[data['female'] == 1] new.to_csv('new.csv', index=False) new.head() 

wage	exper	union	goodhlth	black	female	married	service	educ	looks
0	5.73	30	0	1	0	1	1	1	14	4
1	4.28	28	0	1	0	1	1	0	12	3
2	7.96	35	0	1	0	1	0	0	10	4
5	3.91	20	0	0	0	1	1	0	12	3
8	5.00	5	0	1	0	1	0	0	16	3

data['wage'].sort_values(ascending=False).head(3) 

602 77.72 269 41.67 415 38.86 Name: wage, dtype: float64

data['is_rich'] = (data['wage'] > data['wage'].quantile(.75)).astype('int64') 

data['wage'].quantile(.75) 

7.695

data.head() 

wage	exper	union	goodhlth	black	female	married	service	educ	looks	exp	is_rich
0	5.73	30	0	1	0	1	1	1	14	4	1	0
1	4.28	28	0	1	0	1	1	0	12	3	1	0
2	7.96	35	0	1	0	1	0	0	10	4	1	1
3	11.57	38	0	1	0	0	1	1	16	3	1	1
4	11.42	27	0	1	0	0	1	0	16	3	1	1

data['rubbish'] = .56 * data['wage'] + 0.32 * data['exper'] data.head() 

wage	exper	union	goodhlth	black	female	married	service	educ	looks	exp	is_rich	rubbish
0	5.73	30	0	1	0	1	1	1	14	4	1	0	12.8088
1	4.28	28	0	1	0	1	1	0	12	3	1	0	11.3568
2	7.96	35	0	1	0	1	0	0	10	4	1	1	15.6576
3	11.57	38	0	1	0	0	1	1	16	3	1	1	18.6392
4	11.42	27	0	1	0	0	1	0	16	3	1	1	15.0352

Контест для проверки понимания ссылка.

Домашнее задание будет во 2ой части

Сайт построен с использованием Pelican. За основу оформления взята тема от Smashing Magazine. Исходные тексты программ, приведённые на этом сайте, распространяются под лицензией GPLv3, все остальные материалы сайта распространяются под лицензией CC-BY.