Pandas

[Python] Pandas – 2つのDataFrameを結合する方法

2025-01-18更新日: 2025-01-18

Pandasでは、2つのDataFrameを結合する方法として主にmerge、join、concatの3つがあります。

mergeはSQLのJOINに似た操作で、共通の列を基に結合します。

joinはインデックスを基に結合し、concatは縦または横にDataFrameを連結します。

mergeではhow引数で結合方法(‘inner’, ‘outer’, ‘left’, ‘right’)を指定できます。

concatではaxis引数で縦axis=0か横axis=1かを指定します。

目次から探す

mergeを使ったDataFrameの結合
joinを使ったDataFrameの結合
concatを使ったDataFrameの結合
応用例：複雑な結合操作
まとめ

mergeを使ったDataFrameの結合

mergeの基本的な使い方

merge関数は、2つのDataFrameを特定のキーに基づいて結合するために使用されます。

基本的な構文は以下の通りです。

import pandas as pd
# DataFrameの作成
df1 = pd.DataFrame({
    'キー': [1, 2, 3],
    '値1': ['A', 'B', 'C']
})
df2 = pd.DataFrame({
    'キー': [2, 3, 4],
    '値2': ['D', 'E', 'F']
})
# DataFrameの結合
result = pd.merge(df1, df2, on='キー')
print(result)

   キー 値1 値2
0   2  B  D
1   3  C  E

この例では、df1とdf2をキー列を基に結合しています。

how引数による結合方法の指定

merge関数では、how引数を使って結合の方法を指定できます。

以下の4つの方法があります。

結合方法	説明
inner	両方のDataFrameに存在するキーのみを含む
outer	両方のDataFrameのすべてのキーを含む
left	左側のDataFrameのすべてのキーを含む
right	右側のDataFrameのすべてのキーを含む

内部結合(how=’inner’)

内部結合は、両方のDataFrameに存在するキーのみを含む結合です。

result_inner = pd.merge(df1, df2, on='キー', how='inner')
print(result_inner)

キー 値1 値2
0   2  B  D
1   3  C  E

外部結合(how=’outer’)

外部結合は、両方のDataFrameのすべてのキーを含む結合です。

result_outer = pd.merge(df1, df2, on='キー', how='outer')
print(result_outer)

キー 値1 値2
0   1  A  NaN
1   2  B  D
2   3  C  E
3   4 NaN  F

左結合(how=’left’)

左結合は、左側のDataFrameのすべてのキーを含む結合です。

result_left = pd.merge(df1, df2, on='キー', how='left')
print(result_left)

キー 値1 値2
0   1  A  NaN
1   2  B  D
2   3  C  E

右結合(how=’right’)

右結合は、右側のDataFrameのすべてのキーを含む結合です。

result_right = pd.merge(df1, df2, on='キー', how='right')
print(result_right)

キー 値1 値2
0   2  B  D
1   3  C  E
2   4 NaN  F

on引数で結合キーを指定する

on引数を使用して、結合に使用する列を指定できます。

デフォルトでは、同じ名前の列が使用されますが、異なる名前の列を指定することも可能です。

df3 = pd.DataFrame({
    '異なるキー': [2, 3, 4],
    '値2': ['D', 'E', 'F']
})
result_custom_key = pd.merge(df1, df3, left_on='キー', right_on='異なるキー')
print(result_custom_key)

キー 値1  異なるキー 値2
0   2  B          2  D
1   3  C          3  E

複数の列をキーにして結合する

複数の列をキーにして結合することも可能です。

on引数にリストを渡すことで実現できます。

df4 = pd.DataFrame({
    'キー1': [1, 2, 3],
    'キー2': ['A', 'B', 'C'],
    '値': [10, 20, 30]
})
df5 = pd.DataFrame({
    'キー1': [2, 3, 4],
    'キー2': ['B', 'C', 'D'],
    '値': [40, 50, 60]
})
result_multi_key = pd.merge(df4, df5, on=['キー1', 'キー2'])
print(result_multi_key)

   キー1 キー2  値_x  値_y
0    2   B   20   40
1    3   C   30   50

結合後の列名の重複を解消する方法

結合後に同じ名前の列が存在する場合、suffixes引数を使って接尾辞を追加することができます。

result_suffix = pd.merge(df4, df5, on='キー1', suffixes=('_左', '_右'))
print(result_suffix)

キー1 キー2_左  値_左 キー2_右  値_右
0   2   B   20   B   40
1   3   C   30   C   50

このように、suffixes引数を使うことで、重複した列名を区別することができます。

joinを使ったDataFrameの結合

joinの基本的な使い方

joinメソッドは、主にインデックスを基にしてDataFrameを結合するために使用されます。

基本的な構文は以下の通りです。

import pandas as pd
# DataFrameの作成
df1 = pd.DataFrame({
    '値1': ['A', 'B', 'C']
}, index=[1, 2, 3])
df2 = pd.DataFrame({
    '値2': ['D', 'E', 'F']
}, index=[2, 3, 4])
# DataFrameの結合
result = df1.join(df2)
print(result)

  値1   値2
1  A  NaN
2  B    D
3  C    E

この例では、df1とdf2をインデックスを基に結合しています。

インデックスを基にした結合

joinメソッドは、デフォルトで左側のDataFrameのインデックスを基に結合を行います。

右側のDataFrameのインデックスが一致する場合にデータが結合されます。

# インデックスを基にした結合
result_index = df1.join(df2, how='inner')
print(result_index)

  値1 値2
2  B   D
3  C   E

この例では、両方のDataFrameに存在するインデックスのみが含まれています。

how引数による結合方法の指定

joinメソッドでも、how引数を使用して結合の方法を指定できます。

以下の4つの方法があります。

結合方法	説明
inner	両方のDataFrameに存在するインデックスのみを含む
outer	両方のDataFrameのすべてのインデックスを含む
left	左側のDataFrameのすべてのインデックスを含む
right	右側のDataFrameのすべてのインデックスを含む

左結合

左結合は、左側のDataFrameのすべてのインデックスを含む結合です。

result_left_join = df1.join(df2, how='left')
print(result_left_join)

  値1 値2
1  A NaN
2  B   D
3  C NaN

右結合

右結合は、右側のDataFrameのすべてのインデックスを含む結合です。

result_right_join = df1.join(df2, how='right')
print(result_right_join)

  値1 値2
2  B   D
3  C   E
4 NaN   F

外部結合

外部結合は、両方のDataFrameのすべてのインデックスを含む結合です。

result_outer_join = df1.join(df2, how='outer')
print(result_outer_join)

  値1 値2
1  A NaN
2  B   D
3  C   E
4 NaN   F

複数のDataFrameをjoinで結合する

複数のDataFrameをjoinメソッドで結合することも可能です。

joinメソッドは、連続して呼び出すことで複数のDataFrameを結合できます。

df3 = pd.DataFrame({
    '値3': ['G', 'H', 'I']
}, index=[3, 4, 5])
# 複数のDataFrameを結合
result_multiple_join = df1.join([df2, df3])
print(result_multiple_join)

  値1 値2 値3
1  A NaN NaN
2  B   D NaN
3  C   E   G
4 NaN   F   H
5 NaN NaN   I

このように、joinメソッドを使うことで、複数のDataFrameを簡単に結合することができます。

concatを使ったDataFrameの結合

concatの基本的な使い方

concat関数は、複数のDataFrameを結合するために使用されます。

基本的な構文は以下の通りです。

import pandas as pd
# DataFrameの作成
df1 = pd.DataFrame({
    '値': ['A', 'B', 'C']
})
df2 = pd.DataFrame({
    '値': ['D', 'E', 'F']
})
# DataFrameの結合
result = pd.concat([df1, df2])
print(result)

   値
0  A
1  B
2  C
0  D
1  E
2  F

この例では、df1とdf2を縦に結合しています。

縦方向の結合(axis=0)

デフォルトでは、concatは縦方向にDataFrameを結合します。

axis=0を指定することで、明示的に縦方向の結合を行うことができます。

result_vertical = pd.concat([df1, df2], axis=0)
print(result_vertical)

値
0  A
1  B
2  C
0  D
1  E
2  F

横方向の結合(axis=1)

横方向にDataFrameを結合するには、axis=1を指定します。

この場合、行数が異なるDataFrameを結合することも可能です。

df3 = pd.DataFrame({
    '値2': ['G', 'H']
})
result_horizontal = pd.concat([df1, df3], axis=1)
print(result_horizontal)

   値 値2
0  A  G
1  B  H
2  C NaN

この例では、df1とdf3を横に結合しています。

行数が異なるため、NaNが追加されています。

インデックスの再設定(ignore_index)

結合後にインデックスを再設定したい場合は、ignore_index=Trueを指定します。

これにより、インデックスが0から始まる連続した整数にリセットされます。

result_reset_index = pd.concat([df1, df2], ignore_index=True)
print(result_reset_index)

   値
0  A
1  B
2  C
3  D
4  E
5  F

重複するデータの処理(verify_integrity)

concat関数では、結合後に重複するインデックスが存在するかどうかを確認するために、verify_integrity=Trueを指定することができます。

このオプションを使用すると、重複がある場合にエラーが発生します。

df4 = pd.DataFrame({
    '値': ['A', 'B', 'C']
}, index=[0, 1, 1])  # 重複したインデックス
try:
    result_verify = pd.concat([df1, df4], verify_integrity=True)
except ValueError as e:
    print(e)

Index has duplicates.

このように、verify_integrityを使用することで、重複したインデックスがある場合にエラーを検出することができます。

応用例：複雑な結合操作

複数のDataFrameを一度に結合する

複数のDataFrameを一度に結合するには、concat関数を使用します。

リストに複数のDataFrameを渡すことで、簡単に結合できます。

import pandas as pd
# DataFrameの作成
df1 = pd.DataFrame({'キー': [1, 2], '値1': ['A', 'B']})
df2 = pd.DataFrame({'キー': [2, 3], '値2': ['C', 'D']})
df3 = pd.DataFrame({'キー': [3, 4], '値3': ['E', 'F']})
# 複数のDataFrameを結合
result_multiple = pd.concat([df1, df2, df3], ignore_index=True)
print(result_multiple)

   キー   値1   値2   値3
0   1    A  NaN  NaN
1   2    B  NaN  NaN
2   2  NaN    C  NaN
3   3  NaN    D  NaN
4   3  NaN  NaN    E
5   4  NaN  NaN    F

条件付きでDataFrameを結合する

条件付きでDataFrameを結合するには、merge関数を使用し、on引数やhow引数を適切に設定します。

例えば、特定の条件を満たす行のみを結合することができます。

df4 = pd.DataFrame({'キー': [1, 2, 3], '値': ['A', 'B', 'C']})
df5 = pd.DataFrame({'キー': [2, 3, 4], '値': ['D', 'E', 'F']})
# 条件付きで結合
result_condition = pd.merge(df4, df5, on='キー', how='inner')
print(result_condition)

   キー 値_x 値_y
0   2   B   D
1   3   C   E

結合後にデータをフィルタリングする

結合後に特定の条件に基づいてデータをフィルタリングすることも可能です。

例えば、特定の列の値が特定の条件を満たす行のみを抽出します。

df6 = pd.DataFrame({'キー': [1, 2, 3], '値': ['A', 'B', 'C']})
df7 = pd.DataFrame({'キー': [2, 3, 4], '値': ['D', 'E', 'F']})
# DataFrameを結合
result_joined = pd.merge(df6, df7, on='キー', how='outer')
# 結合後にフィルタリング
filtered_result = result_joined[result_joined['値_x'] == 'B']
print(filtered_result)

   キー 値_x 値_y
1   2  B   D

結合後に新しい列を追加する

結合後に新しい列を追加することもできます。

例えば、結合したDataFrameに計算結果を新しい列として追加します。

df8 = pd.DataFrame({'キー': [1, 2], '値1': [10, 20]})
df9 = pd.DataFrame({'キー': [2, 3], '値2': [30, 40]})
# DataFrameを結合
result_combined = pd.merge(df8, df9, on='キー', how='outer')
# 新しい列を追加
result_combined['合計'] = result_combined['値1'].fillna(0) + result_combined['値2'].fillna(0)
print(result_combined)

   キー    値1    値2    合計
0   1  10.0   NaN  10.0
1   2  20.0  30.0  50.0
2   3   NaN  40.0  40.0

結合後のデータを集計する

結合後にデータを集計することも可能です。

例えば、特定の列の合計や平均を計算します。

df10 = pd.DataFrame({'キー': [1, 2, 3], '値': [10, 20, 30]})
df11 = pd.DataFrame({'キー': [2, 3, 4], '値': [40, 50, 60]})
# DataFrameを結合
result_aggregated = pd.merge(df10, df11, on='キー', how='outer')
# 集計
total_sum = result_aggregated['値_x'].fillna(0).sum() + result_aggregated['値_y'].fillna(0).sum()
print(f'合計: {total_sum}')