Pandas

[Python] Pandas – ベクトルの基本的な算術演算のやり方

Pandasでは、SeriesやDataFrameを使ってベクトルの基本的な算術演算を簡単に行うことができます。

PandasのSeriesは1次元のデータ構造で、DataFrameは2次元のデータ構造です。

これらのオブジェクトに対して、加算+、減算-、乗算*、除算/などの算術演算を直接適用できます。

これらの演算は要素ごとに実行され、異なるサイズのオブジェクトに対しては自動的にブロードキャストが行われます。

目次から探す

Pandasでのベクトル演算の基本
ベクトル演算の具体例
応用例
まとめ

Pandasでのベクトル演算の基本

Pandasのデータ構造

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

データ構造	説明
Series	一次元のラベル付き配列。インデックスを持ち、異なるデータ型を格納可能。
DataFrame	二次元のラベル付きデータ構造。行と列を持ち、異なるデータ型を格納可能。

SeriesとDataFrameの違い

Series: 一次元のデータ構造で、インデックスを持つ。

例えば、株価の時系列データなど。

DataFrame: 二次元のデータ構造で、行と列を持つ。

例えば、複数の株の時系列データをまとめたもの。

Seriesの基本的な使い方

Seriesを作成するには、以下のようにします。

import pandas as pd
# Seriesの作成
data = [10, 20, 30, 40]
index = ['a', 'b', 'c', 'd']
series = pd.Series(data, index=index)
print(series)

a    10
b    20
c    30
d    40
dtype: int64

DataFrameの基本的な使い方

DataFrameを作成するには、以下のようにします。

import pandas as pd
# DataFrameの作成
data = {
    'A': [1, 2, 3],
    'B': [4, 5, 6]
}
df = pd.DataFrame(data)
print(df)

ベクトル演算の基本

Pandasでは、SeriesやDataFrameに対してベクトル演算を行うことができます。

これにより、要素ごとの演算が簡単に行えます。

要素ごとの加算

SeriesやDataFrameの要素を加算するには、以下のようにします。

import pandas as pd
# Seriesの作成
s1 = pd.Series([1, 2, 3])
s2 = pd.Series([4, 5, 6])
# 要素ごとの加算
result = s1 + s2
print(result)

0    5
1    7
2    9
dtype: int64

要素ごとの減算

要素ごとの減算も同様に行えます。

import pandas as pd
# Seriesの作成
s1 = pd.Series([10, 20, 30])
s2 = pd.Series([1, 2, 3])
# 要素ごとの減算
result = s1 - s2
print(result)

0    9
1    18
2    27
dtype: int64

要素ごとの乗算

要素ごとの乗算は次のように行います。

import pandas as pd
# Seriesの作成
s1 = pd.Series([2, 3, 4])
s2 = pd.Series([5, 6, 7])
# 要素ごとの乗算
result = s1 * s2
print(result)

0    10
1    18
2    28
dtype: int64

要素ごとの除算

要素ごとの除算も簡単に行えます。

import pandas as pd
# Seriesの作成
s1 = pd.Series([10, 20, 30])
s2 = pd.Series([2, 5, 10])
# 要素ごとの除算
result = s1 / s2
print(result)

0    5.0
1    4.0
2    3.0
dtype: float64

演算時の注意点

インデックスが異なるSeries同士の演算を行うと、共通のインデックスのみが計算され、他のインデックスにはNaNが入ります。
DataFrame同士の演算も同様で、行と列のインデックスが一致する部分のみが計算されます。

インデックスの揃え方

インデックスを揃えるためには、reindexメソッドを使用します。

import pandas as pd
# Seriesの作成
s1 = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
s2 = pd.Series([4, 5], index=['b', 'c'])
# インデックスを揃える
s2_reindexed = s2.reindex(s1.index)
result = s1 + s2_reindexed
print(result)

a    NaN
b    6.0
c    8.0
dtype: float64

NaN(欠損値)の扱い

演算結果にNaNが含まれる場合、PandasはNaNを無視して計算を行います。

例えば、加算時に片方のSeriesにNaNが含まれていると、その部分は計算結果に影響しません。

異なるサイズのデータの演算(ブロードキャスト)

Pandasでは、異なるサイズのデータ同士の演算も可能です。

これをブロードキャストと呼びます。

例えば、スカラー値をSeriesやDataFrameに加算することができます。

import pandas as pd
# Seriesの作成
s = pd.Series([1, 2, 3])
# スカラー値との加算
result = s + 10
print(result)

0    11
1    12
2    13
dtype: int64

ベクトル演算の具体例

Series同士の演算

Series同士の演算は、インデックスが一致する要素同士で行われます。

以下の例では、2つのSeriesを加算しています。

import pandas as pd
# Seriesの作成
s1 = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
s2 = pd.Series([4, 5, 6], index=['a', 'b', 'c'])
# Series同士の加算
result = s1 + s2
print(result)

a    5
b    7
c    9
dtype: int64

同じ長さのSeriesの演算

同じ長さのSeries同士の演算は、インデックスが一致するため、簡単に行えます。

import pandas as pd
# 同じ長さのSeriesの作成
s1 = pd.Series([10, 20, 30])
s2 = pd.Series([1, 2, 3])
# 要素ごとの減算
result = s1 - s2
print(result)

0    9
1    18
2    27
dtype: int64

異なる長さのSeriesの演算

異なる長さのSeriesを演算すると、共通のインデックスのみが計算され、他のインデックスにはNaNが入ります。

import pandas as pd
# 異なる長さのSeriesの作成
s1 = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
s2 = pd.Series([4, 5], index=['b', 'c'])
# 要素ごとの加算
result = s1 + s2
print(result)

a    NaN
b    6.0
c    8.0
dtype: float64

DataFrame同士の演算

DataFrame同士の演算も、行と列のインデックスが一致する部分のみが計算されます。

import pandas as pd
# DataFrameの作成
df1 = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
df2 = pd.DataFrame({'A': [5, 6], 'B': [7, 8]})
# DataFrame同士の加算
result = df1 + df2
print(result)

A  B
0  6  10
1  8  12

同じ形状のDataFrameの演算

同じ形状のDataFrame同士の演算は、要素ごとに計算されます。

import pandas as pd
# 同じ形状のDataFrameの作成
df1 = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
df2 = pd.DataFrame({'A': [5, 6], 'B': [7, 8]})
# 要素ごとの乗算
result = df1 * df2
print(result)

   A   B
0  5  21
1 12  32

異なる形状のDataFrameの演算

異なる形状のDataFrameを演算する場合、事前にどちらかの形状に整形し、足りない部分を補う必要があります。

例えば以下の例では、df1 と df2 のインデックスを揃えることで、加算が可能にしています。

import pandas as pd

# ベースとなるDataFrame
df1 = pd.DataFrame({'A': [1, 2, 3]})
df2 = pd.DataFrame({'B': [4, 5]})

# df2のインデックスをdf1に合わせ、足りない部分を0で埋める
df2_reindexed = df2.reindex(df1.index, fill_value=0)

# DataFrame同士の加算
result = df1.add(df2_reindexed, fill_value=0)
print("\nResult of addition:")
print(result)

Result of addition:
     A    B
0  1.0  4.0
1  2.0  5.0
2  3.0  0.0

SeriesとDataFrameの演算

SeriesとDataFrameの演算も可能で、SeriesのインデックスがDataFrameの列名と一致する場合、addメソッドを使用することで自動的に行方向にブロードキャストされて演算されます。

import pandas as pd

# DataFrameの作成
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
s = pd.Series([10, 20, 30], index=[0, 1, 2])

# SeriesとDataFrameの加算（行方向にブロードキャスト）
result_add = df.add(s, axis=0)
result_sub = df.sub(s, axis=0)
result_mul = df.mul(s, axis=0)
result_div = df.div(s, axis=0)

print(f'加算:\n{result_add}')
print(f'減算:\n{result_sub}')
print(f'乗算:\n{result_mul}')
print(f'除算:\n{result_div}')

# この書き方は非推奨(形状が異なると全てNaNになる)
# result = df + s
# result = df - s
# result = df * s
# result = df / s

加算:
    A   B
0  11  14
1  22  25
2  33  36
減算:
    A   B
0  -9  -6
1 -18 -15
2 -27 -24
乗算:
    A    B
0  10   40
1  40  100
2  90  180
除算:
     A     B
0  0.1  0.40
1  0.1  0.25
2  0.1  0.20

応用例

スカラーとの演算

Pandasでは、スカラー値(単一の数値)との演算が可能です。

スカラー値をSeriesやDataFrameに加算、減算、乗算、除算することで、全ての要素に対して同じ演算を適用できます。

スカラー値との加算

スカラー値をSeriesに加算する例です。

import pandas as pd
# Seriesの作成
s = pd.Series([1, 2, 3])
# スカラー値との加算
result = s + 5
print(result)

0    6
1    7
2    8
dtype: int64

スカラー値との乗算

スカラー値をDataFrameに乗算する例です。

import pandas as pd
# DataFrameの作成
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
# スカラー値との乗算
result = df * 2
print(result)

A  B
0  2  6
1  4  8

行や列ごとの演算

Pandasでは、行や列ごとに演算を行うこともできます。

これにより、特定の行や列に対して一括で演算を適用できます。

行ごとの演算

DataFrameの各行に対して演算を行う例です。

import pandas as pd
# DataFrameの作成
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
# 行ごとの合計を計算
row_sum = df.sum(axis=1)
print(row_sum)

0    4
1    6
dtype: int64

列ごとの演算

DataFrameの各列に対して演算を行う例です。

import pandas as pd
# DataFrameの作成
df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
# 列ごとの合計を計算
col_sum = df.sum(axis=0)
print(col_sum)

A    3
B    7
dtype: int64

条件付き演算

条件に基づいて要素を選択し、演算を行うことも可能です。

これにより、特定の条件を満たす要素に対してのみ演算を適用できます。

条件に基づく要素の選択と演算

特定の条件を満たす要素を選択し、演算を行う例です。

import pandas as pd
# DataFrameの作成
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
# A列の値が2以上の行を選択し、B列に5を加算
df.loc[df['A'] >= 2, 'B'] += 5
print(df)

条件付きで異なる値を適用する

条件に基づいて異なる値を適用する例です。

import pandas as pd
# DataFrameの作成
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
# A列の値が2以上の場合はB列を10に、それ以外はB列を0に設定
df['B'] = df['B'].where(df['A'] < 2, 10)
print(df)