Pandas

[Python] Pandas – 2つのベクトルを結合する方法

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

Pandasで2つのベクトル(SeriesやDataFrameの列)を結合するには、pd.concat()やDataFrameのメソッドを使用します。

pd.concat([vec1, vec2], axis=1)を使うと、2つのベクトルを列方向に結合できます。

また、DataFrameのassign()メソッドを使って新しい列として追加することも可能です。

vec1.append(vec2)は行方向に結合しますが、非推奨です。

目次から探す

Pandasでベクトルを結合する基本的な方法
pd.concat()を使ったベクトルの結合
DataFrame.assign()を使ったベクトルの結合
merge()を使った結合
応用例：異なる長さのベクトルを結合する
応用例：複数のベクトルを一度に結合する
応用例：異なるデータ型のベクトルを結合する
まとめ

Pandasでベクトルを結合する基本的な方法

Pandasの基本的なデータ構造：SeriesとDataFrame

Pandasは、データ解析のための強力なライブラリで、主に2つのデータ構造を提供しています。

データ構造	説明
Series	一次元のラベル付き配列で、異なるデータ型を持つことができます。
DataFrame	二次元のラベル付きデータ構造で、異なるデータ型の列を持つことができます。

Seriesは、リストや配列のように扱うことができ、DataFrameは、表形式のデータを扱うのに適しています。

これらのデータ構造を使って、データの操作や分析を行います。

2つのベクトルを結合するとは？

2つのベクトルを結合するとは、2つのデータ構造(通常はSeriesまたはDataFrame)を一つにまとめることを指します。

これにより、データの統合や新しい情報の生成が可能になります。

例えば、異なる情報を持つ2つのベクトルを結合することで、より豊富なデータセットを作成できます。

Pandasでの結合方法の概要

Pandasでは、ベクトルを結合するためにいくつかの方法があります。

主な方法は以下の通りです。

方法	説明
`pd.concat()`	複数のSeriesやDataFrameを結合するための関数。
`DataFrame.assign()`	新しい列を追加するためのメソッド。
`merge()`	キーを使って2つのDataFrameを結合するためのメソッド。

これらの方法を使うことで、データの結合や統合が簡単に行えます。

次のセクションでは、具体的な結合方法について詳しく解説します。

pd.concat()を使ったベクトルの結合

pd.concat()の基本的な使い方

pd.concat()は、複数のSeriesやDataFrameを結合するための関数です。

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

import pandas as pd
# 例として2つのSeriesを作成
series1 = pd.Series([1, 2, 3])
series2 = pd.Series([4, 5, 6])
# Seriesを結合
result = pd.concat([series1, series2])
print(result)

0    1
1    2
2    3
0    4
1    5
2    6
dtype: int64

このように、pd.concat()を使うことで、簡単に複数のベクトルを結合することができます。

列方向に結合する方法(axis=1)

pd.concat()では、axisオプションを使って結合の方向を指定できます。

axis=1を指定すると、列方向に結合されます。

import pandas as pd
# 例として2つのDataFrameを作成
df1 = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
df2 = pd.DataFrame({'C': [5, 6], 'D': [7, 8]})
# 列方向に結合
result = pd.concat([df1, df2], axis=1)
print(result)

   A  B  C  D
0  1  3  5  7
1  2  4  6  8

このように、axis=1を指定することで、列を追加する形で結合できます。

行方向に結合する方法(axis=0)

デフォルトでは、pd.concat()はaxis=0(行方向)で結合を行います。

これにより、行を追加する形でデータを結合できます。

import pandas as pd
# 例として2つのDataFrameを作成
df1 = pd.DataFrame({'A': [1, 2]})
df2 = pd.DataFrame({'A': [3, 4]})
# 行方向に結合
result = pd.concat([df1, df2], axis=0)
print(result)

このように、axis=0を指定することで、行を追加する形で結合できます。

インデックスの扱い方(ignore_indexオプション)

pd.concat()では、ignore_indexオプションを使うことで、結合後のインデックスを再設定することができます。

これをTrueに設定すると、インデックスが0から始まる連番にリセットされます。

import pandas as pd
# 例として2つのDataFrameを作成
df1 = pd.DataFrame({'A': [1, 2]})
df2 = pd.DataFrame({'A': [3, 4]})
# 行方向に結合し、インデックスをリセット
result = pd.concat([df1, df2], ignore_index=True)
print(result)

このように、ignore_index=Trueを指定することで、インデックスをリセットできます。

keysオプションを使った階層的な結合

pd.concat()では、keysオプションを使って階層的なインデックスを作成することもできます。

これにより、結合したデータの元のデータフレームを識別しやすくなります。

import pandas as pd
# 例として2つのDataFrameを作成
df1 = pd.DataFrame({'A': [1, 2]})
df2 = pd.DataFrame({'A': [3, 4]})
# 階層的なインデックスを持つ結合
result = pd.concat([df1, df2], keys=['df1', 'df2'])
print(result)

このように、keysオプションを使うことで、結合したデータに階層的なインデックスを付与できます。

これにより、データの出所を明確にすることができます。

DataFrame.assign()を使ったベクトルの結合

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

assign()メソッドは、既存のDataFrameに新しい列を追加するための便利な方法です。

このメソッドは、元のDataFrameを変更せずに新しいDataFrameを返します。

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

import pandas as pd
# 例としてDataFrameを作成
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
# assign()メソッドを使って新しい列を追加
new_df = df.assign(C=[5, 6])
print(new_df)

   A  B  C
0  1  3  5
1  2  4  6

このように、assign()メソッドを使うことで、新しい列を簡単に追加できます。

新しい列としてベクトルを追加する方法

assign()メソッドを使用して、新しい列としてベクトルを追加する際には、追加したいデータをリストやSeriesとして指定します。

以下の例では、列Cに新しいベクトルを追加しています。

import pandas as pd
# 例としてDataFrameを作成
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
# 列Cとして新しいベクトルを追加
new_df = df.assign(C=pd.Series([5, 6]))
print(new_df)

   A  B  C
0  1  3  5
1  2  4  6

このように、assign()メソッドを使って新しい列を追加することができます。

複数のベクトルを同時に追加する方法

assign()メソッドでは、複数の列を同時に追加することも可能です。

複数の列を追加する場合は、各列をカンマで区切って指定します。

import pandas as pd
# 例としてDataFrameを作成
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
# 複数の列を同時に追加
new_df = df.assign(C=pd.Series([5, 6]), D=pd.Series([7, 8]))
print(new_df)

   A  B  C  D
0  1  3  5  7
1  2  4  6  8

このように、assign()メソッドを使うことで、複数のベクトルを同時に追加することができます。

これにより、データの拡張が簡単に行えます。

merge()を使った結合

merge()の基本的な使い方

merge()メソッドは、2つのDataFrameを特定のキーに基づいて結合するための方法です。

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

import pandas as pd
# 例として2つのDataFrameを作成
df1 = pd.DataFrame({'key': ['A', 'B', 'C'], 'value1': [1, 2, 3]})
df2 = pd.DataFrame({'key': ['B', 'C', 'D'], 'value2': [4, 5, 6]})
# merge()メソッドを使って結合
result = pd.merge(df1, df2, on='key')
print(result)

  key  value1  value2
0   B       2       4
1   C       3       5

このように、merge()を使うことで、指定したキーに基づいて2つのDataFrameを結合できます。

onオプションを使ったキーによる結合

merge()メソッドでは、onオプションを使って結合に使用するキーを指定します。

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

import pandas as pd
# 例として2つのDataFrameを作成
df1 = pd.DataFrame({'key1': ['A', 'B', 'C'], 'value1': [1, 2, 3]})
df2 = pd.DataFrame({'key2': ['B', 'C', 'D'], 'value2': [4, 5, 6]})
# onオプションを使って異なるキーで結合
result = pd.merge(df1, df2, left_on='key1', right_on='key2')
print(result)

  key1  value1 key2  value2
0    B       2    B       4
1    C       3    C       5

このように、onオプションを使うことで、異なる列名を持つキーによる結合が可能です。

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

merge()メソッドでは、内部結合(inner join)と外部結合(outer join)を選択できます。

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

一方、外部結合は、どちらかのDataFrameに存在するすべてのキーを含む結果を返します。

import pandas as pd
# 例として2つのDataFrameを作成
df1 = pd.DataFrame({'key': ['A', 'B', 'C'], 'value1': [1, 2, 3]})
df2 = pd.DataFrame({'key': ['B', 'C', 'D'], 'value2': [4, 5, 6]})
# 内部結合
inner_result = pd.merge(df1, df2, on='key', how='inner')
print("内部結合の結果:")
print(inner_result)
# 外部結合
outer_result = pd.merge(df1, df2, on='key', how='outer')
print("\n外部結合の結果:")
print(outer_result)

内部結合の結果:
  key  value1  value2
0   B       2       4
1   C       3       5
外部結合の結果:
  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

このように、内部結合と外部結合の違いを理解することで、データの結合方法を適切に選択できます。

merge()とconcat()の違い

merge()とconcat()は、どちらもデータを結合するためのメソッドですが、使用する目的が異なります。

特徴	`merge()`	`concat()`
結合の方法	キーに基づいて結合	行または列方向に結合
結合の対象	DataFrame同士の結合	複数のSeriesまたはDataFrameの結合
結合の種類	内部結合、外部結合が可能	行方向または列方向の単純な結合

merge()は、特定のキーに基づいてデータを結合するのに対し、concat()は単純にデータを追加するために使用されます。

データの結合方法を選択する際には、これらの違いを考慮することが重要です。

応用例：異なる長さのベクトルを結合する

異なる長さのベクトルを結合する際の注意点

異なる長さのベクトルを結合する場合、注意が必要です。

Pandasでは、長さが異なるSeriesやDataFrameを結合すると、短い方のデータに対してはNaN(欠損値)が自動的に挿入されます。

これにより、データの整合性が保たれますが、意図しない結果を招くこともあるため、結合後のデータを確認することが重要です。

import pandas as pd
# 異なる長さのSeriesを作成
series1 = pd.Series([1, 2, 3])
series2 = pd.Series([4, 5])
# Seriesを結合
result = pd.concat([series1, series2])
print(result)

0    1
1    2
2    3
0    4
1    5
dtype: int64

このように、異なる長さのベクトルを結合する際には、NaNが挿入されることを理解しておく必要があります。

欠損値の処理方法(NaNの扱い)

結合後に発生するNaN(欠損値)は、データ分析において重要な要素です。

NaNは、データが欠けていることを示し、計算や分析に影響を与える可能性があります。

Pandasでは、NaNを扱うためのさまざまなメソッドが用意されています。

例えば、isna()メソッドを使って欠損値を確認したり、dropna()メソッドを使って欠損値を含む行を削除したりできます。

import pandas as pd
# 例としてDataFrameを作成
df = pd.DataFrame({'A': [1, 2, None], 'B': [4, None, 6]})
# 欠損値の確認
print(df.isna())

A      B
0  False  False
1  False   True
2   True  False

このように、isna()メソッドを使うことで、欠損値の位置を確認できます。

fillna()を使った欠損値の補完

fillna()メソッドを使用すると、NaNを特定の値で補完することができます。

これにより、データの整合性を保ちながら、分析を行うことが可能になります。

以下の例では、NaNを0で補完しています。

import pandas as pd
# 例としてDataFrameを作成
df = pd.DataFrame({'A': [1, 2, None], 'B': [4, None, 6]})
# 欠損値を0で補完
filled_df = df.fillna(0)
print(filled_df)

     A    B
0  1.0  4.0
1  2.0  0.0
2  0.0  6.0

このように、fillna()メソッドを使うことで、欠損値を簡単に補完することができます。

補完方法は、0以外にも平均値や中央値など、さまざまな方法を選択できます。

データの特性に応じて適切な補完方法を選ぶことが重要です。

応用例：複数のベクトルを一度に結合する

複数のベクトルをpd.concat()で結合する

pd.concat()を使用すると、複数のSeriesやDataFrameを一度に結合することができます。

リストに結合したいデータを格納し、pd.concat()に渡すことで、簡単に結合できます。

import pandas as pd
# 例として3つのSeriesを作成
series1 = pd.Series([1, 2, 3])
series2 = pd.Series([4, 5, 6])
series3 = pd.Series([7, 8, 9])
# 複数のSeriesを結合
result = pd.concat([series1, series2, series3])
print(result)

0    1
1    2
2    3
0    4
1    5
2    6
0    7
1    8
2    9
dtype: int64

このように、pd.concat()を使うことで、複数のベクトルを一度に結合することができます。

DataFrameに複数の列を追加する方法

assign()メソッドを使用すると、DataFrameに複数の列を同時に追加することができます。

各列をカンマで区切って指定することで、簡単に新しい列を追加できます。

import pandas as pd
# 例としてDataFrameを作成
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
# 複数の列を同時に追加
new_df = df.assign(C=pd.Series([5, 6]), D=pd.Series([7, 8]))
print(new_df)

   A  B  C  D
0  1  3  5  7
1  2  4  6  8

このように、assign()メソッドを使うことで、DataFrameに複数の列を一度に追加することができます。

ループを使って動的にベクトルを結合する

ループを使用することで、動的に複数のベクトルを結合することも可能です。

例えば、リストに格納された複数のSeriesを結合する場合、forループを使って各Seriesを追加することができます。

import pandas as pd
# 例として空のリストを作成
series_list = []
# ループを使ってSeriesを追加
for i in range(1, 4):
    series_list.append(pd.Series([i * j for j in range(1, 4)]))
# 複数のSeriesを結合
result = pd.concat(series_list)
print(result)

0    1
1    2
2    3
0    2
1    4
2    6
0    3
1    6
2    9
dtype: int64

このように、ループを使うことで、動的に複数のベクトルを結合することができます。

これにより、データの生成や結合を柔軟に行うことが可能になります。

応用例：異なるデータ型のベクトルを結合する

異なるデータ型のベクトルを結合する際の注意点

異なるデータ型のベクトルを結合する際には、データ型の整合性に注意が必要です。

Pandasでは、異なるデータ型を持つSeriesやDataFrameを結合することができますが、結合後のデータ型は自動的に上位のデータ型に変換されることがあります。

例えば、整数型と浮動小数点型を結合すると、結果は浮動小数点型になります。

このため、意図しないデータ型の変換が行われる可能性があるため、結合前にデータ型を確認しておくことが重要です。

import pandas as pd
# 異なるデータ型のSeriesを作成
series1 = pd.Series([1, 2, 3])  # 整数型
series2 = pd.Series([4.0, 5.0, 6.0])  # 浮動小数点型
# Seriesを結合
result = pd.concat([series1, series2])
print(result)

0    1.0
1    2.0
2    3.0
0    4.0
1    5.0
2    6.0
dtype: float64

このように、異なるデータ型を結合すると、結果は浮動小数点型になります。

astype()を使ったデータ型の変換

astype()メソッドを使用すると、SeriesやDataFrameのデータ型を明示的に変換することができます。

これにより、結合前にデータ型を統一することが可能です。

import pandas as pd
# 異なるデータ型のSeriesを作成
series1 = pd.Series([1, 2, 3])  # 整数型
series2 = pd.Series(['4', '5', '6'])  # 文字列型
# series2を整数型に変換
series2 = series2.astype(int)
# Seriesを結合
result = pd.concat([series1, series2])
print(result)

0    1
1    2
2    3
0    4
1    5
2    6
dtype: int64

このように、astype()を使うことで、データ型を明示的に変換し、結合後のデータ型を統一することができます。

結合後のデータ型の確認方法

結合後のデータ型を確認するには、dtype属性を使用します。

これにより、各SeriesやDataFrameのデータ型を簡単に確認できます。

import pandas as pd
# 異なるデータ型のSeriesを作成
series1 = pd.Series([1, 2, 3])  # 整数型
series2 = pd.Series([4.0, 5.0, 6.0])  # 浮動小数点型
# Seriesを結合
result = pd.concat([series1, series2])
# 結合後のデータ型を確認
print("結合後のデータ型:", result.dtype)