PySpark での DataFrame 結合

PySpark は、分散処理フレームワーク Apache Spark の Python 用 API です。PySpark では、DataFrame というデータ構造を使用します。

データを分析する際にはデータソースとして DB、Parquet、CSV などいろいろなデータソースからデータを取得して分析します。この際に、各データソースのデータを同じ意味を表すキー列をもとに結合してから分析することがほとんどです。これにより、より多角的な分析が可能になります。データ結合は、データ活用において非常に重要なデータ操作となります。

PySpark では、DataFrame の結合方法として join メソッドが用意されています。この記事では、join メソッドの使い方の基本を紹介します。

また、Spark は分散処理環境であるため結合アルゴリズムも複数あり、Spark が適切なアルゴリズムを選択します。どのアルゴリズムが選択されるかは Spark が決定しますが、どのような結合アルゴリズムがあるかを理解しておくことはパフォーマンスチューニングに役立ちます。後半では、Spark の結合アルゴリズムの種類についても概要を説明したいと思います。

join を用いた DataFrame の結合

PySpark では、DataFrame の結合方法として join メソッドを使用します。以降では、join メソッドの使い方を例を使って紹介していきます。

使用する DataFrame の作成

結合操作の説明のための簡単な DataFrame を以下のように作成します。

from pyspark.sql import SparkSession

# SparkSessionの初期化
spark = SparkSession.builder.appName("ColumnsOperation").getOrCreate()

data_a = [
    ("A001", 100),
    ("B001", 200),
    ("C001", 300),
    ("C002", 400),
    ("E001", 500),
]
df_a = spark.createDataFrame(data_a, ["id", "value1"])
df_a.printSchema()
df_a.show()

data_b = [
    ("B001", "aaa"),
    ("C001", "bbb"),
    ("D001", "ccc"),
    ("E002", "ddd"),
]
df_b = spark.createDataFrame(data_b, ["id", "value2"])
df_b.printSchema()
df_b.show()

【実行結果】
root
 |-- id: string (nullable = true)
 |-- value1: long (nullable = true)

+----+------+
|  id|value1|
+----+------+
|A001|   100|
|B001|   200|
|C001|   300|
|C002|   400|
|E001|   500|
+----+------+

root
 |-- id: string (nullable = true)
 |-- value2: string (nullable = true)

+----+------+
|  id|value2|
+----+------+
|B001|   aaa|
|C001|   bbb|
|D001|   ccc|
|E002|   ddd|
+----+------+

上記例では、df_aとdf_bという2つのDataFrameを作成しています。共にidという列を持っているため、id列を使った結合をすることを以降で考えていきます。

なお、処理を完了した後は SparkSession を終了しますが、説明では省略します。

# SparkSessionを終了
spark.stop()

以降では、結合で代表的な内部結合 (Inner Join)、外部結合 (Outer Join) の各方法について上記データを用いた例で説明していきます。

内部結合 (Inner Join)

内部結合 (Inner Join) は、結合対象テーブルで指定した列で両テーブルの行を比較し、共に指定列の値が一致する行のみを使ってテーブルを結合します。つまり、片方のテーブルに存在しても、もう一方には存在しないデータは結合結果に含まれません。

基本的な使い方

PySpark の DataFrame での内部結合 (Inner Join) は以下のようにします。

# 内部結合 (inner join)
df_inner = df_a.join(df_b, on=["id"], how="inner")
df_inner.show()

【実行結果】
+----+------+------+
|  id|value1|value2|
+----+------+------+
|B001|   200|   aaa|
|C001|   300|   bbb|
+----+------+------+

例では、df_a に対して df_b のテーブルを join メソッドで結合しています。

結合条件に指定する列は on 引数で指定します。例では、id 列を指定しています。また、結合方法は how 引数で指定します。内部結合のため how="inner" とします。

結果を見てみると df_a と df_b でともに現れる id の行のみが抽出されて結合されていることが分かります。

外部結合 (Outer Join)

外部結合 (Outer Join) は、結合対象テーブルで指定した列において両テーブルの行を比較したときに、一致しない行も結合結果に含めて結合します。この時、片方のテーブルに存在し、もう一方には存在しないデータの場合には NULL で埋められます。

外部結合 (Outer Join)

PySpark の DataFrame での外部結合 (Outer Join) は以下のようにします。

# 外部結合 (outer join)
df_outer = df_a.join(df_b, on=["id"], how="outer")
df_outer.show()

【実行結果】
+----+------+------+
|  id|value1|value2|
+----+------+------+
|A001|   100|  NULL|
|B001|   200|   aaa|
|C001|   300|   bbb|
|C002|   400|  NULL|
|D001|  NULL|   ccc|
|E001|   500|  NULL|
|E002|  NULL|   ddd|
+----+------+------+

外部結合を使用する場合は、 how 引数で how="outer" を指定します。

結果を見てみると df_a と df_b において id が一致していない行についても含めて結合されていることが分かります。例のように片方のテーブルには存在し、もう一方には存在しないデータは NULL で埋められます。

左外部結合 (Left Outer Join)

左外部結合(Left Outer Join) は、外部結合のうち、左側のテーブルを基準にして結合します。具体的には、左側のテーブルのすべての行を含み、指定した列において一致する行が右側のテーブルにない場合は NULLで埋めます。Left Join と単純に言う場合は左外部結合のことを指していると思ってください。

PySpark の DataFrame で左外部結合 (Left Outer Join) は以下のようにします。

# 左外部結合 (left Outer join)
df_left_outer = df_a.join(df_b, on=["id"], how="left")
df_left_outer.show()

【実行結果】
+----+------+------+
|  id|value1|value2|
+----+------+------+
|A001|   100|  NULL|
|B001|   200|   aaa|
|C001|   300|   bbb|
|C002|   400|  NULL|
|E001|   500|  NULL|
+----+------+------+

左外部結合を使用する場合は、how 引数で how="left" を指定します。

ここでいう左とは df_a のことです。結果を見ると df_a のすべて行を含み df_b を結合しています。左側のテーブルである df_a に存在し、もう一方の df_b には存在しないデータは NULL で埋められます。

右外部結合 (Right Outer Join)

右外部結合 (Right Outer Join) は、外部結合のうち、右側のテーブルを基準にして結合します。具体的には、右側のテーブルのすべての行を含み、指定した列において一致する行が左側のテーブルにない場合は NULL で埋めます。Right Join と単純に言う場合は右外部結合のことを指していると思ってください。

結合するテーブル順を逆にすれば、右外部結合は左外部結合でも表現できます。実際の使用においては左外部結合がより一般的です。これは、左から右へという自然な流れにあっているからです。とはいえ、右外部結合の使い方も知っておきましょう。

PySpark の DataFrame で右外部結合 (Right Outer Join) は以下のようにします。

# 右外部結合 (Right Outer Join)
df_right_outer = df_a.join(df_b, on=["id"], how="right")
df_right_outer.show()

【実行結果】
+----+------+------+
|  id|value1|value2|
+----+------+------+
|B001|   200|   aaa|
|C001|   300|   bbb|
|D001|  NULL|   ccc|
|E002|  NULL|   ddd|
+----+------+------+

右外部結合を使用する場合は、how 引数で how="right" を指定します。

ここでいう右とは df_b のことです。結果を見ると df_b のすべての行を含み df_a を結合しています。右側のテーブルである df_b に存在し、もう一方の df_a には存在しないデータは NULL で埋められます。

複数列をキーに使用した結合

DataFrame を結合する場合には、複数列をキーにして結合したくなることがほとんどです。複数キーでの結合するために df_c という DataFrame を作っておきます。

data_c = [
    ("A001", 1, "num1"),
    ("B001", 200, "num2"),
    ("C001", 300, "num3"),
    ("C001", 4, "num4"),
    ("E001", 500, "num5"),
]
df_c = spark.createDataFrame(data_c, ["id", "value1", "value3"])
df_c.printSchema()
df_c.show()

【実行結果】
root
 |-- id: string (nullable = true)
 |-- value1: long (nullable = true)
 |-- value3: string (nullable = true)

+----+------+------+
|  id|value1|value3|
+----+------+------+
|A001|     1|  num1|
|B001|   200|  num2|
|C001|   300|  num3|
|C001|     4|  num4|
|E001|   500|  num5|
+----+------+------+

id 列と value1 列は、df_a と共通したものとなっています。このデータを用いて df_a と df_c を id、value1 をキーに結合してみます。

# 複数条件での結合
df_inner_multi = df_a.join(df_c, on=["id", "value1"], how="inner")
df_inner_multi.show()

【実行結果】
+----+------+------+
|  id|value1|value3|
+----+------+------+
|B001|   200|  num2|
|C001|   300|  num3|
|E001|   500|  num5|
+----+------+------+

使い方はこれまで見てきた例とほとんど同じで on 引数に ["id", "value1"] といった形で複数のキーとなる列をリストで指定します。

結果を見ると id と value1 がともに一致する列のみ抽出されています。

異なる列名で結合する場合

複数データソースからデータを取得して分析をする場合、同じ意味でも列名が異なるケースはよくあります。このような場合の対処法についても見ておきましょう。

列名が異なる例として df_d という DataFrame を作っておきます。このデータは df_b と内容は同じなのですが id に該当する列名が no となっています。

data_d = [
    ("B001", "aaa"),
    ("C001", "bbb"),
    ("D001", "ccc"),
    ("E002", "ddd"),
]
df_d = spark.createDataFrame(data_d, ["no", "value5"])
df_d.printSchema()
df_d.show()

【実行結果】
root
 |-- no: string (nullable = true)
 |-- value5: string (nullable = true)

+----+------+
|  no|value5|
+----+------+
|B001|   aaa|
|C001|   bbb|
|D001|   ccc|
|E002|   ddd|
+----+------+

これまで使用していた df_a と上記の df_d を結合する例を見てみましょう。

等価演算子 (==) を使用して結合する

異なる列名で結合する場合に、等価演算子 (==) を使用して結合する方法があります。等価演算子を使用して異なる列名を条件に結合する場合には以下のようにします。

# 等価演算子(==)を使用して異なる列名を条件に結合する
df_inner_equal = df_a.join(df_d, df_a.id == df_d.no, how="inner")
df_inner_equal.show()

【実行結果】
+----+------+----+------+
|  id|value1|  no|value5|
+----+------+----+------+
|B001|   200|B001|   aaa|
|C001|   300|C001|   bbb|
+----+------+----+------+

等価演算子 (==) を使用する場合には、例のように「df_a.id == df_d.no」といった条件を引数に指定します。

結果を見ると条件に一致した行のみ抽出されていることが分かるかと思います。ただし、結合結果にはそれぞれの列 (id と no) が含まれる結果となります。

列名を統一してから結合する

上記のように等価演算子 (==) を使用することで異なる列名でも結合ができました。しかし、同じ意味の異なる列が結合結果に残ってしまいます。

それぞれの列を残しておく必要がない場合には、列名を統一してから結合します。

# 列名を変更して統一する
df_d = df_d.withColumnRenamed("no", "id")
df_d.show()

# 統一した列名を用いて結合する
df_inner_renamed = df_a.join(df_d, on=["id"], how="inner")
df_inner_renamed.show()

【実行結果】
+----+------+
|  id|value5|
+----+------+
|B001|   aaa|
|C001|   bbb|
|D001|   ccc|
|E002|   ddd|
+----+------+

+----+------+------+
|  id|value1|value5|
+----+------+------+
|B001|   200|   aaa|
|C001|   300|   bbb|
+----+------+------+

列名を統一する場合には、withColumnRenamed を使用して列名を変更します。例では、df_d の no を id に変更しています。その後、id 列をキーにして結合することで異なる列名に対する結合ができます。

等価演算子 (==) を使用して結合するか、列名を統一してから結合するかは、結合によって求められる状況によって異なります。各状況に応じでどちらで対応するかを十分に検討してください。

結合アルゴリズムの種類

Spark の結合の join では、結合アルゴリズムをデータセットのサイズ、結合キーの有無、クエリの要件などに基づいて最適なものが選択します。主な結合のアルゴリズムは以下のようなものがあります。

1. Broadcast Hash Join
2. Sort Merge Join
3. Shuffle Hash Join
4. Broadcast Nested Loop Join
5. Cartesian Join

一般的には、上から順に高速な処理と言われます。ただし、実際の性能はケースによるためご注意ください。以降で、各アルゴリズムの概要について説明します。

Broadcast Hash Join

Broadcast Hash Join (ブロードキャストハッシュジョイン)は、片方のデータセットが十分に小さい場合に使用されます。

Spark は、分散されたノードで処理が実行されます。そのため、例えばマスタテーブルなど小さいデータセットがある場合には、各ノードに先にブロードキャストで配布し、その後で大きなデータセットとハッシュテーブルを使用して結合することで効率的にデータを結合します。

主に小さなデータセットと大きなデータセットの結合で使用され、処理は高速です。

Sort Merge Join

Sort Merge Join (ソートマージジョイン)は、両方のデータセットが大きい場合に使用されます。

このアルゴリズムは、結合キーに基づいてデータがソート、シャッフルされた後、ソートされたデータを使用してマージ結合が行われます。両方のデータセットが大きく、データの分散が一様でない場合の結合で使用され、効率的に処理がされます。

Shuffle Hash Join

Shuffle Hash Join (シャッフルハッシュジョイン)は、両方のデータセットが中程度のサイズの場合に使用されることが多いアルゴリズムです。

このアルゴリズムでは、結合キーに基づいてデータがシャッフルされ、その後ハッシュベースの結合が行われます。中程度のデータセットには適していますが Broadcast Hash Join や Sort Merge Join よりは一般的に少し遅くなります。

Broadcast Nested Loop Join

Broadcast Nested Loop Join (ブロードキャストネステッドループジョイン)は、結合キーがない場合等に使用されます。

このアルゴリズムでは、小さいデータセットが各ノードにブロードキャストされて大きなデータセットのデータに対してループによる結合が行われます。結合キーがない場合といった通り、組み合わせで結合するため通常避けられるべき結合の種類です。

上記の join での結合例で紹介したように結合キーを指定して結合する場合には、通常選択されることはありません。

Cartesian Join

Cartesian Join (カルテシアンジョイン)は、結合キーが指定されていない場合で、データセット間のカルテシアン積（すべての可能なペアの結合）を生成する場合に使用されます。

このアルゴリズムは、リソースを大量に消費し非常に遅いプロセスであるため、通常は避けられるべき結合の種類であり、特定の分析や複雑なクエリなどで他の結合方法が適用できな場合に限り使われるものです。

上記の join での結合例で紹介したように結合キーを指定して結合する場合には、通常選択されることはありません。

チューニングの際に考慮するべきこと

Spark では、上記のような結合アルゴリズムをデータセットのサイズ、結合キーの有無、クエリの要件などに基づいて最適なものが選択されます。

実行計画を確認する explain メソッドや実行結果を確認する Spark UI を用いると、どの結合アルゴリズムが選択されているかを確認することができます。もし遅いとされる Broadcast Nested Loop Join や Cartesian Join が選択されているような場合には、repartition 等でパーティションサイズを調整したり、クエリを変更するなどを再検討するのが良いでしょう。

また、join の際に特定のアルゴリズムを使用するようにヒントを与える hint メソッドというものもあります。以下は、Broadcast Hash Join を使用するようにヒントを与える例です。

df = df1.join(df2.hint("broadcast"), on=["Key1"])

上記例では df2 が小さいデータセットの場合に df2 をブロードキャストしてから結合するように促すことができます。

また、同様に Sort Merge Join を使用するように促したい場合には、以下のようにすることもできます。

df = df1.join(df2.hint("merge"), on=["Key1"])

なお、注意事項として上記はあくまでヒントであるため必ずそのアルゴリズムが選択されるわけではないことに注意してください。

どのアルゴリズムが選択されるかは、最終的にはデータセットのサイズや結合キーの有無、クエリの要件によって Spark が自動的に判定して最適なものを選択します。

まとめ

PySpark で DataFrame を結合する方法について解説しました。

PySpark では、DataFrameの結合方法として join メソッドが用意されています。この記事では join メソッドの使い方の基本を紹介しました。

また、Spark では分散環境で動作するため、内部的に効率的な結合アルゴリズムが選択されます。Spark の結合アルゴリズムの種類についても簡単に説明しました。

パフォーマンスチューニングの際には、どの結合アルゴリズムが選択されているかを確認して必要に応じて repartition 等でパーティションサイズを調整したり、クエリを変更するなどの検討が必要になります。

データ結合は、データ活用において非常に重要なデータ操作です。ぜひ、PySpark での結合操作をうまく使いこなしてもらいたいと思います。

あわせて読みたい

【Python Tech】プログラミングガイド

SeriesやDataFrameの連結方法

データ分析の際には、異なる種類のデータソースの組み合わせから深い知見や研究成果が得られるということがほとんどです。ここでいう「組み合わせ」とは2つのデータセットを単に連結するだけではなく、重複するデータを適切に処理することも含まれます。

pandasで中心的なデータ構造はSeriesやDataFrameです。これらは連結処理を念頭に置いて設計されているため、データを簡単に連結することができます。具体的には、pandasのSeriesやDataFrameを連結したい場合、concat関数を使用することができます。

この記事では、pandasのconcat関数を用いたデータの連結方法を説明します。

concat関数の基本的な使い方

SeriesやDataFrameを連結する場合にはconcat関数を使用します。以下の簡単な例を見てみましょう。

import pandas as pd

# ===== Seriesの連結
# データの準備
ser1 = pd.Series(['A', 'B', 'C', 'D', 'E'], index=[1, 2, 3, 4, 5])
ser2 = pd.Series(['V', 'W', 'X', 'Y', 'Z'], index=[6, 7, 8, 9, 10])

# 連結
ser_concat = pd.concat([ser1, ser2])
print(ser_concat, '\n')

# ===== DataFrameの連結
# データの準備
df1 = pd.DataFrame([['A', 'B'], ['C', 'D'], ['E', 'F']],
                   index=[1, 2, 3], columns=['attr1', 'attr2'])
df2 = pd.DataFrame([['U', 'V'], ['W', 'X'], ['Y', 'Z']],
                   index=[4, 5, 6], columns=['attr1', 'attr2'])

# 連結
df_concat = pd.concat([df1, df2])
print(df_concat)

【実行結果】
1     A
2     B
3     C
4     D
5     E
6     V
7     W
8     X
9     Y
10    Z
dtype: object 

  attr1 attr2
1     A     B
2     C     D
3     E     F
4     U     V
5     W     X
6     Y     Z

上記では、SeriesとDataFrameをそれぞれ連結をしています。使用方法は簡単で、concat関数の引数に連結したい対象のSeriesやDataFrameを含むリストを指定するだけです。

インデックスが重複している場合

concat関数の特徴として、連結するデータのインデックスが重複していても、それぞれのインデックスが保持される点があります。以下は、インデックス2, 3が重複しているケースです。

import pandas as pd

# ===== DataFrameの連結
# データの準備
df1 = pd.DataFrame([['A', 'B'], ['C', 'D'], ['E', 'F']],
                   index=[1, 2, 3], columns=['attr1', 'attr2'])
df2 = pd.DataFrame([['U', 'V'], ['W', 'X'], ['Y', 'Z']],
                   index=[2, 3, 4], columns=['attr1', 'attr2'])

# 連結 (インデックスが重複していても保持する)
df_concat = pd.concat([df1, df2])
print(df_concat)

【実行結果】
  attr1 attr2
1     A     B
2     C     D
3     E     F
2     U     V
3     W     X
4     Y     Z

上記結果を見ると、インデックス2, 3が複数回出現していることが分かります。

このような状況でも問題がなければそのままで構いません。もし、重複が問題になる場合は、後述するverify_integrityやignore_indexを使った対処法があります。

重複がある場合に例外を出す ~ verify_integrity ~

concat関数は、インデックスが重複していても保持します。インデックスの重複が問題になる場合、重複があることを例外として出して対処する方法があります。

重複した場合に例外を出すには、以下のようにverify_integrityをTrueに設定します。

import pandas as pd

# ===== DataFrameの連結
df1 = pd.DataFrame([['A', 'B'], ['C', 'D'], ['E', 'F']],
                   index=[1, 2, 3], columns=['attr1', 'attr2'])
df2 = pd.DataFrame([['U', 'V'], ['W', 'X'], ['Y', 'Z']],
                   index=[2, 3, 4], columns=['attr1', 'attr2'])

# 連結 (インデックス重複時は例外:ValueError)
try:
    df_concat = pd.concat([df1, df2], verify_integrity=True)
    print(df_concat)
except ValueError as ex:
    print(ex)

【実行結果】
Indexes have overlapping values: Int64Index([2, 3], dtype='int64')

verify_integrityをTrueに設定すると、インデックスが重複していた場合には、ValueErrorの例外が発生します。この例外をキャッチすることで、処理を変更することが可能です。

インデックスを無視する ~ ignore_index ~

インデックスが重複しているケースで、もともとのインデックスが意味を持たない場合は、インデックスを無視して新しいインデックスを振ることが可能です。

インデックスを無視して新しいインデックスを振るには、以下のようにignore_indexをTrueに設定します。

import pandas as pd

# ===== DataFrameの連結
df1 = pd.DataFrame([['A', 'B'], ['C', 'D'], ['E', 'F']],
                   index=[1, 2, 3], columns=['attr1', 'attr2'])
df2 = pd.DataFrame([['U', 'V'], ['W', 'X'], ['Y', 'Z']],
                   index=[2, 3, 4], columns=['attr1', 'attr2'])

# 連結 (インデックスを無視する)
df_concat = pd.concat([df1, df2], ignore_index=True)
print(df_concat)

【実行結果】
  attr1 attr2
0     A     B
1     C     D
2     E     F
3     U     V
4     W     X
5     Y     Z

上記結果から、もともとのインデックスが無視され、新しいインデックスが0から設定されてデータが結合されていることが分かります。

連結するデータにキーを指定して階層型インデックス（マルチインデックス）にする ~ keys ~

データを連結する際に、元のデータのキーを残して結合したい場合は、階層型インデックス（マルチインデックス）を使用して対応することができます。階層型インデックスにするには、以下のようにkeysで各データのキー情報を指定します。

import pandas as pd

# ===== DataFrameの連結
# データの準備
df1 = pd.DataFrame([['A', 'B'], ['C', 'D'], ['E', 'F']],
                   index=[1, 2, 3], columns=['attr1', 'attr2'])
df2 = pd.DataFrame([['U', 'V'], ['W', 'X'], ['Y', 'Z']],
                   index=[2, 3, 4], columns=['attr1', 'attr2'])

# 連結 (階層型のインデックスにする)
df_concat = pd.concat([df1, df2], keys=['D1', 'D2'])
print(df_concat)

【実行結果】
     attr1 attr2
D1 1     A     B
   2     C     D
   3     E     F
D2 2     U     V
   3     W     X
   4     Y     Z

上記の例では"D1"、"D2"を指定しています。結果として、それぞれのキーの下に元のデータのインデックスが階層型インデックスとして配置され、データが連結されています。

積集合での連結 ~ join=”inner” ~

上記で見てきた例では、列名が全く同じデータを連結してきました。では、列名が異なるデータを連結する場合はどうなるでしょうか。以下の例で見てみましょう。

import pandas as pd

# ===== DataFrameの連結
df1 = pd.DataFrame([['A', 'B'], ['C', 'D'], ['E', 'F']],
                   index=[1, 2, 3], columns=['attr1', 'attr2'])
df2 = pd.DataFrame([['U', 'V'], ['W', 'X'], ['Y', 'Z']],
                   index=[4, 5, 6], columns=['attr2', 'attr3'])

# 連結 (デフォルトはjoin='outer')
df_concat = pd.concat([df1, df2])
print(df_concat, '\n')

# 連結 (join='inner')
df_concat = pd.concat([df1, df2], join='inner')
print(df_concat)

【実行結果】
  attr1 attr2 attr3
1     A     B   NaN
2     C     D   NaN
3     E     F   NaN
4   NaN     U     V
5   NaN     W     X
6   NaN     Y     Z 

  attr2
1     B
2     D
3     F
4     U
5     W
6     Y

concat関数は、デフォルトではjoin="outer"となっています。outerは和集合を意味し、両方の列を含んだ連結が行われ、値がない部分は上記結果のようにNaNとなります。

もし、それぞれのデータセットに存在する列のみを連結したい場合は、join="inner"を指定します。これにより積集合としての連結が行われます。上記結果を見ると、join="inner"を指定した場合は、両方に存在する"attr2"列のみ連結したデータが得られていることが分かります。

appendメソッドによるデータ連結【非推奨】

その他のデータの結合方法（merge, join）

上記では、concat関数を用いた連結方法について紹介しました。pandasには、他にもmerge関数やjoinメソッドという強力なデータ結合方法があります。

データベースのSQLに慣れている人にとっては、merge関数やjoinメソッドが理解しやすいかもしれません。これらの使用方法については「DataFrameを結合する方法」でまとめていますので興味があれば参考にしてください。

まとめ

pandasのSeriesやDataFrameを連結する方法について解説しました。具体的には、concat関数によるデータ連結方法について説明しました。

データ分析では、単にデータを連結するだけではなく、重複するデータの適切な処理や、連結時に元のデータを保持しながら階層型インデックス（マルチインデックス）を作成する方法、さらにouterやinner結合を使い分けることが重要です。これらについて本記事で紹介しました。

データ分析においては、複数のデータソースを適切に結合してから分析を行うことで、有益な情報を抽出できます。concat関数を利用したデータ結合に慣れることは重要です。

あわせて読みたい

【Python Tech】プログラミングガイド

DataFrameの結合

データ分析の際には、データベースやCSVファイル等、様々なデータソースからデータを取得して分析することがほとんどです。この時、各データで同じ意味を表すキー列をもとに結合して分析できるようにすることは、データに対する深い知見を得るために必要不可欠です。

Pythonのデータ分析で使用されるpandasでは、DataFrameの結合方法としてmerge関数やjoinメソッドといった非常に便利な機能が提供されています。

以降では、以下図に示したような製品一覧と関連する情報を結合する例でmerge関数やjoinメソッドを用いたDataFrameの結合方法を紹介していきます。

上記例では、各製品シリアル一覧と関連する品質情報実績、顧客情報、製品特徴のデータがあるものとします。製造メーカー等では生産管理システムのマスタや製造実績、品質管理システムの品質実績など、様々なシステムのデータをつなげて分析したいといったことがよくあります。実際の現場で使われているデータはもっと複雑なデータが多いと思いますが、上記のような簡単データで結合のイメージをつかんでもらえればと思います。

merge関数によるDataFrameの結合の基本

データを結合する場合には、データの関係性をよく考慮することが重要です。データの関係に応じて「1対1」「多対1」「多対多」という関係性があります。以降では、それぞれの関係性のデータを使いながらmerge関数を使用してデータを結合する方法を紹介します。

1対1の結合

上記図の例は「1対1」の関係があるデータです。「serial_no」をキー列として見てみると、各レコード（各行）は1対1に対応していることがわかります。ここでは、製品一覧と品質情報をserial_noをキーにmerge関数で結合します。

import pandas as pd

# 製品一覧
product_list = pd.DataFrame(
    {'serial_no': ['A001', 'B001', 'C001', 'C002', 'D001'],
     'customer_id': ['cid_1', 'cid_1', 'cid_2', 'cid_2', 'cid_3'],
     'product_code': ['p_a', 'p_b', 'p_c', 'p_c', 'p_d']
     }
)

# 品質情報
quality_result = pd.DataFrame(
    {'serial_no': ['A001', 'B001', 'C001', 'C002', 'D001'],
     'quality': [100, 200, 300, 400, 500]
     }
)

print(f'製品一覧(product_list):\n{product_list}\n')
print(f'品質実績(quality_result):\n{quality_result}\n')

# 製品一覧と品質情報をマージ（1対1）
result_df = pd.merge(product_list, quality_result)

print(f'製品一覧と品質情報をマージ（1対1）:\n{result_df}')

【実行結果】
製品一覧(product_list):
  serial_no customer_id product_code
0      A001       cid_1          p_a
1      B001       cid_1          p_b
2      C001       cid_2          p_c
3      C002       cid_2          p_c
4      D001       cid_3          p_d

品質実績(quality_result):
  serial_no  quality
0      A001      100
1      B001      200
2      C001      300
3      C002      400
4      D001      500

製品一覧と品質情報をマージ（1対1）:
  serial_no customer_id product_code  quality
0      A001       cid_1          p_a      100
1      B001       cid_1          p_b      200
2      C001       cid_2          p_c      300
3      C002       cid_2          p_c      400
4      D001       cid_3          p_d      500

merge関数の引数に結合するDataFrameを指定すると、結合されたDataFrameが返却されます。merge関数は、自動的に1つ以上の同じ名前の列名を探してキーにして結合をしてくれます。上記例では「serial_no」がキーとなります。

多対1の結合

上記図の例は「多対1」の関係があるデータです。「customer_id」をキー列として見てみると、製品一覧の複数レコードに1つの顧客情報のレコードが対応しています。ここでは、製品一覧と顧客情報をcustomer_idをキーにしてmerge関数で結合します。

import pandas as pd

# 製品一覧
product_list = pd.DataFrame(
    {'serial_no': ['A001', 'B001', 'C001', 'C002', 'D001'],
     'customer_id': ['cid_1', 'cid_1', 'cid_2', 'cid_2', 'cid_3'],
     'product_code': ['p_a', 'p_b', 'p_c', 'p_c', 'p_d']
     }
)

# 顧客情報
customer_info = pd.DataFrame(
    {'customer_id': ['cid_1', 'cid_2', 'cid_3'],
     'customer_name': ['顧客１', '顧客２', '顧客３']
     }
)

print(f'製品一覧(product_list):\n{product_list}\n')
print(f'顧客情報(customer_info):\n{customer_info}\n')

# 製品一覧と顧客情報をマージ（多対1）
result_df = pd.merge(product_list, customer_info)

print(f'製品一覧と顧客情報をマージ（多対1）:\n{result_df}')

製品一覧(product_list):
  serial_no customer_id product_code
0      A001       cid_1          p_a
1      B001       cid_1          p_b
2      C001       cid_2          p_c
3      C002       cid_2          p_c
4      D001       cid_3          p_d

顧客情報(customer_info):
  customer_id customer_name
0       cid_1           顧客１
1       cid_2           顧客２
2       cid_3           顧客３

製品一覧と顧客情報をマージ（多対1）:
  serial_no customer_id product_code customer_name
0      A001       cid_1          p_a           顧客１
1      B001       cid_1          p_b           顧客１
2      C001       cid_2          p_c           顧客２
3      C002       cid_2          p_c           顧客２
4      D001       cid_3          p_d           顧客３

上記結果を見てみるとcustomer_idをキーにして製品一覧に顧客情報が結合されていることが分かります。製品一覧の方が多であるため、顧客情報は複製されて各行に結合されていることが分かるかと思います。

多対多の結合

上記図の例は「多対多」の関係があるデータです。「product_code」をキー列としてみてみると、製品一覧の複数レコードに、複数の製品特徴のレコードが対応しているということが分かります。ここでは、製品一覧と製品特徴をproduct_codeをキーにしてmerge関数で結合します。

import pandas as pd

# 製品一覧
product_list = pd.DataFrame(
    {'serial_no': ['A001', 'B001', 'C001', 'C002', 'D001'],
     'customer_id': ['cid_1', 'cid_1', 'cid_2', 'cid_2', 'cid_3'],
     'product_code': ['p_a', 'p_b', 'p_c', 'p_c', 'p_d']
     }
)

# 製品特徴
product_feature = pd.DataFrame(
    {'product_code': ['p_a', 'p_a', 'p_b', 'p_b', 'p_c', 'p_c',
                      'p_d', 'p_d', 'p_d'],
     'feature': ['a-1', 'a-2', 'b-1', 'b-2', 'c-1', 'c-2',
                 'd-1', 'd-2', 'd-3']
     }
)

print(f'製品一覧(product_list):\n{product_list}\n')
print(f'製品特徴(product_feature):\n{product_feature}\n')

# 製品一覧と製品特徴をマージ（多対多）
result_df = pd.merge(product_list, product_feature)

print(f'製品一覧と製品特徴をマージ（多対多）:\n{result_df}')

【実行結果】
製品一覧(product_list):
  serial_no customer_id product_code
0      A001       cid_1          p_a
1      B001       cid_1          p_b
2      C001       cid_2          p_c
3      C002       cid_2          p_c
4      D001       cid_3          p_d

製品特徴(product_feature):
  product_code feature
0          p_a     a-1
1          p_a     a-2
2          p_b     b-1
3          p_b     b-2
4          p_c     c-1
5          p_c     c-2
6          p_d     d-1
7          p_d     d-2
8          p_d     d-3

製品一覧と製品特徴をマージ（多対多）:
   serial_no customer_id product_code feature
0       A001       cid_1          p_a     a-1
1       A001       cid_1          p_a     a-2
2       B001       cid_1          p_b     b-1
3       B001       cid_1          p_b     b-2
4       C001       cid_2          p_c     c-1
5       C001       cid_2          p_c     c-2
6       C002       cid_2          p_c     c-1
7       C002       cid_2          p_c     c-2
8       D001       cid_3          p_d     d-1
9       D001       cid_3          p_d     d-2
10      D001       cid_3          p_d     d-3

上記結果を見てみると、多対多の関係であるため、ある製品シリアルに関するレコードが複数行に増えていることが分かるかと思います。

上記で見てきた通り、merge関数は自動的に1つ以上のキーを探して結合してくれます。データの関係性による結合の違いを見てもらうために自動でのキー結合をで結果を見てもらいましたが、実際のデータ分析の場面では、結合したいキーを明確に指定して結合することがほとんどです。以降では、merge関数で、キーを指定してDataFrameを結合する方法を紹介していきます。

merge関数でキーを指定したDataFrameの結合

ここでは、merge関数でキー列を指定してDataFrameを結合する方法を説明します。

onでキーを指定して結合

merge関数でキー列を指定する場合は、以下の例のようにonを使用してキー列を指定します。

import pandas as pd

# 製品一覧
product_list = pd.DataFrame(
    {'serial_no': ['A001', 'B001', 'C001', 'C002', 'D001'],
     'customer_id': ['cid_1', 'cid_1', 'cid_2', 'cid_2', 'cid_3'],
     'product_code': ['p_a', 'p_b', 'p_c', 'p_c', 'p_d']
     }
)

# 品質情報
quality_result = pd.DataFrame(
    {'serial_no': ['A001', 'B001', 'C001', 'C002', 'D001'],
     'quality': [100, 200, 300, 400, 500]
     }
)

print(f'製品一覧(product_list):\n{product_list}\n')
print(f'品質実績(quality_result):\n{quality_result}\n')

# onでキーを指定してマージ
result_df = pd.merge(product_list, quality_result, on='serial_no')

print(f'onでキー(serial_no)を指定してマージ\n{result_df}')

【実行結果】
製品一覧(product_list):
  serial_no customer_id product_code
0      A001       cid_1          p_a
1      B001       cid_1          p_b
2      C001       cid_2          p_c
3      C002       cid_2          p_c
4      D001       cid_3          p_d

品質実績(quality_result):
  serial_no  quality
0      A001      100
1      B001      200
2      C001      300
3      C002      400
4      D001      500

onでキー(serial_no)を指定してマージ
  serial_no customer_id product_code  quality
0      A001       cid_1          p_a      100
1      B001       cid_1          p_b      200
2      C001       cid_2          p_c      300
3      C002       cid_2          p_c      400
4      D001       cid_3          p_d      500

上記例では、明示的に"serial_no"をキーとして結合しています。

この例では、それぞれのDataFrameが同一名の列を持っているため、簡単に結合できます。しかし、データ分析では同じ意味でも異なる列名であることがよくあります。この場合には、以降で説明するleft_onやright_onを使用します。

left_onとright_onでそれぞれのDataFrameのキーを指定する

データを結合する際には、それぞれのDataFrameで意味は同じなのに異なる列名となっている場合がよくあります。このような場合にはleft_onやright_onを使ってそれぞれのDataFrameにおけるキー列を指定します。

ここで左(left)と言っているのは、merge関数の第1引数に指定するDataFrameで、右(right)と言っているのはmerge関数の第2引数に指定するDataFrameです。以下の例で見てみましょう。

import pandas as pd

# 製品一覧
product_list = pd.DataFrame(
    {'serial_no': ['A001', 'B001', 'C001', 'C002', 'D001'],
     'customer_id': ['cid_1', 'cid_1', 'cid_2', 'cid_2', 'cid_3'],
     'product_code': ['p_a', 'p_b', 'p_c', 'p_c', 'p_d']
     }
)

# 品質情報
quality_result = pd.DataFrame(
    {'serial': ['A001', 'B001', 'C001', 'C002', 'D001'],
     'quality': [100, 200, 300, 400, 500]
     }
)

print(f'製品一覧(product_list):\n{product_list}\n')
print(f'品質実績(quality_result):\n{quality_result}\n')

# 左右のDataFrameのキーをそれぞれ指定してマージ
result_df = pd.merge(product_list, quality_result,
                     left_on='serial_no', right_on='serial')

print(f'左右のDataFrameのキーをそれぞれ指定してマージ:\n{result_df}')

【実行結果】
製品一覧(product_list):
  serial_no customer_id product_code
0      A001       cid_1          p_a
1      B001       cid_1          p_b
2      C001       cid_2          p_c
3      C002       cid_2          p_c
4      D001       cid_3          p_d

品質実績(quality_result):
  serial  quality
0   A001      100
1   B001      200
2   C001      300
3   C002      400
4   D001      500

左右のDataFrameのキーをそれぞれ指定してマージ:
  serial_no customer_id product_code serial  quality
0      A001       cid_1          p_a   A001      100
1      B001       cid_1          p_b   B001      200
2      C001       cid_2          p_c   C001      300
3      C002       cid_2          p_c   C002      400
4      D001       cid_3          p_d   D001      500

上記例では、製品一覧ではシリアルナンバーは「serial_no」であるのに対して、品質情報では「serial」となっており名前が異なっています。この場合は、merge関数をそのまま使用しても一致するキーがなく、自動ではうまく結合できません。

このような場合には「left_on="serial_no"」「right_on="serial"」としてそれぞれ結合するキー名称を指定することで指定列をキーにして結合することができます。

上記結果を見ても分かるように、キー列は一つにまとめられるわけではなく複数列出てくる点も覚えておきましょう。もし、キー列が複数出てこないようにしたい場合は、事前にDataFrameの列名を揃えておく必要があります。

left_indexとright_indexを指定してDataFrameのインデックスで結合

これまでの例では、DataFrameの列名を使用したmerge関数の実行例を見てきました。pandasのDataFrameでは、インデックスを持っているためインデックスを用いての結合をすることも可能です。

インデックスを使用して結合する場合には、以下の例のように「left_index=True」「right_index=True」を指定することで、インデックスを使用しての結合が可能です。

import pandas as pd

# 製品一覧
product_list = pd.DataFrame(
    {'serial_no': ['A001', 'B001', 'C001', 'C002', 'D001'],
     'customer_id': ['cid_1', 'cid_1', 'cid_2', 'cid_2', 'cid_3'],
     'product_code': ['p_a', 'p_b', 'p_c', 'p_c', 'p_d']
     }
)
# serial_no列をインデックスに設定
product_list = product_list.set_index('serial_no')

# 品質情報
quality_result = pd.DataFrame(
    {'serial_no': ['A001', 'B001', 'C001', 'C002', 'D001'],
     'quality': [100, 200, 300, 400, 500]
     }
)
# serial_no列をインデックスに設定
quality_result = quality_result.set_index('serial_no')

print(f'製品一覧(product_list):\n{product_list}\n')
print(f'品質実績(quality_result):\n{quality_result}\n')

# インデックスを使ってマージ
result_df = pd.merge(product_list, quality_result,
                     left_index=True, right_index=True)

print(f'インデックスを使ってマージ:\n{result_df}')

【実行結果】
製品一覧(product_list):
          customer_id product_code
serial_no                         
A001            cid_1          p_a
B001            cid_1          p_b
C001            cid_2          p_c
C002            cid_2          p_c
D001            cid_3          p_d

品質実績(quality_result):
           quality
serial_no         
A001           100
B001           200
C001           300
C002           400
D001           500

インデックスを使ってマージ:
          customer_id product_code  quality
serial_no                                  
A001            cid_1          p_a      100
B001            cid_1          p_b      200
C001            cid_2          p_c      300
C002            cid_2          p_c      400
D001            cid_3          p_d      500

上記例では、これまでと異なりset_indexを使って"serial_no"列をインデックスとして登録していることに注意してください。

結果を見ると分かりますが「left_index=True」「right_index=True」を指定することで、インデックスを使った結合ができていることが分かるかと思います。

joinメソッドを用いたインデックスでの結合

merge関数でインデックスを用いた結合の例を紹介しましたが、DataFrameでは、インデックスをキーとして結合を実行するためのjoinメソッドが用意されています。joinメソッドを使用することで、以下のようにインデックスを用いた結合が可能です。

import pandas as pd

# 製品一覧
product_list = pd.DataFrame(
    {'serial_no': ['A001', 'B001', 'C001', 'C002', 'D001'],
     'customer_id': ['cid_1', 'cid_1', 'cid_2', 'cid_2', 'cid_3'],
     'product_code': ['p_a', 'p_b', 'p_c', 'p_c', 'p_d']
     }
)
# serial_no列をインデックスに設定
product_list = product_list.set_index('serial_no')

# 品質情報
quality_result = pd.DataFrame(
    {'serial_no': ['A001', 'B001', 'C001', 'C002', 'D001'],
     'quality': [100, 200, 300, 400, 500]
     }
)
# serial_no列をインデックスに設定
quality_result = quality_result.set_index('serial_no')

print(f'製品一覧(product_list):\n{product_list}\n')
print(f'品質実績(quality_result):\n{quality_result}\n')

# joinメソッドを使ってインデックスで結合
result_df = product_list.join(quality_result)

print(f'joinメソッドを使ってインデックスで結合:\n{result_df}')

【実行結果】
製品一覧(product_list):
          customer_id product_code
serial_no                         
A001            cid_1          p_a
B001            cid_1          p_b
C001            cid_2          p_c
C002            cid_2          p_c
D001            cid_3          p_d

品質実績(quality_result):
           quality
serial_no         
A001           100
B001           200
C001           300
C002           400
D001           500

joinメソッドを使ってインデックスで結合:
          customer_id product_code  quality
serial_no                                  
A001            cid_1          p_a      100
B001            cid_1          p_b      200
C001            cid_2          p_c      300
C002            cid_2          p_c      400
D001            cid_3          p_d      500

mergeは関数でしたが、joinについてはDataFrameのメソッドです。そのため、joinメソッドは、左側となるDataFrameでメソッドとして呼び出し、右側となるDataFrameを引数として指定します。結果としては、merge関数で「left_index=True」「right_index=True」とした場合と同じです。

left_on, right_on, left_index, right_indexの混在での結合

上記では、列を指定する「left_on」「right_on」、インデックスでの結合を指定する「left_index=True」「right_index=True」の使い方を見てきました。もちろん、これらは同時に使用することができ、列とインデックスを混在させて結合することができます。

import pandas as pd

# 製品一覧
product_list = pd.DataFrame(
    {'serial_no': ['A001', 'B001', 'C001', 'C002', 'D001'],
     'customer_id': ['cid_1', 'cid_1', 'cid_2', 'cid_2', 'cid_3'],
     'product_code': ['p_a', 'p_b', 'p_c', 'p_c', 'p_d']
     }
)
# serial_no列をインデックスに設定
product_list = product_list.set_index('serial_no')

# 品質情報
quality_result = pd.DataFrame(
    {'serial_no': ['A001', 'B001', 'C001', 'C002', 'D001'],
     'quality': [100, 200, 300, 400, 500]
     }
)

print(f'製品一覧(product_list):\n{product_list}\n')
print(f'品質実績(quality_result):\n{quality_result}\n')

# インデックスを使ってマージ（左：インデックスを使用、右：列名を指定）
result_df = pd.merge(product_list, quality_result,
                     left_index=True, right_on='serial_no')

print(f'インデックスを使ってマージ（左：インデックス、右：列名）\n{result_df}')

【実行結果】
製品一覧(product_list):
          customer_id product_code
serial_no                         
A001            cid_1          p_a
B001            cid_1          p_b
C001            cid_2          p_c
C002            cid_2          p_c
D001            cid_3          p_d

品質実績(quality_result):
  serial_no  quality
0      A001      100
1      B001      200
2      C001      300
3      C002      400
4      D001      500

インデックスを使ってマージ（左：インデックス、右：列名）
  customer_id product_code serial_no  quality
0       cid_1          p_a      A001      100
1       cid_1          p_b      B001      200
2       cid_2          p_c      C001      300
3       cid_2          p_c      C002      400
4       cid_3          p_d      D001      500

上記例では、左側となる製品一覧は、DataFrameのインデックスを使用し、右側となる品質情報は、列名をキーとして結合しています。このようにインデックスや列名を混在させて、柔軟に結合することが可能です。

まとめ

pandasのDataFrameを結合する方法について解説しました。

pandasでは、DataFrameの結合方法としてmerge関数やjoinメソッドが用意されています。結合時には、1対1、多対1、多対多といったことを考慮して結合をすることが適切な結合のためには重要です。それぞれのパターンに関する結合を例を使って紹介しました。

また、merge関数で結合する際のキーの指定は非常に重要です。列名を指定するon、left_on、right_onやインデックスで結合するleft_index=True、right_index=Trueといった指定方法について説明しました。

データ分析では、異なるデータソースのデータを適切に結合できることが、データから深い知見を得るために必要不可欠です。是非、merge関数やjoinメソッドを適切に使用できるようになってデータ分析に活かしてください。

あわせて読みたい

【Python Tech】プログラミングガイド

文字列を連結・結合する方法

プログラミングでは、文字列の扱いは非常に重要です。文字列操作の中でも、文字列を連結・結合する場面には頻繁に直面します。

この記事では、Python で文字列を連結・結合する方法について紹介します。

文字列を連結・結合する

複数の文字列を連結・結合する方法

複数の文字列を連結・結合する場合には「+ 演算子」「+= 演算子」「文字列リテラルの列挙」という方法があります。

s1 = "a"
s2 = "b"
s3 = "c"

# +演算子で文字列を連結・結合する
temp_str = s1 + s2 + s3
print(temp_str)

# +=演算子で文字列を連結・結合する
s4 = "d"
temp_str += s4
print(temp_str)

# 文字列リテラルを連続して列挙して連結・結合する
temp_str = "e" "f" "g"
print(temp_str)

【実行結果】
abc
abcd
efg

例のように複数文字列を + 演算子や += 演算子によって連結・結合できます。また、文字列リテラルを単純に並べるだけでも連結・結合が可能です。文字列リテラルの列挙の場合は、間にスペースやバックスラッシュによる改行があっても問題ありません。

数値と文字列を連結・結合する方法

数値と文字列を連結・結合する場合には、型が異なるため単純に + 演算子は適用できません。そのまま連結・結合しようとすると TypeError エラーとなります。

s1 = "a"
n1 = 100

# そのまま連結・結合しようとするとエラーとなる
temp_str = s1 + "_" + n1
print(temp_str)

【実行結果】
TypeError: can only concatenate str (not "int") to str

このエラーを解決するには、以下のように型を揃えて実行します。

s1 = "a"
n1 = 100

# +演算子で文字列と数値を連結・結合する
temp_str = s1 + "_" + str(n1)
print(temp_str)

# +=演算子で文字列を連結・結合する
n2 = 0.01
temp_str += "_"
temp_str += str(n2)
print(temp_str)

# formatを使用して連結・結合する
temp_str = "{}_{}".format(s1, n1)
print(temp_str)

# f-stringを使用して連結・結合する
temp_str = f"{s1}_{n1:05}_{n2:.5f}"
print(temp_str)

【実行結果】
a_100
a_100_0.01
a_100
a_00100_0.01000

例では、str を使うことで数値を文字列に変換してから + 演算子等を使うことで数値と文字列を結合しています。

また、format や f-string を使用して連結することで数値のフォーマットを変えつつ結合するも可能です。format や f-string については「文字列のフォーマットを整える方法」を参考にしてください。

リストを連結・結合して文字列にする方法

リストの文字列や数値を連結・結合して文字列にする場合には、str の join メソッドを使用します。join は、非常に効率的な連結・結合方法で Python では頻繁に用います。特に、多くの文字列を連結・結合する場合には効果的です。

文字列のリストを文字列に連結・結合する方法

join メソッドで文字列のリストを連結・結合する場合は以下のようにします。

sample_list = ["Pytho", "Java", "Go", "C", "C#"]

# 文字列をそのまま結合
print("".join(sample_list))

# 区切り文字でjoinで結合
print(",".join(sample_list))

【実行結果】
PythoJavaGoCC#
Pytho,Java,Go,C,C#

文字列を単純につなげたい場合は、空文字 ("") の join メソッドに連結・結合したい対象リストを渡すことで結合できます。

区切り文字を指定する場合は、区切り文字の文字列の join メソッドに結合対象リストを渡します。例えば、"," (カンマ) を区切り文字として結合したい場合は「",".join(sample_list)」とします。もちろん他の区切り文字も使用できます。

数値リストを文字列に連結・結合する方法

数値リストに対して単純に join を適用してしまうと TypeError となります。

sample_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 数値リストをjoinでそのまま連結することはできない
print(",".join(sample_list))

【実行結果】
TypeError: sequence item 0: expected str instance, int found

数値リストを join で結合する場合には、以下のように数値リストを str で文字列に変換してから join メソッドに渡します。

sample_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 数値リストをjoinで結合する場合はstrに変換してからjoinに渡す
print(",".join([str(i) for i in sample_list]))

【実行結果】
1,2,3,4,5,6,7,8,9,10

例のようにリスト内包表記を使ってまとめて作成すると簡単です。リスト内包表記については「リスト（list）内包表記の使い方」を参考にしてください。

異なる型のオブジェクトを含むリストを文字列に連結・結合する方法

上記では、文字列だけ含むリスト、数値だけ含むリストを中心に扱ってきましたが、Python では異なる型のオブジェクトを含むリストを扱うことが可能です。

ほとんどの型は str により文字列に変換できるため、上記の数値の結合で使用した実装方法は、以下のようにすると異なる型のオブジェクトを含むリストに適用できます。

class CustomClass1:
    pass


class CustomClass2:
    def __init__(self, value):
        self.value = value

    def __str__(self):
        return f"<CustomClass2 value={self.value}>"


# 様々な型が混在している場合
sample_list = [1, 2, "a", "b", CustomClass1(), CustomClass2(123), 8.0, 9.0]

# strで文字列に変換ができれば結合可能
print(",".join([str(i) for i in sample_list]))

【実行結果例】
1,2,a,b,<__main__.CustomClass1 object at 0x00000249B9E5A190>,<CustomClass2 value=123>,8.0,9.0

sample_list は、複数の型のオブジェクトを含んでいます。開発者が定義したようなカスタムクラスでも、自動的に __str__ メソッドが提供されるため CustomClass1 クラスに str を適用した場合は「<main.CustomClass1 object at 0x00000249B9E5A190>」のような文字列で表示され、基本的には問題は起こりません。

また、CustomClass2 では、開発者が __str__ メソッドを個別にオーバーライドして定義しています。例では文字列を適切に返却しているので問題は起こりませんが、仮に None のようなコードを書いてしまうと TypeError が発生するので注意してください。

異なる型を含むリストを扱う場合には、型チェックや例外処理を十分意識する必要があります。また、__str__ を個別実装するような場合には、None を返してしまったり、予期しない例外を発生させないように十分注意し、利用者に伝わりやすい簡潔な文字列表現を返却するように十分検討するようにしてください。

まとめ

Python で文字列を連結・結合する方法について解説しました。

+ 演算子や += 演算子を使って単純に連結・結合する方法や join メソッドについて例を使って使い方を説明しました。

少ない数の連結・結合では、+ 演算子や += 演算子を使った方が可読性も高く、適していますが、数が多くなる場合にはより効率的に処理が可能な join メソッドを使用することを検討してください。

文字列の連結・結合はプログラミングにおいては頻繁に出てきます。使い方をしっかり覚えて効率よく文字列の連結・結合をしてもらえればと思います。

あわせて読みたい

【Python Tech】プログラミングガイド