Agg pandas как работает

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

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

В этом уроке мы продемонстрируем методы работы с инструментами библиотеки Pandas, чтобы делать такие операции.

Агрегация данных с использованием метода agg()

Функции агрегирования вычисляют интегральные параметры наборов данных. Обычно возвращаемые значения — это несколько чисел. Чаще всего это одно значение для одного столбца данных.

import pandas as pd df_clicks = pd.read_csv('./data/Cite_clicks_info.csv', index_col=0) print(df_clicks.head()) # => SHOP1 SHOP2 SHOP3 SHOP4 Advertising Size # day # 1 319.0 -265.0 319.0 328.0 small big # 2 292.0 274.0 292.0 301.0 medium small # 3 283.0 301.0 274.0 283.0 medium small # 4 328.0 364.0 328.0 NaN small small # 5 391.0 355.0 373.0 337.0 small small 

В датасете столбец Advertising со значениями ‘small’, ‘medium’, ‘large’. Они указывают на объем рекламы в этот день по магазинам, например, ‘small’ — были низкие объемы рекламы. А также столбец Size со значениями ‘small’ и ‘big’, которые указывают на величину магазина.

Примеры агрегаций

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

print(df_clicks.drop(['Advertising', 'Size'], axis=1).agg('mean')) # => SHOP1 343.807692 # SHOP2 334.481481 # SHOP3 315.785714 # SHOP4 304.230769 # dtype: float64 

Мы исключили столбцы ‘Advertising’, ‘Size’ в примере выше. Это категории, а не численные показатели. Вычисление функции mean() вызвало бы ошибку на категориальных столбцах.

Посчитаем несколько агрегаций одновременно для одного столбца. Для этого в аргументы метода agg() подадим список с перечислением функций:

print(df_clicks.drop(['Advertising', 'Size'], axis=1).agg(['max', 'mean'])) # => SHOP1 SHOP2 SHOP3 SHOP4 # max 581.000000 490.000000 581.000000 529.000000 # mean 343.807692 334.481481 315.785714 304.230769 

Продвинутые примеры агрегаций

С помощью метода agg() можно строить и более сложные примеры. Применим к столбцами различные агрегирующие функции:

dict_func = 'SHOP1': ['mean', 'max'], 'SHOP2': ['mean', 'max'], 'SHOP3': ['mean', 'max'], 'SHOP4': ['mean', 'max'], 'Advertising' : ['count']> print(df_clicks.agg(dict_func)) # => SHOP1 SHOP2 SHOP3 SHOP4 Advertising # sum 8939.0 9031.0 8842.0 7910.0 NaN # max 581.0 490.0 581.0 529.0 NaN # count NaN NaN NaN NaN 28.0 

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

print(df_clicks.agg(shop1_mean=('SHOP1', 'mean'), shop2_mean=('SHOP2', 'mean'), advertising_count=('Advertising', 'count'))) # => SHOP1 SHOP2 Advertising # shop1_mean 343.807692 NaN NaN # shop2_mean NaN 334.481481 NaN # advertising_count NaN NaN 28.0 

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

Агрегация данных с использованием метода groupby()

Рассмотрим агрегацию данных через следующие функции:

• Числовые агрегирующие функции
• Функции подсчета
• Функции порядка

Числовые агрегирующие функции

С помощью метода groupby() можно находить значения агрегированных данных по определенным категориям. Вычислим агрегированные значения для дней, когда значение столбца Advertising было ‘small’, ‘medium’ и ‘large’:

print(df_clicks.groupby(['Advertising']).agg(['mean', 'median'])) # => SHOP1 SHOP2 SHOP3 SHOP4 # mean median mean median mean median mean median # Advertising # large 350.00 319.5 294.41 327.5 309.61 320.0 219.61 312.0 # medium 270.28 312.0 346.37 338.0 260.00 322.5 380.85 344.0 # small 406.71 421.0 389.57 384.0 391.00 399.0 398.16 373.5 

Значение агрегирующих функций вычислились для каждого столбца, причем для всех категорий из столбца ‘Advertising’.

Можно для каждого столбца находить свои агрегации:

agg_func = 'SHOP1': ['mean','max'], 'SHOP2': ['min', 'median'], 'SHOP3':['std', 'var'], 'SHOP4': ['min', 'max']> print(df_clicks.groupby(['Advertising']).agg(agg_func).round(2)) # => SHOP1 SHOP2 SHOP3 SHOP4 # mean max min median std var min max # Advertising # large 350.00 581.0 -265.0 327.5 197.99 39200.26 -477.0 409.0 # medium 270.29 531.0 264.0 338.0 294.71 86851.43 311.0 487.0 # small 406.71 529.0 282.0 384.0 63.02 3971.33 321.0 529.0 

Метод round() округляет дробную часть до двух знаков после запятой. Форматирование упрощает чтение данных.

Функции подсчета

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

agg_func = 'Advertising':['count', 'nunique']> print(df_clicks.groupby(['Size']).agg(agg_func)) # => Advertising # count nunique # Size # big 9 3 # small 19 3 

Функция count подсчитывает количество значений соответствующей категории, функция nunique находит количество уникальных значений в категории. Функция nunique не учитывает пропуски при подсчете.

Функции порядка

В этом разделе покажем, как получать максимальное и минимальное количество кликов магазина по категориям рекламы. Будем использовать функции first() и last() :

agg_func = 'SHOP1': ['first', 'last']> print(df_clicks.sort_values(by='SHOP1').groupby('Advertising').agg(agg_func)) # => SHOP1 # first last # Advertising # large -424.0 581.0 # medium 283.0 487.0 # small 319.0 531.0 

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

Открыть доступ

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

• 130 курсов, 2000+ часов теории
• 1000 практических заданий в браузере
• 360 000 студентов

Наши выпускники работают в компаниях:

Groupby aggregation в pandas

Агрегация является одной из самых частых операций при анализе данных. Разные технологии предлагают нам кучу способов эффективно группировать и агрегировать интересующие нас поля(столбцы, признаки). В этой статье будет рассказано про реализацию агрегации в pandas.
По своей специализации я очень мало работаю с python, но часто слышу про плюсы и мощь этого языка, в особенности когда речь заходит про работу с данными. Поэтому я проведу здесь параллель операций с T-SQL и приведу некотрые примеры кода. В качестве данных я буду использовать наверное самый популярный data set — Ирисы Фишера.

Первое, что приходит в голову, это получить максимальное, минимальное или среднее значение по какому-либо из параметров ириса и сгруппировать по видам этого растения, что на python с помощью pandas будет выглядить примерно следующим образом:

import pandas as pd df = pd.read_csv('iris.csv', delimiter = ',') print(df.groupby('variety').max()[['sepalLength']].to_markdown()) 

| variety | sepal.length |
|:————|—————:|
| Setosa | 5.8 |
| Versicolor | 7 |
| Virginica | 7.9 |

import pandas as pd df = pd.read_csv('iris.csv', delimiter = ',') print(df.groupby('variety').sepalLength.agg( maxSepalLength = 'max', minSepalLength = 'min', ).to_markdown()) 

| variety | maxSepalLength | minSepalLength |
|:————|——————:|——————:|
| Setosa | 5.8 | 4.3 |
| Versicolor | 7 | 4.9 |
| Virginica | 7.9 | 4.9 |

Или с помощью лямбда выражений:

import pandas as pd df = pd.read_csv('iris.csv', delimiter = ',') print(df.groupby('variety').sepalLength.agg([ lambda x: x.max(), lambda x: x.min() ]).to_markdown()) 

Функция экземпляра DataFrame

to_markdown()

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

На T-SQL такая операция выглядит приблизительно так:

select i.Variety, max(i.SepalLength) as maxSepalLength from Iris i group by i.Variety 

Setosa 5.8
Versicolor 7.0
Virginica 7.9

Но допустим, теперь мы хотим получить и максимальное и минимальное (если угодно среднее) значения по всем параметрам ириса, естественно для каждого вида растения, здесь саначала код на T-SQL:

select i.Variety ,max(i.SepalLength) as maxSepalLength ,min(i.SepalLength) as minSepalLength ,max(i.SepalWidth) as maxSepalWidth ,min(i.SepalWidth) as minSepalWidth ,max(i.PetalLength) as maxPetalLength ,min(i.PetalLength) as mibPetalLength ,max(i.PetalWidth) as maxPetalWidth ,min(i.PetalWidth) as minPetalWidth from Iris i group by i.Variety 

Setosa 5.8 4.3 4.4 2.3 1.9 1.0 0.6 0.1
Versicolor 7.0 4.9 3.4 2.0 5.1 3.0 1.8 1.0
Virginica 7.9 4.9 3.8 2.2 6.9 4.5 2.5 1.4

В pandas возможность групповой агрегации появилась только в версии 0.25.0 от 18 июля 2019(что было делать раньше?) и тут есть несколько вариации, рассмотрим их:

import pandas as pd df = pd.read_csv('iris.csv', delimiter = ',') df.groupby('variety').agg( maxSepalLength = pd.NamedAgg(column = 'sepalLength', aggfunc = 'max'), minSepalLength = pd.NamedAgg(column = 'sepalLength', aggfunc = 'min'), maxSepalWidth = pd.NamedAgg(column = 'sepalWidth', aggfunc = 'max'), minSepalWidth = pd.NamedAgg(column = 'sepalWidth', aggfunc = 'min'), maxPetalLength = pd.NamedAgg(column = 'petalLength', aggfunc = 'max'), minPetalLength = pd.NamedAgg(column = 'petalLength', aggfunc = 'min'), maxPetalWidth = pd.NamedAgg(column = 'petalWidth', aggfunc = 'max'), minPetalWidth = pd.NamedAgg(column = 'petalWidth', aggfunc = 'min'), ) 

Setosa 5.8 4.3 4.4 2.3 1.9 1.0 0.6 0.1
Versicolor 7.0 4.9 3.4 2.0 5.1 3.0 1.8 1.0
Virginica 7.9 4.9 3.8 2.2 6.9 4.5 2.5 1.4

DataFrame.agg(self, func, axis=0, *args, **kwargs)

позволяет проводить агрегацию из нескольких операций над заданной осью. В качестве параметров функция получает **kwargs(именнованные аргументы, подробнее можно посмотреть в статье на habr), которые представляют собой столбец, над которым производится операция и собтсвенно имя функции агрегирования в одинарных кавычках. Запись выглядит довольно пространно. Идем дальше.

То же решение с применением лямбда выражений выглядит гораздо более лаконично и просто:

import pandas as pd df = pd.read_csv('iris.csv', delimiter = ',') df.groupby('variety').agg([ lambda x: x.max(), lambda x: x.min() ]) 

Setosa 5.8 4.3 4.4 2.3 1.9 1.0 0.6 0.1
Versicolor 7.0 4.9 3.4 2.0 5.1 3.0 1.8 1.0
Virginica 7.9 4.9 3.8 2.2 6.9 4.5 2.5 1.4

Мне часто доводится слышать о гораздо меньшем количестве написанного когда Python при решении однотипных задача в сравнении с другими языками. Здесь, в сравнении с T-SQL, с этим можно согласится, однако понятность и последовательность выражений лингвистических средств таких как SQL или T-SQL напрочь теряется(личное мнение).

Аналитикам: большая шпаргалка по 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. Постройте сводную таблицу средних чеков по всем штатам за каждый год.

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

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

Объяснение функций Grouper и Agg в Pandas¶

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

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

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

Группировка данных временных рядов¶

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

Рассмотрим пример данных о продажах и некоторые простые операции для получения общих продаж по месяцам, дням, годам и т.д.

import pandas as pd 

df = pd.read_excel("https://github.com/chris1610/pbpython/blob/master/data/sample-salesv3.xlsx?raw=True") df.head() 

account number	name	sku	quantity	unit price	ext price	date
0	740150	Barton LLC	B1-20000	39	86.69	3380.91	2014-01-01 07:21:51
1	714466	Trantow-Barrows	S2-77896	-1	63.16	-63.16	2014-01-01 10:00:47
2	218895	Kulas Inc	B1-69924	23	90.70	2086.10	2014-01-01 13:24:58
3	307599	Kassulke, Ondricka and Metz	S1-65481	41	21.05	863.05	2014-01-01 15:05:22
4	412290	Jerde-Hilpert	S2-34077	6	83.21	499.26	2014-01-01 23:26:55

Обратим внимание на типы данных:

df.info() 

 RangeIndex: 1500 entries, 0 to 1499 Data columns (total 7 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 account number 1500 non-null int64 1 name 1500 non-null object 2 sku 1500 non-null object 3 quantity 1500 non-null int64 4 unit price 1500 non-null float64 5 ext price 1500 non-null float64 6 date 1500 non-null object dtypes: float64(2), int64(2), object(3) memory usage: 82.2+ KB

Столбец date приведем к типу datetime :

df["date"] = pd.to_datetime(df['date']) 

df.dtypes 

account number int64 name object sku object quantity int64 unit price float64 ext price float64 date datetime64[ns] dtype: object

Прежде чем я продвинусь дальше, полезно познакомиться с псевдонимами смещения ( Offset Aliases ). Эти строки используются для представления различных временных частот, таких как дни, недели и годы.

Например, если вы хотите суммировать все продажи по месяцам, то можете использовать функцию resample . Особенность использования resample заключается в том, что она работает только с индексом. В этом наборе данные не индексируются по столбцу date , поэтому resample не будет работать без реструктуризации (restructuring).

Используйте set_index , чтобы сделать столбец date индексом, а затем выполните resample :

df.set_index('date').resample('M')["ext price"].sum() 

date 2014-01-31 185361.66 2014-02-28 146211.62 2014-03-31 203921.38 2014-04-30 174574.11 2014-05-31 165418.55 2014-06-30 174089.33 2014-07-31 191662.11 2014-08-31 153778.59 2014-09-30 168443.17 2014-10-31 171495.32 2014-11-30 119961.22 2014-12-31 163867.26 Freq: M, Name: ext price, dtype: float64

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

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

df.set_index('date').groupby('name')["ext price"].resample("M").sum() 

name date Barton LLC 2014-01-31 6177.57 2014-02-28 12218.03 2014-03-31 3513.53 2014-04-30 11474.20 2014-05-31 10220.17 . Will LLC 2014-08-31 1439.82 2014-09-30 4345.99 2014-10-31 7085.33 2014-11-30 3210.44 2014-12-31 12561.21 Name: ext price, Length: 240, dtype: float64

Это работает, но выглядит немного неуклюжим.

К счастью, Grouper упрощает данную процедуру!

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

df.groupby(['name', pd.Grouper(key='date', freq='M')])['ext price'].sum() 

name date Barton LLC 2014-01-31 6177.57 2014-02-28 12218.03 2014-03-31 3513.53 2014-04-30 11474.20 2014-05-31 10220.17 . Will LLC 2014-08-31 1439.82 2014-09-30 4345.99 2014-10-31 7085.33 2014-11-30 3210.44 2014-12-31 12561.21 Name: ext price, Length: 240, dtype: float64

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

Приятным дополнением является то, что для обобщенния в другом временном интервале, достаточно измените параметр freq на один из допустимых псевдонимов смещения.

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

df.groupby(['name', pd.Grouper(key='date', freq='A-DEC')])['ext price'].sum() 

name date Barton LLC 2014-12-31 109438.50 Cronin, Oberbrunner and Spencer 2014-12-31 89734.55 Frami, Hills and Schmidt 2014-12-31 103569.59 Fritsch, Russel and Anderson 2014-12-31 112214.71 Halvorson, Crona and Champlin 2014-12-31 70004.36 Herman LLC 2014-12-31 82865.00 Jerde-Hilpert 2014-12-31 112591.43 Kassulke, Ondricka and Metz 2014-12-31 86451.07 Keeling LLC 2014-12-31 100934.30 Kiehn-Spinka 2014-12-31 99608.77 Koepp Ltd 2014-12-31 103660.54 Kuhn-Gusikowski 2014-12-31 91094.28 Kulas Inc 2014-12-31 137351.96 Pollich LLC 2014-12-31 87347.18 Purdy-Kunde 2014-12-31 77898.21 Sanford and Sons 2014-12-31 98822.98 Stokes LLC 2014-12-31 91535.92 Trantow-Barrows 2014-12-31 123381.38 White-Trantow 2014-12-31 135841.99 Will LLC 2014-12-31 104437.60 Name: ext price, dtype: float64

Если ваши годовые продажи были не календарными, то данные можно легко изменить, передав параметр freq .

Призываю вас поиграть с разными смещениями, чтобы понять, как это работает. При суммировании данных временных рядов это невероятно удобно!

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

Новая и улучшенная агрегатная функция¶

В pandas 0.20.0 была добавлена новая функция agg , которая значительно упрощает суммирование данных аналогично groupby.

Чтобы проиллюстрировать ее функциональность, предположим, что нам нужно получить сумму в столбцах ext price и quantity (количество), а также среднее значение unit price (цены за единицу).

Процесс не очень удобный: