データサイエンス100本ノック（構造化データ加工編）- R Part 2 (Q21 to Q40)の解説です。

参照(Reference) : 「データサイエンティスト協会スキル定義委員」の「データサイエンス100本ノック（構造化データ加工編）」

The Data Scientist Society Github :

GitHub - The-Japan-DataScientist-Society/100knocks-preprocess: データサイエンス100本ノック（構造化データ加工編）

データサイエンス100本ノック（構造化データ加工編）. Contribute to The-Japan-DataScientist-Society/100knocks-preprocess development by creating a...

Data Science 100 Knocks (Structured Data Processing) URL :

100knocks-preprocess/docker/work/answer/ans_preprocess_knock_Python.ipynb at master · The-Japan-DataScientist-Society/100knocks-preprocess

データサイエンス100本ノック（構造化データ加工編）. Contribute to The-Japan-DataScientist-Society/100knocks-preprocess development by creating a...

はじめに

初めに以下のセルを実行してください
必要なライブラリのインポートとデータベース（PostgreSQL）からのデータ読み込みを行います
利用が想定されるライブラリは以下セルでインポートしています
その他利用したいライブラリがあればinstall.packages()で適宜インストールしてください
名前、住所等はダミーデータであり、実在するものではありません

In [ ]:

require("RPostgreSQL") 
require("tidyr") 
require("dplyr") 
require("stringr") 
require("caret") 
require("lubridate") 
require("rsample") 
require("recipes") 
require("themis") 

host <- "db" 
port <- Sys.getenv()["PG_PORT"] 
dbname <- Sys.getenv()["PG_DATABASE"] 
user <- Sys.getenv()["PG_USER"] 
password <- Sys.getenv()["PG_PASSWORD"] 

con <- dbConnect(PostgreSQL(), host=host, port=port, dbname=dbname, user=user, password=password) 
df_customer <- dbGetQuery(con,"SELECT * FROM customer") 
df_category <- dbGetQuery(con,"SELECT * FROM category") 
df_product <- dbGetQuery(con,"SELECT * FROM product") 
df_receipt <- dbGetQuery(con,"SELECT * FROM receipt") 
df_store <- dbGetQuery(con,"SELECT * FROM store") 
df_geocode <- dbGetQuery(con,"SELECT * FROM geocode")

Loading required package: RPostgreSQL

Loading required package: DBI

Loading required package: tidyr

Loading required package: dplyr


Attaching package: ‘dplyr’


The following objects are masked from ‘package:stats’:

    filter, lag


The following objects are masked from ‘package:base’:

    intersect, setdiff, setequal, union


Loading required package: stringr

Loading required package: caret

Loading required package: ggplot2

Loading required package: lattice

Loading required package: lubridate


Attaching package: ‘lubridate’


The following objects are masked from ‘package:base’:

    date, intersect, setdiff, union


Loading required package: rsample

Loading required package: recipes


Attaching package: ‘recipes’


The following object is masked from ‘package:stringr’:

    fixed


The following object is masked from ‘package:stats’:

    step


Loading required package: themis

Registered S3 methods overwritten by 'themis':
  method                  from   
  bake.step_downsample    recipes
  bake.step_upsample      recipes
  prep.step_downsample    recipes
  prep.step_upsample      recipes
  tidy.step_downsample    recipes
  tidy.step_upsample      recipes
  tunable.step_downsample recipes
  tunable.step_upsample   recipes


Attaching package: ‘themis’


The following objects are masked from ‘package:recipes’:

    step_downsample, step_upsample

演習問題

R-021: レシート明細データ（df_receipt）に対し、件数をカウントせよ。

In [22]:

nrow(df_receipt)

解説:

nrow(df_receipt)」というコードは、Rまたは同様の統計プログラミング言語で記述されています。これは、"df_receipt "というデータフレームの行数を決定するために使用されます。

以下、コードの内訳を説明します。

"nrow() "はRの組み込み関数で、データフレーム内の行数を返す。

"df_receipt "は、行数を求めたいデータフレームの名前です。

例えば、データフレーム "df_receipt "に100行のデータがある場合、このコードを実行すると、値100が返されます。このコードは、さらなる分析やデータの操作を行う前に、データフレームのサイズを素早くチェックし、期待通りの行数を持つことを確認するのに便利です。

R-022: レシート明細データ（df_receipt）の顧客ID（customer_id）に対し、ユニーク件数をカウントせよ。

In [23]:

length(unique(df_receipt$customer_id))

解説:

コード "length(unique(df_receipt$customer_id))" は、R または同様の統計プログラミング言語で記述されています。これは、"df_receipt "というデータフレームに含まれるユニークな顧客の数を決定するために使用されます。

以下、コードの内訳を説明します。

"unique() "は、あるベクトルのユニークな要素だけを含むベクトルを返すR関数です。この場合、"unique() "関数に渡されるベクトルは "df_receipt$customer_id "で、"df_receipt "データフレーム内の顧客IDを含む列である。

"length() "もまた、ベクトルの要素数を返すRの組み込み関数である。この場合、"length() "に渡されるベクトルは、"unique() "関数の出力であり、ユニークな顧客IDを含むベクトルである。

これをまとめると、このコードは、ユニークな顧客IDを含むベクトルの長さを取ることによって、「df_receipt」データフレーム内のユニークな顧客の数を計算する。例えば、データフレームに1000行が含まれ、ユニークな顧客IDが500しかない場合、このコードを実行すると、500という値が返されます。このコードは、データセット内のユニークな顧客の数を把握したり、顧客生涯価値などの顧客レベルの指標を計算するのに便利です。

R-023: レシート明細データ（df_receipt）に対し、店舗コード（store_cd）ごとに売上金額（amount）と売上数量（quantity）を合計せよ。

In [24]:

df_receipt %>% group_by(store_cd) %>% summarise(amount = sum(amount), quantity = sum(quantity), .groups = "drop")

A tibble: 52 × 3

store_cd	amount	quantity
<chr>	<int>	<int>
S12007	638761	2099
S12013	787513	2425
S12014	725167	2358
S12029	794741	2555
S12030	684402	2403
S13001	811936	2347
S13002	727821	2340
S13003	764294	2197
S13004	779373	2390
S13005	629876	2004
S13008	809288	2491
S13009	808870	2486
S13015	780873	2248
S13016	793773	2432
S13017	748221	2376
S13018	790535	2562
S13019	827833	2541
S13020	796383	2383
S13031	705968	2336
S13032	790501	2491
S13035	715869	2219
S13037	693087	2344
S13038	708884	2337
S13039	611888	1981
S13041	728266	2233
S13043	587895	1881
S13044	520764	1729
S13051	107452	354
S13052	100314	250
S14006	712839	2284
S14010	790361	2290
S14011	805724	2434
S14012	720600	2412
S14021	699511	2231
S14022	651328	2047
S14023	727630	2258
S14024	736323	2417
S14025	755581	2394
S14026	824537	2503
S14027	714550	2303
S14028	786145	2458
S14033	725318	2282
S14034	653681	2024
S14036	203694	635
S14040	701858	2233
S14042	534689	1935
S14045	458484	1398
S14046	412646	1354
S14047	338329	1041
S14048	234276	769
S14049	230808	788
S14050	167090	580

解説:

df_receipt %>% group_by(store_cd) %>% summarise(amount = sum(amount), quantity = sum(quantity), .groups = 'drop')" というコードは、Rまたは同様の統計プログラミング言語で書かれています。これは、"df_receipt" データフレームを "store_cd" という変数でグループ化し、各店舗グループ内の "amount" と "quantity" 変数の合計を計算するために使用されています。

以下、コードの内訳を説明します。

パイプ演算子（「%>%」）は、複数の関数を順番に連結するために使用します。パイプ演算子（「%>%」）は、複数の関数を連鎖させて使うもので、前の関数の出力を受け取り、次の関数の入力として使用します。この例では、"group_by() "と "summarise() "関数を連結させるためにパイプ演算子を使用しています。

"group_by() "は、データフレームを1つまたは複数の変数でグループ化するために使用されるR関数です。今回は、"df_receipt "データフレームを "store_cd "変数でグループ化します。

"summarise() "は、データフレームの要約統計量を計算するために使用されるR関数です。今回は、各店舗グループ内の「金額」「数量」変数の合計を算出しています。また、代入演算子「=」を使って、新しい変数の名前を指定しています。

summarise()」関数の「.groups」引数は、出力の書式を指定するために使用されます。これを "drop "に設定すると、出力からグループ化情報が取り除かれます。

このコードの結果は、"df_receipt "データフレーム内の各店舗に1行を持つ新しいデータフレームになります。amount "と "quantity "の列には、各店舗グループ内のこれらの変数の合計が含まれます。このコードは、総売上高や販売個数など、店舗レベルの指標を計算するのに便利です。

R-024: レシート明細データ（df_receipt）に対し、顧客ID（customer_id）ごとに最も新しい売上年月日（sales_ymd）を求め、10件表示せよ。

In [25]:

df_receipt %>% group_by(customer_id) %>% summarise(max_ymd = max(sales_ymd), .groups = "drop") %>% slice(1:10)

A tibble: 10 × 2

customer_id	max_ymd
<chr>	<int>
CS001113000004	20190308
CS001114000005	20190731
CS001115000010	20190405
CS001205000004	20190625
CS001205000006	20190224
CS001211000025	20190322
CS001212000027	20170127
CS001212000031	20180906
CS001212000046	20170811
CS001212000070	20191018

解説:

df_receipt %>% group_by(customer_id) %>% summarise(max_ymd = max(sales_ymd), .groups = 'drop') %>% slice(1:10)" というコードはRまたは同様の統計プログラミング言語で書かれています。これは、"df_receipt" データフレームを "customer_id" という変数でグループ化し、各顧客の最新の購入日を見つけるために使用されます。最後に、出来上がったデータフレームの最初の10行をスライスしています。

以下、コードの内訳を説明します。

パイプ演算子（「%>%」）は、複数の関数を順番に連結するために使用します。パイプ演算子（"%>%"）は、複数の関数を順番に連結するために使用されます。前の関数の出力を受け取り、次の関数の入力として使用します。この例では、"group_by()"、"summarise()"、"slice() "関数を連結するためにパイプ演算子が使用されています。

"group_by() "は、データフレームを1つまたは複数の変数でグループ化するために使用されるR関数です。この場合、"df_receipt "データフレームを "customer_id "変数でグループ化しています。

"summarise() "は、データフレームの要約統計量を計算するために使用されるR関数です。今回は、"sales_ymd "変数の "max() "関数を用いて、各顧客の最新の購入日を算出しています。

summarise()」関数の「.groups」引数は、出力がどのようにフォーマットされるかを指定するために使用されます。これを "drop "に設定すると、出力からグループ化情報が取り除かれます。

"slice() "は、データフレームから行のサブセットを抽出するために使用されるR関数です。この場合、結果のデータフレームから最初の10行を選択しています。

このコードの結果は、"df_receipt "データフレームの各顧客について1行を持つ新しいデータフレームになります。max_ymd "列には、各顧客の最新の購入日が含まれます。最後に、このコードは結果のデータ・フレームの最初の10行を選択します。このコードは、各顧客の最新の購入日を把握するのに役立ち、様々な顧客レベルの分析やセグメンテーションの目的に使用することができます。

R-025: レシート明細データ（df_receipt）に対し、顧客ID（customer_id）ごとに最も古い売上年月日（sales_ymd）を求め、10件表示せよ。

In [26]:

df_receipt %>% group_by(customer_id) %>% summarise(min_ymd = min(sales_ymd), .groups = "drop") %>% slice(1:10)

A tibble: 10 × 2

customer_id	min_ymd
<chr>	<int>
CS001113000004	20190308
CS001114000005	20180503
CS001115000010	20171228
CS001205000004	20170914
CS001205000006	20180207
CS001211000025	20190322
CS001212000027	20170127
CS001212000031	20180906
CS001212000046	20170811
CS001212000070	20191018

解説:

このコードでは、%>%（パイプ）演算子を使って、df_receiptというデータ・フレームに対して一連の操作を連鎖的に行っています。

以下は、各操作が何をするのかのステップバイステップの説明です。

group_by(customer_id)。group_by(customer_id)：customer_id列でデータをグループ化し、その後の処理を顧客ごとに分けて実行します。

summarise(min_ymd = min(sales_ymd), .groups = "drop"):sales_ymdカラムの最小値を計算し、min_ymdという新しいカラムに格納することで、各グループ内のデータの要約を作成する。.groups = "drop "引数は、結果のデータフレームからグループ化情報を削除するようdplyrに指示します（さらなる分析に必要ないため）。

slice(1:10):これは、結果のデータフレームから最初の10行を選択します。データはcustomer_idでグループ化され、summary関数が使用されたので、データセットの最初の10人の顧客の最も早いsales_ymd値が得られることになります。

全体として、このコードはdf_receiptデータフレーム内の各顧客の最も早いsales_ymd値を選択し、データセットの最初の10人の顧客の最も早い日付を返しています。

R-026: レシート明細データ（df_receipt）に対し、顧客ID（customer_id）ごとに最も新しい売上年月日（sales_ymd）と古い売上年月日を求め、両者が異なるデータを10件表示せよ。

In [27]:

df_receipt %>% group_by(customer_id) %>% summarise(max_ymd = max(sales_ymd) ,min_ymd = min(sales_ymd), .groups = "drop") %>% filter(max_ymd != min_ymd) %>% slice(1:10)

A tibble: 10 × 3

customer_id	max_ymd	min_ymd
<chr>	<int>	<int>
CS001114000005	20190731	20180503
CS001115000010	20190405	20171228
CS001205000004	20190625	20170914
CS001205000006	20190224	20180207
CS001214000009	20190902	20170306
CS001214000017	20191006	20180828
CS001214000048	20190929	20171109
CS001214000052	20190617	20180208
CS001215000005	20181021	20170206
CS001215000040	20171022	20170214

解説:

このコードでは、%>%（パイプ）演算子を使って、df_receiptというデータ・フレームに対して一連の操作を連鎖的に行っています。

以下は、各操作が何をするのかのステップバイステップの説明です。

group_by(customer_id) : group_by(customer_id)：customer_id列でデータをグループ化し、その後の処理を顧客ごとに分けて実行する。

summarise(max_ymd = max(sales_ymd), min_ymd = min(sales_ymd), .groups = "drop"): sales_ymdカラムの最大値と最小値を計算し、それぞれmax_ymdとmin_ymdという新しいカラムに格納することで、各グループ内のデータの要約を作成する。.groups = "drop "引数は、結果のデータフレームからグループ化情報を削除するようdplyrに指示します（さらなる分析には必要ないため）。

filter(max_ymd != min_ymd): これは、max_ymdの値がmin_ymdの値と等しくない行だけを含むようにデータフレームをフィルタリングします。これにより、データセットの対象期間中に1回しか購入しなかった顧客は除外されます。

slice(1:10):これは、結果のデータ・フレームの最初の10行を選択します。データはcustomer_idでグループ化され、max関数とmin関数で要約され、それらの要約統計に基づいてフィルタリングされたので、これはデータセットの対象期間中に1回以上購入した最初の10人の顧客を得ることができます。

全体として、このコードはdf_receiptデータフレームでカバーされる期間中に1回以上購入した顧客を選択し、最も早い購入日と最も遅い購入日を返しています。このコードでは、これらの条件を満たす最初の10人の顧客について、最も早い購入日と最も遅い購入日を返します。

R-027: レシート明細データ（df_receipt）に対し、店舗コード（store_cd）ごとに売上金額（amount）の平均を計算し、降順でTOP5を表示せよ。

In [28]:

df_receipt %>% group_by(store_cd) %>% summarise(mean_amount = mean(amount), .groups = "drop") %>% arrange(desc(mean_amount)) %>% slice(1:5)

A tibble: 5 × 2

store_cd	mean_amount
<chr>	<dbl>
S13052	402.8675
S13015	351.1120
S13003	350.9155
S14010	348.7913
S13001	348.4704

解説:

このコードでは、%>%（パイプ）演算子を使って、df_receiptというデータ・フレームに対して一連の操作を連鎖的に行っています。

以下、各操作が何をするのか、順を追って説明します。

group_by(store_cd)。group_by(store_cd)：store_cd列でデータをグループ化し、その後の処理を各店舗ごとに行う。

summarise(mean_amount = mean(amount), .groups = "drop") : 各グループ内のデータの要約を作成し、amount列の平均値を計算して、mean_amountという新しい列に格納します。.groups = "drop "引数は、結果のデータフレームからグループ化情報を削除するようdplyrに指示します（さらなる分析に必要ないため）。

arrange(desc(mean_amount)) : これは、mean_amount列の降順（高いものから低いものへ）で結果のデータフレームをソートします。

slice(1:5) : 結果のデータフレームから最初の5行を選択します。データはstore_cdでグループ化され、mean関数を使って要約されたので、これにより、すべてのトランザクションで最も高い平均金額値を持つ店舗が得られます。

全体として、このコードはdf_receiptデータフレーム内のすべてのトランザクションで最も高い平均金額値を持つ店舗を選択し、その値に基づいて上位5店舗を返しています。

R-028: レシート明細データ（df_receipt）に対し、店舗コード（store_cd）ごとに売上金額（amount）の中央値を計算し、降順でTOP5を表示せよ。

In [29]:

df_receipt %>% group_by(store_cd) %>% summarise(median_amount = median(amount), .groups = "drop") %>% arrange(desc(median_amount)) %>% slice(1:5)

A tibble: 5 × 2

store_cd	median_amount
<chr>	<dbl>
S13052	190
S14010	188
S14050	185
S13003	180
S13018	180

解説:

このコードでは、%>%（パイプ）演算子を使って、df_receiptというデータ・フレームに対して一連の操作を連鎖的に行っています。

以下、各操作が何をするのか、順を追って説明します。

group_by(store_cd)。group_by(store_cd)：store_cd列でデータをグループ化し、その後の処理を店舗ごとに分けて実行するようにします。

summarise(median_amount = median(amount), .groups = "drop") : 各グループ内のデータの要約を作成し、amount列の中央値を計算して、median_amountという新しい列に格納します。.groups = "drop "引数は、結果のデータフレームからグループ化情報を削除するようdplyrに指示します（さらなる分析には必要ないため）。

arrange(desc(median_amount)) : これは、結果のデータフレームをmedian_amount列で降順（高い方から低い方へ）にソートします。

slice(1:5) : 結果のデータフレームから最初の5行を選択します。データはstore_cdでグループ化され、median関数を使って要約されたので、これにより、すべてのトランザクションで中央値の値が最も高い店舗が得られることになります。

全体として、このコードはdf_receiptデータフレームの全トランザクションの中で最も中央値の高い店舗を選択し、その値に基づいて上位5店舗を返しています。このコードと前回説明したコードの違いは、このコードでは、各店舗の金額値の中心傾向を計算するために、平均関数ではなく、中央値関数を使用していることです。

R-029: レシート明細データ（df_receipt）に対し、店舗コード（store_cd）ごとに商品コード（product_cd）の最頻値を求め、10件表示させよ。

In [30]:

# コード例1 df_receipt %>% group_by(store_cd, product_cd) %>% summarise(cnt = n(), .groups = "drop_last") %>% filter(cnt == cnt %>% max()) %>% ungroup() %>% slice(1:10)

A tibble: 10 × 3

store_cd	product_cd	cnt
<chr>	<chr>	<int>
S12007	P060303001	72
S12013	P060303001	107
S12014	P060303001	65
S12029	P060303001	92
S12030	P060303001	115
S13001	P060303001	67
S13002	P060303001	78
S13003	P071401001	65
S13004	P060303001	88
S13005	P040503001	36

解説:

このコードはdplyrパッケージを使って、df_receiptというデータフレームに対してデータ操作を行うものです。以下は、このコードが行っていることを段階的に説明したものである。

ある関数の出力が次の関数の入力になるように、関数を連鎖させるために使用されるパイプ演算子です。

group_by関数は、データフレームをstore_cdとproduct_cdでグループ化する関数です。

summarise関数は、各グループの要約統計量を計算します。この場合、各グループの行数をカウントし、cntという新しい列を作成します。

.groups = "drop_last "引数は、summarise関数で作成された最後のグループ化レベル、つまりproduct_cdグループ化を削除するために使用されます。これは、後で最大数でフィルタリングするのを簡単にするために行われます。

filter関数は、ある条件を満たした行を選択する。この場合、cnt列がデータフレーム内のcnt列の最大値と等しい行を選択することになります。

ungroup関数は、データフレームからすべてのグループ化レベルを削除します。

slice関数は、その位置に基づいて行のサブセットを選択する。この場合、データフレームの最初の10行を選択しています。

つまり、このコードは全体として、データを店舗と商品でグループ化し、各グループのカウントを計算し、カウントが最も多いグループをフィルタリングして、上位10件を選択しています。

In [31]:

# コード例2： which.max()を使用（最頻値複数発生時、どれか一つに絞られる） # 件数の表示は省略 

# Display of the number of cases is omitted 

table_product <-table(df_receipt$store_cd,df_receipt$product_cd) 

store <- names(table_product[,1]) 

mode_product <- c() 
for (i in 1:length(store)){ 
mode_product[i] <- names(which.max(table_product[i,])) 
} 

data.frame(store_cd = store, product_cd = mode_product) %>% 
 slice(1:10)

A data.frame: 10 × 2

store_cd	product_cd
<chr>	<chr>
S12007	P060303001
S12013	P060303001
S12014	P060303001
S12029	P060303001
S12030	P060303001
S13001	P060303001
S13002	P060303001
S13003	P071401001
S13004	P060303001
S13005	P040503001

解説:

このコードは、df_receiptデータフレーム内の各店舗の各商品コードのモード（最頻値）を求めるために、table関数とforループを使っています。

以下、このコードが行っていることをステップバイステップで説明します。

table関数は、df_receiptのstore_cdとproduct_cdの各組み合わせのカウントの分割表を作成します。その結果、table_productというオブジェクトは、行が各店舗、列が各商品コードに対応する行列となります。

names関数は、table_product行列の1列目から店舗コードを抽出し、storeという文字ベクトルとして保存する。

各店舗の各商品コードのモードを保存するために、mode_productという空のベクトルが作成されます。

forループはstoreの各店舗を繰り返し、その店舗の各商品コードのモードを求めます。which.max関数でtable_product行列の各行の最大カウントのインデックスを求め、names関数でそのインデックスを持つ商品コードを抽出する。得られたプロダクトコードはmode_productベクトルに格納される。

store_cdとproduct_cdの2つのカラムを持つデータフレームが作成される。store_cdカラムにはstoreベクトルの値が、product_cdカラムにはmode_productベクトルの値が格納される。

また、%>%演算子を使ってデータフレームをslice関数にパイプし、データフレームの最初の10行を選択しています。

つまり、このコードは全体として、df_receiptの各店舗の各商品コードのモードを求め、これらの値でデータフレームを作成し、上位10件を選択しています。

R-030: レシート明細データ（df_receipt）に対し、店舗コード（store_cd）ごとに売上金額（amount）の分散を計算し、降順で5件表示せよ。

In [32]:

var_sample <- function(x){ var(x) * (length(x) - 1) / length(x) } 

df_receipt %>% 
 group_by(store_cd) %>% 
 summarise(var_amount = var_sample(amount), .groups = "drop") %>%   arrange(desc(var_amount)) %>% 
 slice(1:5)

A tibble: 5 × 2

store_cd	var_amount
<chr>	<dbl>
S13052	440088.7
S14011	306314.6
S14034	296920.1
S13001	295432.0
S13015	295294.4

解説:

このコードは、dplyrパッケージを使用して、df_receiptデータフレームの各店舗の金額変数のサンプル分散を計算し、次に分散が最も大きい上位5店舗を選択しています。

以下は、このコードが行っていることをステップバイステップで説明したものです。

var_sample 関数が定義されており、var(x) * (length(x) - 1) / length(x) という式を使って値xのベクトルのサンプル分散を計算します。この式は、母集団の分散を偏りなく推定するために、length(x)の代わりにlength(x) - 1で割ることで分散を調整する。

演算子 %>% は、df_receipt データフレームをチェーンの次の関数にパイプするために使用されます。

group_by関数は、データをstore_cdでグループ化するために使用されます。

summarise関数は、各グループの要約統計量を計算します。この場合、var_sample関数を使用して、各グループの金額変数のサンプル分散を計算し、var_amountという新しい列を作成しています。

.groups = "drop "引数は、出力からグループ化情報を削除し、グループ化されたtibbleではなく、フラットなデータフレームにするために使用されます。

arrange関数は、var_amountでデータフレームを降順にソートするために使用され、分散が最も高い店舗が最初に表示されるようにします。

演算子%>%は、ソートされたデータフレームをslice関数にパイプし、データフレームの最初の5行を選択するために使用されています。

つまり、このコードは全体として、店舗ごとにデータをグループ化し、グループごとに金額変数のサンプル分散を計算し、分散によって結果のデータフレームを降順にソートし、そして上位5つの結果を選択しています。

R-031: レシート明細データ（df_receipt）に対し、店舗コード（store_cd）ごとに売上金額（amount）の標準偏差を計算し、降順で5件表示せよ。

In [33]:

var_sample <- function(x){ var(x)*(length(x)-1)/length(x) } 

std_sample <- function(x){ sqrt(var_sample(x)) } 

head( 
df_receipt %>% 
group_by(store_cd) %>% 
summarise(std_amount = std_sample(amount), .groups = "drop") %>%
arrange(desc(std_amount)) , 
n = 5
)

A tibble: 5 × 2

store_cd	std_amount
<chr>	<dbl>
S13052	663.3918
S14011	553.4569
S14034	544.9037
S13001	543.5366
S13015	543.4099

解説:

このコードは、dplyrパッケージを使って、df_receiptデータフレームの各店舗の金額変数のサンプル標準偏差を計算し、標準偏差が最も高い上位5店舗を選択しています。

以下、このコードが何をやっているのか、順を追って説明します。

var_sample 関数が定義されており、var(x) * (length(x) - 1) / length(x) という式を使って値 x のベクトルのサンプル分散を計算しています。この式は、母集団の分散を偏りなく推定するために、length(x)の代わりにlength(x) - 1で割ることで分散を調整する。

std_sample関数が定義されており、sqrt(var_sample(x))という式を用いて、値のベクトルxの標本標準偏差を計算するものである。

head関数は、結果のデータフレームの最初の5行を選択するために使用されます。

演算子 %>% は、df_receipt データフレームをチェーンの次の関数にパイプするために使用されます。

group_by関数は、データをstore_cdでグループ化するために使用されます。

summarise関数は、各グループの要約統計量を計算します。この場合、std_sample関数を使用して、各グループの金額変数のサンプル標準偏差を計算し、std_amountという新しい列を作成しています。

.groups = "drop "引数は、出力からグループ化情報を削除し、グループ化されたtibbleではなく、フラットなデータフレームにするために使用されます。

arrange関数は、データフレームをstd_amountで降順にソートし、標準偏差が最も高い店舗が最初に表示されるようにするために使用される。

n = 5の引数は、出力を上位5行に限定するために使用されます。

つまり、このコードは全体として、データを店舗ごとにグループ化し、グループごとに金額変数のサンプル標準偏差を計算し、標準偏差の降順で結果のデータフレームをソートし、そして上位5つの結果を選択しています。

R-032: レシート明細データ（df_receipt）の売上金額（amount）について、25％刻みでパーセンタイル値を求めよ。

In [34]:

df_receipt %>% 
summarise
(amount_25per = quantile(amount, 0.25), 
amount_50per = quantile(amount, 0.5), 
amount_75per = quantile(amount, 0.75), 
amount_100per = quantile(amount, 1.0))

A data.frame: 1 × 4

amount_25per	amount_50per	amount_75per	amount_100per
<dbl>	<dbl>	<dbl>	<dbl>
102	170	288	10925

解説:

このコードはdplyrパッケージを使って、df_receiptデータフレーム内の金額変数の四分位を計算しています。

以下は、このコードが行っていることをステップバイステップで説明します。

演算子%>%は、df_receiptデータフレームをチェーン内の次の関数にパイプするために使用されます。

summarise関数は、データフレームの要約統計量を計算するために使用されます。この場合、量変数の25、50（中央値）、75、100パーセンタイルを計算するために、分位関数を使用しています。

結果のデータフレームは1行4列で、列名はamount_25per, amount_50per, amount_75per, amount_100perで、対応する四分位点の値もあります。

つまり、全体として、このコードはdf_receiptデータフレーム内のamount変数の四分位を計算し、四分位値を含むサマリーデータフレームを返しているのです。

R-033: レシート明細データ（df_receipt）に対し、店舗コード（store_cd）ごとに売上金額（amount）の平均を計算し、330以上のものを抽出せよ。

In [35]:

df_receipt %>% 
 group_by(store_cd) %>% 
 summarise(mean_amount = mean(amount), .groups = "drop") %>% 
 filter(mean_amount >= 330)

A tibble: 13 × 2

store_cd	mean_amount
<chr>	<dbl>
S12013	330.1941
S13001	348.4704
S13003	350.9155
S13004	330.9439
S13015	351.1120
S13019	330.2086
S13020	337.8799
S13052	402.8675
S14010	348.7913
S14011	335.7183
S14026	332.3406
S14045	330.0821
S14047	330.0771

解説:

このコードはdplyrパッケージを使って、df_receiptデータフレームをstore_cdでグループ化し、各グループの平均金額を計算し、平均金額が330以上であるグループのみを含むように結果のデータフレームをフィルターしています。

以下は、このコードが行っていることを段階的に説明したものです。

演算子%>%は、df_receiptデータフレームをチェーンの次の関数にパイプするために使用されます。

group_by関数は、データをstore_cdでグループ化するために使用されます。

summarise関数は、各グループの要約統計量を計算するために使用されます。この場合、mean関数を使って各グループの平均金額を計算し、mean_amountという新しい列を作成しています。

.groups = "drop "引数は、出力からグループ化情報を削除し、グループ化されたtibbleではなく、フラットなデータフレームにするために使用されます。

filter関数は、mean_amountが330以上の行のみを含むようにデータフレームをサブセットするために使用されます。

つまり、このコードは全体として、データをstore_cdでグループ化し、各グループの平均金額を計算し、平均金額が330以上のグループのみを選択しています。結果として得られるデータフレームには、対象となる店舗ごとに1行が含まれ、店舗コードと平均金額が表示されます。

R-034: レシート明細データ（df_receipt）に対し、顧客ID（customer_id）ごとに売上金額（amount）を合計して全顧客の平均を求めよ。ただし、顧客IDが”Z”から始まるものは非会員を表すため、除外して計算すること。

In [36]:

df_mean <- df_receipt %>% 
 filter(!grepl("^Z", customer_id)) %>% 
 group_by(customer_id) %>% 
 summarise(sum_amount = sum(amount), .groups = "drop") %>% 
 summarise(mean_amount = mean(sum_amount)) 

df_mean$mean_amount

2547.74223452926

解説:

このコードは、dplyrパッケージを使用して、customer_idが文字 "Z "で始まる顧客を除外した後、各顧客の平均消費額を計算しています。

以下は、このコードが行っていることを段階的に説明したものである。

演算子 %>% は、df_receipt データフレームをチェーンの次の関数にパイプするために使用されます。

filter関数は、customer_idが文字 "Z "で始まる行を除外するために使用されます。

group_by関数は、customer_idでデータをグループ化するために使用されます。

summarise関数は、各グループの要約統計量を計算するために使用されます。この場合、sum関数を使って各顧客が使った金額の合計を計算し、sum_amountという新しい列を作成しています。

.groups = "drop "引数は、出力からグループ化情報を削除し、グループ化されたibbleではなく、フラットなデータフレームにするために使用されます。

もう一つのsummarise関数は、全顧客のsum_amountの平均値を計算するために使用されます。

結果の mean_amount 値は、$mean_amount を使って抽出されます。

全体として、このコードは customer_id が "Z" で始まる行を除外するためにデータをフィルタリングし、customer_id でデータをグループ化し、各顧客が使った合計金額を計算し、すべての顧客にわたる平均 sum_amount を計算し、結果の平均値を返している。結果の出力は、各顧客が使用した平均額を表す単一の数値です。

R-035: レシート明細データ（df_receipt）に対し、顧客ID（customer_id）ごとに売上金額（amount）を合計して全顧客の平均を求め、平均以上に買い物をしている顧客を抽出し、10件表示せよ。ただし、顧客IDが”Z”から始まるものは非会員を表すため、除外して計算すること。

In [37]:

df_sum <- df_receipt %>% 
 filter(!grepl("^Z", customer_id)) %>% 
 group_by(customer_id) %>% 
 summarise(sum_amount = sum(amount), .groups = "drop") 

df_mean <- df_sum %>% 
 summarise(mean_amount = mean(sum_amount)) 

df_sum %>% 
 filter(sum_amount >= df_mean$mean_amount) %>% 
 slice(1:10)

A tibble: 10 × 2

customer_id	sum_amount
<chr>	<int>
CS001115000010	3044
CS001205000006	3337
CS001214000009	4685
CS001214000017	4132
CS001214000052	5639
CS001215000040	3496
CS001304000006	3726
CS001305000005	3485
CS001305000011	4370
CS001315000180	3300

解説:

このコードは、dplyrパッケージを使用して、customer_idが文字「Z」で始まる顧客を除外した後、全顧客の平均使用額以上の金額を使用した顧客をフィルタリングしています。その後、総使用額に基づいて上位10名の顧客を選択します。

以下は、このコードが行っていることを順を追って説明したものです。

演算子 %>% は、df_receipt データフレームをチェーン内の次の関数にパイプするために使用されます。

filter関数は、customer_idが文字 "Z "で始まる行を除外するために使用されます。

group_by関数は、customer_idでデータをグループ化するために使用されます。

summarise関数は、各グループの要約統計量を計算するために使用されます。この場合、sum関数を使って各顧客が使った金額の合計を計算し、sum_amountという新しい列を作成しています。

.groups = "drop "引数は、出力からグループ化情報を削除し、グループ化されたibbleではなく、フラットなデータフレームにするために使用されます。

df_sumデータフレームは、上記の操作の出力を格納することで作成されます。

summarise関数は、df_sumの全顧客のsum_amountの平均値を計算するために再び使用されます。

結果の mean_amount 値は $mean_amount を使って抽出される。

演算子%>%は、df_sumをチェーンの次の関数にパイプするために使用されます。

フィルター関数は、sum_amountがステップ7で計算されたmean_amount以上の行だけを選択するために使用される。

スライス関数は、元のデータフレームでの順序に基づいて、結果のデータフレームの上位10行のみを選択するために使用されます。

つまり、このコードは全体として、customer_idが "Z "で始まる行を除外するためのデータのフィルタリング、customer_idによるデータのグループ化、各顧客が使った合計金額の計算、全顧客の平均sum_amountの計算、使った合計金額が全顧客の平均金額以上の顧客のデータフレームの作成、使った合計金額に基づいて上位10顧客を選択することです。

R-036: レシート明細データ（df_receipt）と店舗データ（df_store）を内部結合し、レシート明細データの全項目と店舗データの店舗名（store_name）を10件表示せよ。

In [38]:

inner_join(df_receipt, df_store[c("store_cd", "store_name")], by = "store_cd") %>% slice(1:10)

A data.frame: 10 × 10

sales_ymd	sales_epoch	store_cd	receipt_no	receipt_sub_no	customer_id	product_cd	quantity	amount	store_name
<int>	<int>	<chr>	<int>	<int>	<chr>	<chr>	<int>	<int>	<chr>
20181103	1541203200	S14006	112	1	CS006214000001	P070305012	1	158	葛が谷店
20181118	1542499200	S13008	1132	2	CS008415000097	P070701017	1	81	成城店
20170712	1499817600	S14028	1102	1	CS028414000014	P060101005	1	170	二ツ橋店
20190205	1549324800	S14042	1132	1	ZZ000000000000	P050301001	1	25	新山下店
20180821	1534809600	S14025	1102	2	CS025415000050	P060102007	1	90	大和店
20190605	1559692800	S13003	1112	1	CS003515000195	P050102002	1	138	狛江店
20181205	1543968000	S14024	1102	2	CS024514000042	P080101005	1	30	三田店
20190922	1569110400	S14040	1102	1	CS040415000178	P070501004	1	128	長津田店
20170504	1493856000	S13020	1112	2	ZZ000000000000	P071302010	1	770	十条仲原店
20191010	1570665600	S14027	1102	1	CS027514000015	P071101003	1	680	南藤沢店

解説:

このコードは、df_receiptとdf_storeの2つのデータフレーム間で、共通の列「store_cd」に基づいて内部結合操作を実行します。この操作の結果はslice()関数に送られ、結果のデータフレームの最初の10行が選択されます。

それでは、コードをステップごとに分解してみましょう。

inner_join(df_receipt, df_store[c("store_cd", "store_name")], by = "store_cd"): これは、df_receiptデータフレームと、列 "store_cd "と "store_name "のみを含むdf_storeのサブセットとの間の内部結合を実行する。結合は、両方のデータフレームに存在する "store_cd "カラムに対して行われます。結果は、両方のデータフレームの "store_cd "カラムが一致するすべての行を含む新しいデータフレームとなります。

%>%: これはパイプ演算子で、前のコマンドの出力を受け取り、次のコマンドの入力としてパイプします。

slice(1:10):この関数は、前のコマンドで得られたデータフレームの最初の10行を選択します。

つまり、このコードの全体的な目的は、df_receiptとdf_storeのサブセット間の内部結合操作の結果の最初の10行を選択することです。結果のデータフレームは、両方のデータフレームの "store_cd "カラムが一致する行のみを含み、df_storeの "store_cd "と "store_name "カラムとdf_receiptのすべてのカラムを持つことになる。

R-037: 商品データ（df_product）とカテゴリデータ（df_category）を内部結合し、商品データの全項目とカテゴリデータのカテゴリ小区分名（category_small_name）を10件表示せよ。

In [39]:

inner_join(df_product, df_category[c("category_small_cd", "category_small_name")], by = "category_small_cd") %>% slice(1:10)

A data.frame: 10 × 7

product_cd	category_major_cd	category_medium_cd	category_small_cd	unit_price	unit_cost	category_small_name
<chr>	<chr>	<chr>	<chr>	<int>	<int>	<chr>
P040101001	04	0401	040101	198	149	弁当類
P040101002	04	0401	040101	218	164	弁当類
P040101003	04	0401	040101	230	173	弁当類
P040101004	04	0401	040101	248	186	弁当類
P040101005	04	0401	040101	268	201	弁当類
P040101006	04	0401	040101	298	224	弁当類
P040101007	04	0401	040101	338	254	弁当類
P040101008	04	0401	040101	420	315	弁当類
P040101009	04	0401	040101	498	374	弁当類
P040101010	04	0401	040101	580	435	弁当類

解説:

このコードは、df_productとdf_categoryの2つのデータフレーム間で、共通の列「category_small_cd」に基づいて内部結合操作を実行します。この操作の結果は、結果のデータ・フレームの最初の10行を選択するためにslice()関数にパイプされます。

それでは、コードをステップごとに分解してみましょう。

inner_join(df_product, df_category[c("category_small_cd", "category_small_name")], by = "category_small_cd"): これは、df_productデータフレームと、"category_small_cd "と "category_small_name "のカラムのみを含むdf_categoryのサブセット間の内部結合を実行する。結合は、両方のデータフレームに存在する "category_small_cd "カラムに対して行われます。結果は、両方のデータフレームの "category_small_cd "カラムが一致するすべての行を含む新しいデータフレームになります。

%>%: これはパイプ演算子で、前のコマンドの出力を受け取り、次のコマンドの入力としてパイプします。

slice(1:10) : この関数は、前のコマンドで得られたデータフレームの最初の10行を選択します。

つまり、このコードの全体的な目的は、df_productとdf_categoryのサブセット間の内部結合操作の結果の最初の10行を選択することです。結果のデータフレームは、両方のデータフレームの "category_small_cd "カラムが一致する行だけを含み、df_categoryの "category_small_cd "と "category_small_name "のカラムとdf_productのすべてのカラムを持つことになる。

R-038: 顧客データ（df_customer）とレシート明細データ（df_receipt）から、顧客ごとの売上金額合計を求め、10件表示せよ。ただし、売上実績がない顧客については売上金額を0として表示させること。また、顧客は性別コード（gender_cd）が女性（1）であるものを対象とし、非会員（顧客IDが”Z”から始まるもの）は除外すること。

In [40]:

df_sum <- df_receipt %>% 
 group_by(customer_id) %>% 
 summarise(sum_amount = sum(amount), .groups = "drop") 

df_target <- df_customer %>% 
 filter(gender_cd == "1" & !grepl("^Z", customer_id)) 

left_join(df_target["customer_id"], df_sum, by = "customer_id") %>% 
 replace_na(list(sum_amount = 0)) %>% slice(1:10)

A data.frame: 10 × 2

customer_id	sum_amount
<chr>	<dbl>
CS021313000114	0
CS031415000172	5088
CS028811000001	0
CS001215000145	875
CS015414000103	3122
CS033513000180	868
CS035614000014	0
CS011215000048	3444
CS009413000079	0
CS040412000191	210

解説:

このコードでは、顧客データの要約表を得るためにいくつかの処理を実行します。最後に、この結果をslice()関数に渡して、結果のデータフレームの最初の10行を選択します。

それでは、コードをステップごとに分解してみましょう。

df_sum <- df_receipt %>% group_by(customer_id) %>% summise(sum_amount = sum(amount), .groups = "drop"): このコードは、まずdf_receiptデータフレームを "customer_id "列でグループ化し、次にsum()関数を用いて "amount "列を要約しています。結果として得られるデータフレームdf_sumには、各顧客が使った金額の合計が含まれています。.groupsパラメータは、出力からグループ化情報を削除するために "drop "に設定されています。

df_target <- df_customer %>% filter(gender_cd == "1" & !grepl("^Z", customer_id)): このコードは、df_customerデータフレームをフィルタリングして、"gender_cd" カラムが "1" に等しく、"customer_id" カラムが文字 "Z" で始まらない行のみを含むようにします。その結果、データフレームdf_targetには、IDが "Z "で始まらない男性顧客のみが含まれます。

left_join(df_target["customer_id"], df_sum, by = "customer_id"): これは、df_target["customer_id"]とdf_sumの間で、"customer_id "列に基づいて左結合操作を実行する。結果は、df_targetのすべての行と、df_sumの各顧客が使用した対応する合計金額を含む新しいデータフレームになります。

replace_na(list(sum_amount = 0)): sum_amount "カラムの欠損値をデフォルトの0に置き換えます。

%>% slice(1:10): この関数は、前のコマンドで得られたデータフレームの最初の10行を選択します。

つまり、このコードの全体的な目的は、IDが "Z "で始まらない男性客が使った金額の合計の要約表を得ることです。出来上がったデータフレームは、"customer_id "と "sum_amount "という2つの列を持ち、"sum_amount "は各顧客が使った合計金額となります。sum_amount "列の欠損値はすべて0に置き換えられ、結果のデータフレームは最初の10行に限定される。

R-039: レシート明細データ（df_receipt）から、売上日数の多い顧客の上位20件を抽出したデータと、売上金額合計の多い顧客の上位20件を抽出したデータをそれぞれ作成し、さらにその2つを完全外部結合せよ。ただし、非会員（顧客IDが”Z”から始まるもの）は除外すること。

In [41]:

# コード例１
df_data <- df_receipt %>% 
 filter(!grepl("^Z", customer_id)) %>% 
 group_by(customer_id) 

df_cnt <- df_data %>% 
 summarise(come_days = n_distinct(sales_ymd), .groups = "drop") %>%
 arrange(desc(come_days), customer_id) %>% 
 slice(1:20) 

df_sum <- df_data %>% summarise(sum_amount = sum(amount), .groups = "drop") %>%
 arrange(desc(sum_amount)) %>% 
 slice(1:20) 

full_join(df_cnt, df_sum, by = "customer_id")
 

A tibble: 34 × 3

customer_id	come_days	sum_amount
<chr>	<int>	<int>
CS040214000008	23	NA
CS010214000010	22	18585
CS015415000185	22	20153
CS010214000002	21	NA
CS028415000007	21	19127
CS016415000141	20	18372
CS017415000097	20	23086
CS014214000023	19	NA
CS021514000045	19	NA
CS021515000172	19	NA
CS022515000226	19	NA
CS031414000051	19	19202
CS039414000052	19	NA
CS007515000107	18	NA
CS014415000077	18	NA
CS021515000056	18	NA
CS021515000211	18	NA
CS022515000028	18	NA
CS030214000008	18	NA
CS031414000073	18	NA
CS001605000009	NA	18925
CS006515000023	NA	18372
CS011414000106	NA	18338
CS038415000104	NA	17847
CS035414000024	NA	17615
CS021515000089	NA	17580
CS032414000072	NA	16563
CS016415000101	NA	16348
CS011415000006	NA	16094
CS034415000047	NA	16083
CS007514000094	NA	15735
CS009414000059	NA	15492
CS030415000034	NA	15468
CS015515000034	NA	15300

解説:

このコードは、顧客データの2つのサマリー・テーブルを取得するためにいくつかの操作を行い、"customer_id "カラムに基づいてこれら2つのテーブル間で完全結合操作を実行します。結果として得られるデータ・フレームには、販売日が最も明確な上位20人の顧客と、購入金額の合計が最も高い上位20人の顧客が含まれています。

それでは、コードをステップごとに分解してみましょう。

df_data <- df_receipt %>% filter(!grepl("^Z", customer_id)) %>% group_by(customer_id): このコードは、まずdf_receiptデータフレームをフィルタリングして、"customer_id "列が文字 "Z "で始まる行を除外します。その結果、データフレームは "customer_id "カラムによってグループ化されます。結果のdf_dataデータフレームは、df_receiptから "Z "の顧客IDを取り除いたすべての行を含み、"customer_id "でグループ化されています。

df_cnt <- df_data %>% summarise(come_days = n_distinct(sales_ymd), .groups = "drop") %>% arrange(desc(come_days), customer_id) %>% slice(1:20): このコードでは、まず、n_distinct()関数を使用して、各顧客の "sales_ymd" 値の数をカウントして、df_data データフレームを要約しています。結果として得られるデータフレームdf_cntは、各顧客のユニークな販売日の合計数を含んでいます。このデータフレームは、"come_days "の降順、"customer_id "の降順で並べられます。次に、slice()関数を使用して、結果のデータ・フレームの最初の20行を選択します。

df_sum <- df_data %>% summarise(sum_amount = sum(amount), .groups = "drop") %>% arrange(desc(sum_amount)) %>% slice(1:20): このコードは、sum()関数を使用して各顧客の「金額」列の合計を計算することにより、df_dataデータフレームを要約しています。結果として得られるデータフレームdf_sumには、各顧客が使った金額の合計が含まれています。次に、このデータフレームを "sum_amount" の降順に並べ、slice() 関数を使用して、結果のデータフレームの最初の 20 行を選択します。

full_join(df_cnt, df_sum, by = "customer_id"): このコードは、df_cntとdf_sumの間で、"customer_id "列に基づいて完全な結合操作を実行する。結果は、両方のデータフレームから "customer_id "でマッチしたすべての行を含む新しいデータフレームになります。結果として得られるデータフレームには、最も明確な販売日を持つ上位20人の顧客と、最も高い総消費額を持つ上位20人の顧客が含まれています。

つまり、このコードの全体的な目的は、顧客データの2つのサマリーテーブルを取得し、これら2つのテーブル間で完全結合操作を実行することです。結果として得られるデータフレームには、最も異なる販売日を持つ上位20人の顧客と、最も高い総支払額を持つ上位20人の顧客が含まれます。

In [42]:

# コード例2
# Code example using slice_max. 
# Rewrite with_ties = FALSE to with_ties = TRUE to change the form to include the same rank 

df_data <- df_receipt %>% 
 filter(!grepl("^Z", customer_id)) %>% 
 group_by(customer_id) 

df_cnt <- df_data %>% 
 summarise(come_days = n_distinct(sales_ymd)) %>% 
 slice_max(come_days, n = 20, with_ties = FALSE) 

df_sum <- df_data %>% 
 summarise(sum_amount = sum(amount)) %>% 
 slice_max(sum_amount, n = 20, with_ties = FALSE) 

full_join(df_cnt, df_sum, by = "customer_id")

A tibble: 34 × 3

customer_id	come_days	sum_amount
<chr>	<int>	<int>
CS040214000008	23	NA
CS010214000010	22	18585
CS015415000185	22	20153
CS010214000002	21	NA
CS028415000007	21	19127
CS016415000141	20	18372
CS017415000097	20	23086
CS014214000023	19	NA
CS021514000045	19	NA
CS021515000172	19	NA
CS022515000226	19	NA
CS031414000051	19	19202
CS039414000052	19	NA
CS007515000107	18	NA
CS014415000077	18	NA
CS021515000056	18	NA
CS021515000211	18	NA
CS022515000028	18	NA
CS030214000008	18	NA
CS031414000073	18	NA
CS001605000009	NA	18925
CS006515000023	NA	18372
CS011414000106	NA	18338
CS038415000104	NA	17847
CS035414000024	NA	17615
CS021515000089	NA	17580
CS032414000072	NA	16563
CS016415000101	NA	16348
CS011415000006	NA	16094
CS034415000047	NA	16083
CS007514000094	NA	15735
CS009414000059	NA	15492
CS030415000034	NA	15468
CS015515000034	NA	15300

解説:

このコードは前回説明したコードと似ていますが、arrange()関数の代わりにslice_max()関数を使い、販売日数と購入金額の合計から上位20名の顧客を取得します。

以下、コードの内訳を紹介します。

df_data <- df_receipt %>% filter(!grepl("^Z", customer_id)) %>% group_by(customer_id): このコードは前のコードと同様で、df_receiptデータフレームをフィルタリングして、"customer_id "列が文字 "Z "で始まる行を除外しています。その結果、データフレームは "customer_id "カラムによってグループ化されます。

df_cnt <- df_data %>% summarise(come_days = n_distinct(sales_ymd)) %>% slice_max(come_days, n = 20, with_ties = FALSE): このコードは、n_distinct()関数を使用して、各顧客の "sales_ymd "値の数をカウントすることにより、df_dataデータフレームを要約しています。結果のデータフレームdf_cntは、各顧客のユニークな販売日の合計数を含んでいます。slice_max()関数は、"come_days "列に基づいて上位20行を選択するために使用されます。

df_sum <- df_data %>% summarise(sum_amount = sum(amount)) %>% slice_max(sum_amount, n = 20, with_ties = FALSE): このコードは、sum()関数を使用して各顧客の "amount "列の合計を計算することにより、df_dataデータフレームを要約しています。結果として得られるデータフレームdf_sumには、各顧客が使った金額の合計が含まれています。slice_max()関数を使用して、"sum_amount "列に基づいて上位20行を選択します。with_ties = FALSEは、上位20個の異なる値のみを選択することを指定します。

full_join(df_cnt, df_sum, by = "customer_id"): このコードは、df_cntとdf_sumの間で、"customer_id "カラムに基づく完全な結合操作を実行する。結果は、両方のデータフレームから "customer_id "でマッチしたすべての行を含む新しいデータフレームになります。結果として得られるデータフレームには、最も明確な販売日を持つ上位20人の顧客と、最も高い総消費額を持つ上位20人の顧客が含まれています。

つまり、このコードの全体的な目的は、顧客データの2つのサマリーテーブルを取得し、これら2つのテーブル間で完全結合操作を実行することです。結果として得られるデータフレームには、最も異なる販売日を持つ上位20人の顧客と、最も高い総支払額を持つ上位20人の顧客が含まれ、arrange() 関数の代わりに slice_max() 関数を使用して取得します。

R-040: 全ての店舗と全ての商品を組み合わせたデータを作成したい。店舗データ（df_store）と商品データ（df_product）を直積し、件数を計算せよ。

In [43]:

df_store_tmp <- df_store 

df_product_tmp <- df_product 

df_store_tmp["key"] <- 0 

df_product_tmp["key"] <- 0 

nrow(full_join(df_store_tmp, df_product_tmp, by = "key"))

解説:

このコードは、df_storeとdf_productの両データフレームに追加された共通の「キー」列に基づいて、両データフレーム間の完全な結合処理を実行します。その後、結果のデータフレームを使用して、nrow()関数を使用して行数を計算します。

以下、コードの内訳を示します。

df_store_tmp <- df_store: このコードでは、df_store_tmpという新しいデータフレームを作成し、df_storeデータフレームのコピーとします。これは、元のデータ・フレームを変更しないようにするためです。

df_product_tmp <- df_product: このコードは、df_productデータ・フレームのコピーであるdf_product_tmpという新しいデータ・フレームを作成します。これは、元のデータフレームを変更しないようにするために行われます。

df_store_tmp["key"] <- 0: このコードはdf_store_tmpデータフレームに "key "という新しい列を追加し、すべての値をゼロに初期化します。このカラムは、結合操作のための共通カラムを提供するために追加されます。

df_product_tmp["key"] <- 0: このコードはdf_product_tmpデータフレームに "key "という新しい列を追加し、すべての値をゼロに初期化します。このカラムは、結合操作のための共通カラムを提供するために追加されます。

full_join(df_store_tmp, df_product_tmp, by = "key")。このコードは、共通の "key "列に基づいてdf_store_tmpとdf_product_tmpデータフレーム間の完全な結合操作を実行する。両データフレームはすべての行でこのカラムに同じ値を持つので、完全結合は2つのデータフレームのデカルト積となり、df_store_tmpのすべての行はdf_product_tmpのすべての行と対になることを意味します。

nrow(full_join(df_store_tmp, df_product_tmp, by = "key")): このコードは、nrow()関数を使用して、完全結合操作から得られるデータフレーム内の行数を計算します。結果は、df_storeとdf_product間の行の組み合わせの総数です。

要約すると、このコードはdf_storeとdf_productデータフレームのコピーを作成し、両方のデータフレームに共通の「キー」列を追加してすべての値をゼロに設定し、共通の「キー」列に基づいて2つのデータフレーム間で完全結合操作を実行し、結果の行数を計算する。このコードの目的は、df_storeとdf_productのデータフレーム間の行の組み合わせの総数を決定することである。