Pandas

[Python] Pandas – DataFrameを外部結合する方法

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

PandasでDataFrameを外部結合するには、merge()関数またはjoin()メソッドを使用します。

merge()関数では、how引数に'outer'を指定することで外部結合が可能です。

例えば、pd.merge(df1, df2, how='outer', on='key')のように使用します。

join()メソッドでも同様に、how='outer'を指定して外部結合ができます。

外部結合では、結合キーが一致しない行も含まれ、欠損値が発生する場合があります。

目次から探す

DataFrameの結合とは
Pandasでの外部結合の基本
merge()を使った外部結合の詳細
join()を使った外部結合の詳細
外部結合の応用例
外部結合のパフォーマンス最適化
まとめ

DataFrameの結合とは

PandasのDataFrameは、データを表形式で扱うための強力なツールです。

複数のDataFrameを結合することで、より複雑なデータ分析が可能になります。

ここでは、DataFrameの結合について詳しく解説します。

DataFrameの結合の基本

DataFrameの結合は、異なるデータセットを一つのDataFrameに統合するプロセスです。

主に以下の方法で結合が行われます。

結合方法	説明
内部結合	両方のDataFrameに共通するキーを持つ行のみを結合
外部結合	一方または両方のDataFrameに存在するすべての行を結合
左外部結合	左側のDataFrameのすべての行と、右側のDataFrameの一致する行を結合
右外部結合	右側のDataFrameのすべての行と、左側のDataFrameの一致する行を結合

内部結合と外部結合の違い

内部結合と外部結合の主な違いは、結合結果に含まれる行の数です。

内部結合: 両方のDataFrameに共通するキーを持つ行のみが結果に含まれます。

これにより、データの重複を避けることができます。

外部結合: 一方または両方のDataFrameに存在するすべての行が結果に含まれます。

これにより、欠損値が発生する可能性がありますが、より多くの情報を保持できます。

外部結合のメリットとデメリット

外部結合には、以下のようなメリットとデメリットがあります。

メリット	デメリット
データの完全性を保つ	欠損値が発生する可能性がある
異なるデータソースを統合できる	結合処理が重くなることがある
分析の幅が広がる	結合キーの設定が複雑になることがある

外部結合は、異なるデータソースを統合する際に非常に有用ですが、欠損値の処理やパフォーマンスに注意が必要です。

Pandasでの外部結合の基本

Pandasでは、外部結合を行うために主にmerge()関数、join()メソッド、concat()関数を使用します。

それぞれの使い方や特徴について詳しく解説します。

merge()関数の使い方

merge()関数は、DataFrameを結合するための最も一般的な方法です。

外部結合を行うには、how引数に'outer'を指定します。

import pandas as pd
# サンプルデータの作成
df1 = pd.DataFrame({
    'key': ['A', 'B', 'C'],
    'value1': [1, 2, 3]
})
df2 = pd.DataFrame({
    'key': ['B', 'C', 'D'],
    'value2': [4, 5, 6]
})
# 外部結合の実行
result = pd.merge(df1, df2, on='key', how='outer')
print(result)

key  value1  value2
0   A     1.0     NaN
1   B     2.0     4.0
2   C     3.0     5.0
3   D     NaN     6.0

この例では、key列を基準に外部結合を行い、両方のDataFrameに存在するすべての行が結果に含まれています。

join()メソッドの使い方

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

外部結合を行うには、how引数に'outer'を指定します。

import pandas as pd
# サンプルデータの作成
df1 = pd.DataFrame({
    'value1': [1, 2, 3]
}, index=['A', 'B', 'C'])
df2 = pd.DataFrame({
    'value2': [4, 5, 6]
}, index=['B', 'C', 'D'])
# 外部結合の実行
result = df1.join(df2, how='outer')
print(result)

value1  value2
A     1.0     NaN
B     2.0     4.0
C     3.0     5.0
D     NaN     6.0

この例では、インデックスを基準に外部結合を行い、両方のDataFrameに存在するすべての行が結果に含まれています。

concat()関数との違い

concat()関数は、DataFrameを単純に連結するために使用されますが、外部結合とは異なります。

concat()は、行または列を追加する形でデータを結合します。

import pandas as pd
# サンプルデータの作成
df1 = pd.DataFrame({
    'key': ['A', 'B', 'C'],
    'value1': [1, 2, 3]
})
df2 = pd.DataFrame({
    'key': ['B', 'C', 'D'],
    'value2': [4, 5, 6]
})
# concat()を使用した結合
result = pd.concat([df1, df2], axis=0, ignore_index=True)
print(result)

key  value1  value2
0   A     1.0     NaN
1   B     2.0     NaN
2   C     3.0     NaN
3   B     NaN     4.0
4   C     NaN     5.0
5   D     NaN     6.0

この例では、concat()を使用してDataFrameを縦に連結していますが、外部結合のようにキーを基準にした結合は行われていません。

concat()は、データの構造を維持しながら単純に追加するための方法です。

merge()を使った外部結合の詳細

merge()関数は、Pandasでの外部結合を行う際に非常に便利なツールです。

ここでは、merge()関数の詳細な使い方について解説します。

how引数の役割

how引数は、結合の方法を指定するために使用されます。

以下のオプションがあります。

オプション	説明
`'inner'`	内部結合。共通のキーを持つ行のみを結合
`'outer'`	外部結合。すべての行を結合し、欠損値はNaNで埋める
`'left'`	左外部結合。左側のDataFrameのすべての行を保持
`'right'`	右外部結合。右側のDataFrameのすべての行を保持

例えば、外部結合を行う場合は以下のように指定します。

result = pd.merge(df1, df2, on='key', how='outer')

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

on引数は、結合に使用するキーを指定します。

デフォルトでは、両方のDataFrameに共通する列名が使用されますが、異なる列名を指定することも可能です。

import pandas as pd
# サンプルデータの作成
df1 = pd.DataFrame({
    'key1': ['A', 'B', 'C'],
    'value1': [1, 2, 3]
})
df2 = pd.DataFrame({
    'key2': ['B', 'C', 'D'],
    'value2': [4, 5, 6]
})
# 異なる列名での外部結合
result = pd.merge(df1, df2, left_on='key1', right_on='key2', how='outer')
print(result)

key1 key2  value1  value2
0    A  NaN     1.0     NaN
1    B    B     2.0     4.0
2    C    C     3.0     5.0
3  NaN    D     NaN     6.0

複数のキーで外部結合する方法

複数のキーを使用して外部結合を行うことも可能です。

この場合、on引数にリストを指定します。

import pandas as pd
# サンプルデータの作成
df1 = pd.DataFrame({
    'key1': ['A', 'B', 'C'],
    'key2': [1, 2, 3],
    'value1': [10, 20, 30]
})
df2 = pd.DataFrame({
    'key1': ['B', 'C', 'D'],
    'key2': [2, 3, 4],
    'value2': [40, 50, 60]
})
# 複数のキーでの外部結合
result = pd.merge(df1, df2, on=['key1', 'key2'], how='outer')
print(result)

key1  key2  value1  value2
0    A     1    10.0     NaN
1    B     2    20.0    40.0
2    C     3    30.0    50.0
3    D     4     NaN    60.0

列名が異なる場合の結合方法

異なる列名を持つDataFrameを結合する場合、left_onとright_on引数を使用してそれぞれのキーを指定します。

import pandas as pd
# サンプルデータの作成
df1 = pd.DataFrame({
    'id': [1, 2, 3],
    'value1': ['A', 'B', 'C']
})
df2 = pd.DataFrame({
    'identifier': [2, 3, 4],
    'value2': ['D', 'E', 'F']
})
# 異なる列名での外部結合
result = pd.merge(df1, df2, left_on='id', right_on='identifier', how='outer')
print(result)

id value1  identifier value2
0   1      A         NaN    NaN
1   2      B         2.0      D
2   3      C         3.0      E
3 NaN    NaN         4.0      F

結合後の欠損値の扱い

外部結合を行うと、結合キーに存在しない行にはNaNが入ります。

これらの欠損値を処理する方法はいくつかあります。

欠損値を削除: dropna()メソッドを使用して欠損値を含む行を削除します。
欠損値を埋める: fillna()メソッドを使用して欠損値を特定の値で埋めます。

# 欠損値を埋める例
result_filled = result.fillna('欠損')
print(result_filled)

id value1 identifier value2
0   1      A      欠損    欠損
1   2      B      2.0      D
2   3      C      3.0      E
3 欠損    欠損      4.0      F

このように、結合後の欠損値は適切に処理することが重要です。

join()を使った外部結合の詳細

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

ここでは、join()メソッドの詳細な使い方について解説します。

join()メソッドの基本的な使い方

join()メソッドは、デフォルトで左側のDataFrameに基づいて結合を行います。

how引数を使用して結合の方法を指定できます。

import pandas as pd
# サンプルデータの作成
df1 = pd.DataFrame({
    'value1': [1, 2, 3]
}, index=['A', 'B', 'C'])
df2 = pd.DataFrame({
    'value2': [4, 5, 6]
}, index=['B', 'C', 'D'])
# 外部結合の実行
result = df1.join(df2, how='outer')
print(result)

value1  value2
A     1.0     NaN
B     2.0     4.0
C     3.0     5.0
D     NaN     6.0

この例では、df1とdf2を外部結合し、両方のDataFrameに存在するすべての行が結果に含まれています。

インデックスを使った外部結合

join()メソッドは、インデックスを基準に結合を行うため、インデックスが異なるDataFrame同士でも簡単に結合できます。

インデックスが一致する行が結合されます。

import pandas as pd
# サンプルデータの作成
df1 = pd.DataFrame({
    'value1': [10, 20, 30]
}, index=['A', 'B', 'C'])
df2 = pd.DataFrame({
    'value2': [40, 50, 60]
}, index=['B', 'C', 'D'])
# インデックスを使った外部結合
result = df1.join(df2, how='outer')
print(result)

value1  value2
A    10.0     NaN
B    20.0    40.0
C    30.0    50.0
D     NaN    60.0

このように、インデックスを基準にした外部結合が行われ、欠損値がNaNとして表示されています。

複数のDataFrameをjoin()で結合する方法

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

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

import pandas as pd
# サンプルデータの作成
df1 = pd.DataFrame({
    'value1': [1, 2, 3]
}, index=['A', 'B', 'C'])
df2 = pd.DataFrame({
    'value2': [4, 5, 6]
}, index=['B', 'C', 'D'])
df3 = pd.DataFrame({
    'value3': [7, 8]
}, index=['C', 'D'])
# 複数のDataFrameをjoinで結合
result = df1.join(df2, how='outer').join(df3, how='outer')
print(result)

value1  value2  value3
A     1.0     NaN     NaN
B     2.0     4.0     NaN
C     3.0     5.0     7.0
D     NaN     6.0     8.0

この例では、3つのDataFrameを外部結合し、すべての行が結果に含まれています。

join()とmerge()の違い

join()メソッドとmerge()関数は、どちらもDataFrameを結合するために使用されますが、いくつかの違いがあります。

特徴	`join()`	`merge()`
基準	インデックス	列名
デフォルトの結合方法	左外部結合	内部結合
複数のキーでの結合	直接指定不可	リストで指定可能
使用シーン	インデックスを基準にした結合	列名を基準にした結合

join()はインデックスを基準にした結合に特化しており、merge()は列名を基準にした結合に適しています。

データの構造や目的に応じて使い分けることが重要です。

外部結合の応用例

外部結合は、データ分析において非常に強力な手法です。

ここでは、外部結合の具体的な応用例をいくつか紹介します。

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

複数のDataFrameを一度に外部結合する場合、reduce()関数を使用して、リスト内のDataFrameを順次結合することができます。

import pandas as pd
from functools import reduce
# サンプルデータの作成
df1 = pd.DataFrame({'key': ['A', 'B'], 'value1': [1, 2]})
df2 = pd.DataFrame({'key': ['B', 'C'], 'value2': [3, 4]})
df3 = pd.DataFrame({'key': ['C', 'D'], 'value3': [5, 6]})
# 複数のDataFrameを一度に外部結合
dfs = [df1, df2, df3]
result = reduce(lambda left, right: pd.merge(left, right, on='key', how='outer'), dfs)
print(result)

key  value1  value2  value3
0   A     1.0     NaN     NaN
1   B     2.0     3.0     NaN
2   C     NaN     4.0     5.0
3   D     NaN     NaN     6.0

異なるサイズのDataFrameを結合する

異なるサイズのDataFrameを外部結合することも可能です。

結合の際、片方のDataFrameにしか存在しない行はNaNで埋められます。

import pandas as pd
# サンプルデータの作成
df1 = pd.DataFrame({'key': ['A', 'B', 'C'], 'value1': [1, 2, 3]})
df2 = pd.DataFrame({'key': ['B', 'C', 'D', 'E'], 'value2': [4, 5, 6, 7]})
# 異なるサイズのDataFrameを外部結合
result = pd.merge(df1, df2, on='key', how='outer')
print(result)

key  value1  value2
0   A     1.0     NaN
1   B     2.0     4.0
2   C     3.0     5.0
3   D     NaN     6.0
4   E     NaN     7.0

欠損値を処理しながら外部結合する

外部結合を行った後、欠損値を適切に処理することが重要です。

fillna()メソッドを使用して、欠損値を特定の値で埋めることができます。

import pandas as pd
# サンプルデータの作成
df1 = pd.DataFrame({'key': ['A', 'B'], 'value1': [1, 2]})
df2 = pd.DataFrame({'key': ['B', 'C'], 'value2': [3, 4]})
# 外部結合
result = pd.merge(df1, df2, on='key', how='outer')
# 欠損値を埋める
result_filled = result.fillna(0)
print(result_filled)

key  value1  value2
0   A     1.0     0.0
1   B     2.0     3.0
2   C     0.0     4.0

時系列データの外部結合

時系列データを扱う場合、日付をインデックスとして使用し、外部結合を行うことができます。

これにより、異なる時点のデータを統合することが可能です。

import pandas as pd
# サンプルデータの作成
df1 = pd.DataFrame({'value1': [1, 2, 3]}, index=pd.date_range('2023-01-01', periods=3))
df2 = pd.DataFrame({'value2': [4, 5]}, index=pd.date_range('2023-01-02', periods=2))
# 時系列データの外部結合
result = df1.join(df2, how='outer')
print(result)

value1  value2
2023-01-01     1.0     NaN
2023-01-02     2.0     4.0
2023-01-03     3.0     5.0

カテゴリデータの外部結合

カテゴリデータを扱う場合、外部結合を使用して異なるカテゴリのデータを統合することができます。

これにより、分析の幅が広がります。

import pandas as pd
# サンプルデータの作成
df1 = pd.DataFrame({'category': ['A', 'B'], 'value1': [1, 2]})
df2 = pd.DataFrame({'category': ['B', 'C'], 'value2': [3, 4]})
# カテゴリデータの外部結合
result = pd.merge(df1, df2, on='category', how='outer')
print(result)

category  value1  value2
0        A     1.0     NaN
1        B     2.0     3.0
2        C     NaN     4.0

これらの応用例を通じて、外部結合の柔軟性と強力さを理解し、さまざまなデータ分析のシナリオに活用することができます。

外部結合のパフォーマンス最適化

外部結合は非常に便利な機能ですが、大規模データを扱う際にはパフォーマンスに影響を与えることがあります。

ここでは、外部結合のパフォーマンスを最適化するための方法について解説します。

大規模データの結合時の注意点

大規模データを結合する際には、以下の点に注意が必要です。

結合キーの選定: 結合に使用するキーは、できるだけユニークであることが望ましいです。

重複が多いと、結合結果が膨大になり、処理時間が長くなります。

データのサイズ: 結合するDataFrameのサイズが大きい場合、メモリ不足に陥る可能性があります。

必要に応じて、データを分割して処理することを検討してください。

結合方法の選択: 内部結合や左外部結合など、必要なデータに応じて結合方法を選択することで、処理時間を短縮できます。

メモリ効率を上げるためのテクニック

メモリ効率を上げるためには、以下のテクニックを活用できます。

データ型の最適化: DataFrameの各列のデータ型を適切に設定することで、メモリ使用量を削減できます。

例えば、整数型をint64からint32に変更することが考えられます。

  df['column'] = df['column'].astype('int32')

不要な列の削除: 結合に必要ない列は、事前に削除しておくことでメモリを節約できます。

  df.drop(columns=['unnecessary_column'], inplace=True)

チャンク処理: 大規模データを一度に処理するのではなく、チャンクに分けて処理することで、メモリの負担を軽減できます。

  for chunk in pd.read_csv('large_file.csv', chunksize=10000):
      # 各チャンクに対して処理を行う

結合前にデータをソートするメリット

データを結合する前にソートしておくことには、いくつかのメリットがあります。

パフォーマンスの向上: 結合するDataFrameがソートされていると、結合処理が効率的に行われ、パフォーマンスが向上します。

特に大規模データの場合、ソートによって処理時間が短縮されることがあります。

  df1.sort_values(by='key', inplace=True)
  df2.sort_values(by='key', inplace=True)

結果の整然さ: 結合後の結果が整然とした形で得られるため、データの可読性が向上します。

特に、後続の分析や可視化において役立ちます。

デバッグの容易さ: ソートされたデータは、結合後のデータの確認やデバッグが容易になります。

特定のキーに関連するデータを迅速に見つけることができます。

これらの最適化手法を活用することで、外部結合のパフォーマンスを向上させ、効率的なデータ処理が可能になります。

まとめ

この記事では、Pandasを使用したDataFrameの外部結合について、基本的な概念から具体的な実装方法、応用例、パフォーマンス最適化のテクニックまで幅広く解説しました。

外部結合は、異なるデータソースを統合するための強力な手法であり、データ分析において非常に重要な役割を果たします。

これを機に、実際のデータ分析において外部結合を積極的に活用し、より効率的なデータ処理を行ってみてください。