📋 このステップで学ぶこと
merge()の基本と4種類のJOIN(INNER、LEFT、RIGHT、OUTER)
concat()による縦・横連結
join()によるインデックスベースの結合
複数テーブルの結合戦略
結合時の注意点とベストプラクティス
実践演習:顧客データと注文データの統合
⏱️ 学習時間の目安: 2.5時間
📝 練習問題: 10問(基礎4問・応用4問・発展2問)
🎯 1. merge(マージ)の基本
1-1. mergeとは?
merge()は、SQLのJOINと同じ機能 で、2つのDataFrameを共通のカラム(キー) で結合します。
📚 例え話:2つの名簿を統合
生徒名簿A :名前、学年、クラス
部活名簿B :名前、部活動
この2つを「名前」で結合すれば → 名前、学年、クラス、部活動 の完全な名簿ができます!
これがmergeの考え方です。
1-2. 基本的なmerge
# ===== 基本的なmerge =====
import pandas as pd
# 左側のDataFrame(顧客情報)
df_customers = pd.DataFrame({
‘customer_id’: [1, 2, 3, 4],
‘name’: [‘山田太郎’, ‘佐藤花子’, ‘鈴木一郎’, ‘田中美咲’]
})
# 右側のDataFrame(注文情報)
df_orders = pd.DataFrame({
‘order_id’: [101, 102, 103],
‘customer_id’: [1, 2, 1],
‘amount’: [10000, 15000, 20000]
})
print(“=== 顧客テーブル ===”)
print(df_customers)
print(“\n=== 注文テーブル ===”)
print(df_orders)
# customer_idで結合
result = pd.merge(df_customers, df_orders, on=’customer_id’)
print(“\n=== merge結果 ===”)
print(result)
【実行結果】
=== 顧客テーブル ===
customer_id name
0 1 山田太郎
1 2 佐藤花子
2 3 鈴木一郎
3 4 田中美咲
=== 注文テーブル ===
order_id customer_id amount
0 101 1 10000
1 102 2 15000
2 103 1 20000
=== merge結果 ===
customer_id name order_id amount
0 1 山田太郎 101 10000
1 1 山田太郎 103 20000
2 2 佐藤花子 102 15000
✅ ポイント
山田太郎は2件の注文 があるので、結果も2行 になる
鈴木一郎と田中美咲は注文がないので、結果に含まれない (INNER JOINのため)
1-3. 4種類のJOIN(how引数)
結合方法はhow引数で指定します。SQLと同じ4種類があります。
# ===== 4種類のJOINを比較 =====
import pandas as pd
df_left = pd.DataFrame({
‘key’: [‘A’, ‘B’, ‘C’],
‘value_left’: [1, 2, 3]
})
df_right = pd.DataFrame({
‘key’: [‘B’, ‘C’, ‘D’],
‘value_right’: [4, 5, 6]
})
print(“=== 左側(df_left)===”)
print(df_left)
print(“\n=== 右側(df_right)===”)
print(df_right)
# 1. INNER JOIN(デフォルト)- 両方に存在するキーのみ
inner = pd.merge(df_left, df_right, on=’key’, how=’inner’)
print(“\n=== INNER JOIN ===”)
print(inner)
# 2. LEFT JOIN – 左側のすべてを残す
left = pd.merge(df_left, df_right, on=’key’, how=’left’)
print(“\n=== LEFT JOIN ===”)
print(left)
# 3. RIGHT JOIN – 右側のすべてを残す
right = pd.merge(df_left, df_right, on=’key’, how=’right’)
print(“\n=== RIGHT JOIN ===”)
print(right)
# 4. OUTER JOIN – 両方のすべてを残す
outer = pd.merge(df_left, df_right, on=’key’, how=’outer’)
print(“\n=== OUTER JOIN ===”)
print(outer)
【実行結果】
=== INNER JOIN ===
key value_left value_right
0 B 2 4
1 C 3 5
=== LEFT JOIN ===
key value_left value_right
0 A 1 NaN
1 B 2 4.0
2 C 3 5.0
=== RIGHT JOIN ===
key value_left value_right
0 B 2.0 4
1 C 3.0 5
2 D NaN 6
=== OUTER JOIN ===
key value_left value_right
0 A 1.0 NaN
1 B 2.0 4.0
2 C 3.0 5.0
3 D NaN 6.0
JOIN種類の比較
JOIN種類
説明
使いどころ
結果の行数
INNER
両方に存在するキーのみ
注文があった顧客だけ抽出
最小(共通部分のみ)
LEFT
左側はすべて残す
全顧客を表示(注文なしも含む)
左側と同じかそれ以上
RIGHT
右側はすべて残す
LEFT JOINの逆(あまり使わない)
右側と同じかそれ以上
OUTER
両方のすべてを残す
データの漏れをチェック
最大(全データ)
⚠️ 実務で最も使うのはLEFT JOIN
実務ではLEFT JOIN が最も使われます。
理由:「メインのデータ(左側)は全て残しつつ、追加情報(右側)を付与する」という使い方が多いから。
1-4. カラム名が異なる場合のmerge
# ===== left_on、right_onを使う =====
import pandas as pd
df_customers = pd.DataFrame({
‘customer_id’: [1, 2, 3],
‘name’: [‘山田’, ‘佐藤’, ‘鈴木’]
})
df_orders = pd.DataFrame({
‘order_id’: [101, 102],
‘cust_id’: [1, 2], # カラム名が違う!
‘amount’: [10000, 15000]
})
print(“=== 顧客テーブル(customer_id)===”)
print(df_customers)
print(“\n=== 注文テーブル(cust_id)===”)
print(df_orders)
# left_on と right_on で異なるカラム名を指定
result = pd.merge(
df_customers,
df_orders,
left_on=’customer_id’,
right_on=’cust_id’,
how=’left’
)
print(“\n=== merge結果 ===”)
print(result)
【実行結果】
=== merge結果 ===
customer_id name order_id cust_id amount
0 1 山田 101.0 1.0 10000.0
1 2 佐藤 102.0 2.0 15000.0
2 3 鈴木 NaN NaN NaN
1-5. 複数カラムでmerge
# ===== 複数のキーで結合 =====
import pandas as pd
# 月次売上データ
df_sales = pd.DataFrame({
‘year’: [2024, 2024, 2024],
‘month’: [1, 2, 3],
‘sales’: [100, 120, 130]
})
# 月次コストデータ
df_cost = pd.DataFrame({
‘year’: [2024, 2024, 2024],
‘month’: [1, 2, 3],
‘cost’: [80, 90, 95]
})
print(“=== 売上データ ===”)
print(df_sales)
print(“\n=== コストデータ ===”)
print(df_cost)
# year と month の両方で結合
result = pd.merge(df_sales, df_cost, on=[‘year’, ‘month’])
# 利益を計算
result[‘profit’] = result[‘sales’] – result[‘cost’]
print(“\n=== merge結果 ===”)
print(result)
【実行結果】
=== merge結果 ===
year month sales cost profit
0 2024 1 100 80 20
1 2024 2 120 90 30
2 2024 3 130 95 35
📚 2. concat(連結)
2-1. concatとは?
concat()は、DataFrameを縦または横に連結 します。
mergeと違い、共通のカラム(キー)は不要 です。
📝 merge と concat の違い
merge :共通のキーで結合(SQLのJOIN)
concat :単純に連結(積み重ねる・並べる)
2-2. 縦方向の連結(axis=0)
# ===== データを縦に積み重ねる =====
import pandas as pd
# 1月のデータ
df_jan = pd.DataFrame({
‘date’: [‘2024-01-01’, ‘2024-01-02’],
‘sales’: [10000, 12000]
})
# 2月のデータ
df_feb = pd.DataFrame({
‘date’: [‘2024-02-01’, ‘2024-02-02’],
‘sales’: [15000, 18000]
})
# 3月のデータ
df_mar = pd.DataFrame({
‘date’: [‘2024-03-01’, ‘2024-03-02’],
‘sales’: [20000, 22000]
})
print(“=== 1月 ===”)
print(df_jan)
print(“\n=== 2月 ===”)
print(df_feb)
print(“\n=== 3月 ===”)
print(df_mar)
# 縦に連結(デフォルト axis=0)
result = pd.concat([df_jan, df_feb, df_mar])
print(“\n=== concat結果(インデックスそのまま)===”)
print(result)
# インデックスをリセット
result_reset = pd.concat([df_jan, df_feb, df_mar], ignore_index=True)
print(“\n=== concat結果(インデックスリセット)===”)
print(result_reset)
【実行結果】
=== concat結果(インデックスそのまま)===
date sales
0 2024-01-01 10000
1 2024-01-02 12000
0 2024-02-01 15000
1 2024-02-02 18000
0 2024-03-01 20000
1 2024-03-02 22000
=== concat結果(インデックスリセット)===
date sales
0 2024-01-01 10000
1 2024-01-02 12000
2 2024-02-01 15000
3 2024-02-02 18000
4 2024-03-01 20000
5 2024-03-02 22000
✅ ignore_index=True を使おう
縦に連結するときはignore_index=Trueを付けると、インデックスが0から振り直されます。
これを忘れると、インデックスが重複して後で困ることがあります。
2-3. 横方向の連結(axis=1)
# ===== データを横に並べる =====
import pandas as pd
df_sales = pd.DataFrame({
‘product’: [‘A’, ‘B’, ‘C’],
‘sales’: [100, 120, 130]
})
df_cost = pd.DataFrame({
‘cost’: [80, 90, 95]
})
print(“=== 売上データ ===”)
print(df_sales)
print(“\n=== コストデータ ===”)
print(df_cost)
# 横に連結(axis=1)
result = pd.concat([df_sales, df_cost], axis=1)
print(“\n=== concat結果(横連結)===”)
print(result)
【実行結果】
=== concat結果(横連結)===
product sales cost
0 A 100 80
1 B 120 90
2 C 130 95
2-4. カラムが異なるDataFrameを連結
# ===== カラムが一致しない場合 =====
import pandas as pd
df1 = pd.DataFrame({
‘A’: [1, 2],
‘B’: [3, 4]
})
df2 = pd.DataFrame({
‘B’: [5, 6],
‘C’: [7, 8]
})
print(“=== df1(A, B)===”)
print(df1)
print(“\n=== df2(B, C)===”)
print(df2)
# カラムが一致しない部分はNaNになる
result = pd.concat([df1, df2], ignore_index=True)
print(“\n=== concat結果 ===”)
print(result)
# NaNを0で埋める
result_filled = result.fillna(0).astype(int)
print(“\n=== NaNを0で埋めた結果 ===”)
print(result_filled)
【実行結果】
=== concat結果 ===
A B C
0 1.0 3 NaN
1 2.0 4 NaN
2 NaN 5 7.0
3 NaN 6 8.0
=== NaNを0で埋めた結果 ===
A B C
0 1 3 0
1 2 4 0
2 0 5 7
3 0 6 8
2-5. キーを付けて連結(どこから来たか識別)
# ===== keysでデータの出所を識別 =====
import pandas as pd
df_tokyo = pd.DataFrame({
‘name’: [‘山田’, ‘佐藤’],
‘sales’: [100, 120]
})
df_osaka = pd.DataFrame({
‘name’: [‘鈴木’, ‘田中’],
‘sales’: [130, 140]
})
print(“=== 東京支店 ===”)
print(df_tokyo)
print(“\n=== 大阪支店 ===”)
print(df_osaka)
# keysで識別子を付ける
result = pd.concat(
[df_tokyo, df_osaka],
keys=[‘東京’, ‘大阪’]
)
print(“\n=== concat結果(keys付き)===”)
print(result)
# 特定の支店だけ取り出す
print(“\n=== 東京支店だけ取り出す ===”)
print(result.loc[‘東京’])
【実行結果】
=== concat結果(keys付き)===
name sales
東京 0 山田 100
1 佐藤 120
大阪 0 鈴木 130
1 田中 140
=== 東京支店だけ取り出す ===
name sales
0 山田 100
1 佐藤 120
🔑 3. join(ジョイン)
3-1. joinとは?
join()は、インデックスを使って結合 します。
mergeの簡易版で、インデックスがキーになっている場合に便利です。
# ===== 基本的なjoin =====
import pandas as pd
# インデックスを設定したDataFrame
df_left = pd.DataFrame({
‘A’: [1, 2, 3]
}, index=[‘a’, ‘b’, ‘c’])
df_right = pd.DataFrame({
‘B’: [4, 5, 6]
}, index=[‘a’, ‘b’, ‘d’])
print(“=== 左側(df_left)===”)
print(df_left)
print(“\n=== 右側(df_right)===”)
print(df_right)
# インデックスで結合(デフォルトはLEFT JOIN)
result = df_left.join(df_right)
print(“\n=== join結果(LEFT)===”)
print(result)
# INNER JOIN
result_inner = df_left.join(df_right, how=’inner’)
print(“\n=== join結果(INNER)===”)
print(result_inner)
# OUTER JOIN
result_outer = df_left.join(df_right, how=’outer’)
print(“\n=== join結果(OUTER)===”)
print(result_outer)
【実行結果】
=== join結果(LEFT)===
A B
a 1 4.0
b 2 5.0
c 3 NaN
=== join結果(INNER)===
A B
a 1 4
b 2 5
=== join結果(OUTER)===
A B
a 1.0 4.0
b 2.0 5.0
c 3.0 NaN
d NaN 6.0
3-2. merge / concat / join の使い分け
3つの結合メソッドの比較
メソッド
結合方法
使いどころ
推奨度
merge
カラムで結合
SQLのJOINと同じ感覚で使える
★★★(最も使う)
concat
縦・横に連結
月次データを積み重ねるなど
★★★(よく使う)
join
インデックスで結合
インデックスがキーの場合
★☆☆(あまり使わない)
💡 実務では merge と concat を覚えればOK
merge :共通のキーで結合する場合(ほとんどのケース)
concat :単純に連結する場合(月次データの結合など)
joinはmergeで代替できるので、覚えなくても問題ありません。
🔧 4. 複数テーブルの結合戦略
4-1. 3つ以上のテーブルを結合
# ===== 複数のmergeを連続で実行 =====
import pandas as pd
# 顧客情報
df_customers = pd.DataFrame({
‘customer_id’: [1, 2, 3],
‘name’: [‘山田’, ‘佐藤’, ‘鈴木’]
})
# 注文情報
df_orders = pd.DataFrame({
‘order_id’: [101, 102, 103],
‘customer_id’: [1, 2, 1],
‘product_id’: [1001, 1002, 1001]
})
# 商品情報
df_products = pd.DataFrame({
‘product_id’: [1001, 1002, 1003],
‘product_name’: [‘ノートPC’, ‘マウス’, ‘キーボード’],
‘price’: [89800, 1980, 4500]
})
print(“=== 顧客テーブル ===”)
print(df_customers)
print(“\n=== 注文テーブル ===”)
print(df_orders)
print(“\n=== 商品テーブル ===”)
print(df_products)
# 方法1: 段階的にmerge
print(“\n=== 段階的にmerge ===”)
step1 = pd.merge(df_orders, df_customers, on=’customer_id’)
print(“ステップ1(注文+顧客):”)
print(step1)
result = pd.merge(step1, df_products, on=’product_id’)
print(“\nステップ2(+商品):”)
print(result)
4-2. メソッドチェーンで結合
# ===== mergeを連鎖させる(より簡潔)=====
import pandas as pd
# (上記のデータを使用)
# メソッドチェーンで一気に結合
result = (df_orders
.merge(df_customers, on=’customer_id’)
.merge(df_products, on=’product_id’)
)
print(“=== メソッドチェーンでmerge ===”)
print(result)
✅ メソッドチェーンのメリット
コードが読みやすい
中間変数が不要
処理の流れが明確
4-3. 結合時の注意点
⚠️ 結合で行数が増える・減るケース
行数が増える :1対多の関係(1人の顧客に複数の注文)
行数が減る :INNER JOINでキーが一致しないデータがある
NaNが増える :LEFT/OUTER JOINでキーが一致しない
対策 :結合前後で必ず行数を確認する!
# ===== 結合前後の行数確認 =====
import pandas as pd
df_customers = pd.DataFrame({
‘customer_id’: [1, 2, 3],
‘name’: [‘山田’, ‘佐藤’, ‘鈴木’]
})
df_orders = pd.DataFrame({
‘order_id’: [101, 102, 103, 104],
‘customer_id’: [1, 1, 2, 4], # customer_id=4は顧客テーブルにない
‘amount’: [10000, 20000, 15000, 5000]
})
print(f”顧客テーブル: {len(df_customers)}行”)
print(f”注文テーブル: {len(df_orders)}行”)
# INNER JOIN
inner = pd.merge(df_customers, df_orders, on=’customer_id’, how=’inner’)
print(f”\nINNER JOIN後: {len(inner)}行(customer_id=4は除外される)”)
# LEFT JOIN
left = pd.merge(df_customers, df_orders, on=’customer_id’, how=’left’)
print(f”LEFT JOIN後: {len(left)}行(鈴木はNaN、customer_id=4は除外)”)
# OUTER JOIN
outer = pd.merge(df_customers, df_orders, on=’customer_id’, how=’outer’)
print(f”OUTER JOIN後: {len(outer)}行(全データ)”)
print(“\n=== OUTER JOIN結果 ===”)
print(outer)
🏋️ 5. 実践演習:ECサイトのデータ統合
5-1. 課題:複数システムのデータを統合
顧客管理システム、注文システム、商品マスタの3つのシステムのデータ を統合して、分析用のデータセットを作成します。
# ===== ECサイトの完全なデータ統合 =====
import pandas as pd
import numpy as np
# ========== データ準備 ==========
# 顧客マスタ(CRMシステム)
customers = pd.DataFrame({
‘customer_id’: [1, 2, 3, 4, 5],
‘customer_name’: [‘山田太郎’, ‘佐藤花子’, ‘鈴木一郎’, ‘田中美咲’, ‘高橋健太’],
‘email’: [‘yamada@ex.com’, ‘sato@ex.com’, ‘suzuki@ex.com’,
‘tanaka@ex.com’, ‘takahashi@ex.com’],
‘city’: [‘東京’, ‘大阪’, ‘福岡’, ‘東京’, ‘名古屋’],
‘registration_date’: [‘2023-01-15’, ‘2023-02-20’, ‘2023-03-10’,
‘2023-04-05’, ‘2023-05-12’]
})
# 注文データ(注文システム)
orders = pd.DataFrame({
‘order_id’: [101, 102, 103, 104, 105, 106, 107],
‘customer_id’: [1, 2, 1, 3, 2, 4, 1],
‘product_id’: [1001, 1002, 1003, 1001, 1002, 1003, 1001],
‘quantity’: [2, 1, 3, 1, 2, 1, 1],
‘order_date’: [‘2024-01-10’, ‘2024-01-12’, ‘2024-01-15’,
‘2024-01-18’, ‘2024-01-20’, ‘2024-01-22’, ‘2024-01-25’]
})
# 商品マスタ
products = pd.DataFrame({
‘product_id’: [1001, 1002, 1003, 1004],
‘product_name’: [‘ノートPC’, ‘マウス’, ‘キーボード’, ‘モニター’],
‘category’: [‘PC’, ‘周辺機器’, ‘周辺機器’, ‘周辺機器’],
‘price’: [89800, 1980, 4500, 25000]
})
print(“=” * 60)
print(“データ統合開始”)
print(“=” * 60)
print(f”\n顧客テーブル: {len(customers)}行”)
print(f”注文テーブル: {len(orders)}行”)
print(f”商品テーブル: {len(products)}行”)
# ========== ステップ1: 注文データに商品情報を追加 ==========
print(“\n【ステップ1】注文データ + 商品情報”)
step1 = pd.merge(orders, products, on=’product_id’, how=’left’)
print(f”結合後の行数: {len(step1)}行”)
# ========== ステップ2: 顧客情報を追加 ==========
print(“\n【ステップ2】ステップ1 + 顧客情報”)
step2 = pd.merge(step1, customers, on=’customer_id’, how=’left’)
print(f”結合後の行数: {len(step2)}行”)
# ========== ステップ3: データ加工 ==========
print(“\n【ステップ3】データ加工”)
# 日付型に変換
step2[‘order_date’] = pd.to_datetime(step2[‘order_date’])
step2[‘registration_date’] = pd.to_datetime(step2[‘registration_date’])
# 売上金額を計算
step2[‘total_amount’] = step2[‘price’] * step2[‘quantity’]
# 年月を追加(集計用)
step2[‘year_month’] = step2[‘order_date’].dt.to_period(‘M’)
print(” → 日付変換、売上金額計算、年月追加 完了”)
# ========== ステップ4: 集計 ==========
print(“\n【ステップ4】集計処理”)
# 顧客別の集計
customer_summary = step2.groupby(‘customer_name’).agg({
‘order_id’: ‘count’, # 注文回数
‘total_amount’: ‘sum’, # 合計購入金額
‘order_date’: ‘max’ # 最終購入日
}).rename(columns={
‘order_id’: ‘注文回数’,
‘total_amount’: ‘合計購入金額’,
‘order_date’: ‘最終購入日’
}).sort_values(‘合計購入金額’, ascending=False)
# 商品別の集計
product_summary = step2.groupby(‘product_name’).agg({
‘quantity’: ‘sum’, # 販売数量
‘total_amount’: ‘sum’ # 売上金額
}).rename(columns={
‘quantity’: ‘販売数量’,
‘total_amount’: ‘売上金額’
}).sort_values(‘売上金額’, ascending=False)
# ========== 結果表示 ==========
print(“\n” + “=” * 60)
print(“統合完了”)
print(“=” * 60)
print(“\n【統合データ(最初の5行)】”)
print(step2[[‘order_id’, ‘customer_name’, ‘product_name’,
‘quantity’, ‘price’, ‘total_amount’, ‘city’]].head())
print(“\n【顧客別集計】”)
print(customer_summary)
print(“\n【商品別集計】”)
print(product_summary)
print(f”\n総売上: {step2[‘total_amount’].sum():,}円”)
【実行結果】
============================================================
データ統合開始
============================================================
顧客テーブル: 5行
注文テーブル: 7行
商品テーブル: 4行
【ステップ1】注文データ + 商品情報
結合後の行数: 7行
【ステップ2】ステップ1 + 顧客情報
結合後の行数: 7行
【ステップ3】データ加工
→ 日付変換、売上金額計算、年月追加 完了
【ステップ4】集計処理
============================================================
統合完了
============================================================
【顧客別集計】
注文回数 合計購入金額 最終購入日
customer_name
山田太郎 3 283100 2024-01-25
佐藤花子 2 5940 2024-01-20
鈴木一郎 1 89800 2024-01-18
田中美咲 1 4500 2024-01-22
【商品別集計】
販売数量 売上金額
product_name
ノートPC 4 359200
キーボード 4 18000
マウス 3 5940
総売上: 383,140円
📝 STEP 10 のまとめ
✅ このステップで学んだこと
merge() :共通のカラムで結合(SQLのJOINと同じ)
JOIN種類 :INNER(共通部分)、LEFT(左を全て残す)、RIGHT、OUTER(全て残す)
concat() :DataFrameを縦または横に連結
join() :インデックスで結合
複数テーブル結合 :mergeをチェーンさせる
結合の注意点 :行数の変化、NaNの発生を確認
💡 データ結合のベストプラクティス
結合前に件数確認 :元のデータの行数を把握
結合後に件数確認 :予期しない増減がないかチェック
キーの重複を確認 :1対多、多対多の関係に注意
欠損値を確認 :結合できなかったデータを調査
適切なJOIN種類を選択 :ほとんどの場合はLEFT JOIN
🎯 次のステップの予告
次のSTEP 11では、「集計と集約」 を学びます。
groupby()によるグループ集計
pivot_table()によるクロス集計
時系列データの集約
実践演習:売上レポートの作成
📝 練習問題
問題 1
基礎
df_customersとdf_ordersをcustomer_idで結合してください(INNER JOIN)。
解答を見る
【解答例】
result = pd.merge(df_customers, df_orders, on=’customer_id’)
# または
result = pd.merge(df_customers, df_orders, on=’customer_id’, how=’inner’)
問題 2
基礎
df_customersとdf_ordersをLEFT JOINで結合してください(顧客情報を全て残す)。
解答を見る
【解答例】
result = pd.merge(df_customers, df_orders, on=’customer_id’, how=’left’)
問題 3
基礎
df_jan、df_feb、df_marを縦に連結してください(インデックスをリセット)。
解答を見る
【解答例】
result = pd.concat([df_jan, df_feb, df_mar], ignore_index=True)
問題 4
基礎
df_salesとdf_costを横に連結してください。
解答を見る
【解答例】
result = pd.concat([df_sales, df_cost], axis=1)
問題 5
応用
左側のカラム名がcustomer_id、右側のカラム名がcust_idの場合の結合コードを書いてください。
解答を見る
【解答例】
result = pd.merge(
df_customers,
df_orders,
left_on=’customer_id’,
right_on=’cust_id’,
how=’left’
)
問題 6
応用
yearとmonthの2つのカラムで結合してください。
解答を見る
【解答例】
result = pd.merge(df_sales, df_cost, on=[‘year’, ‘month’])
問題 7
応用
3つのDataFrame(df_orders、df_customers、df_products)をメソッドチェーンで結合してください。
解答を見る
【解答例】
result = (df_orders
.merge(df_customers, on=’customer_id’)
.merge(df_products, on=’product_id’)
)
問題 8
応用
東京支店と大阪支店のデータを縦に連結し、keysで支店名を付けてください。
解答を見る
【解答例】
result = pd.concat(
[df_tokyo, df_osaka],
keys=[‘東京’, ‘大阪’]
)
問題 9
発展
OUTER JOINを使い、結合できなかったデータ(NaNがある行)だけを抽出してください。
解答を見る
【解答例】
# OUTER JOINで結合
result = pd.merge(df_customers, df_orders, on=’customer_id’, how=’outer’)
# NaNがある行を抽出
unmatched = result[result.isnull().any(axis=1)]
print(unmatched)
問題 10
発展
以下の処理を行うコードを書いてください:
① df_ordersとdf_customersをLEFT JOINで結合
② df_productsをさらに結合
③ total_amount(price × quantity)を計算
④ 顧客別の合計購入金額を集計
解答を見る
【解答例】
import pandas as pd
# ① ② 結合
result = (df_orders
.merge(df_customers, on=’customer_id’, how=’left’)
.merge(df_products, on=’product_id’, how=’left’)
)
# ③ 売上金額を計算
result[‘total_amount’] = result[‘price’] * result[‘quantity’]
# ④ 顧客別の合計購入金額を集計
customer_summary = result.groupby(‘customer_name’)[‘total_amount’].sum()
print(customer_summary)