はい、承知いたしました。Pandasのsum関数に関する詳細な説明を含む記事を作成します。約5000文字（バイト）を目安に記述します。
Pandas sum 関数：Series/DataFrameの合計計算ガイド
データ分析において、数値データの合計を求めることは非常に頻繁に行われる操作です。Pandasライブラリは、この合計計算を効率的かつ柔軟に行うためのsum関数をSeriesおよびDataFrameオブジェクトに提供しています。
この記事では、Pandasのsum関数について、基本的な使い方から、各種引数の詳細、応用例、さらには使用上の注意点まで、網羅的に解説します。これを読めば、あなたのデータ集計タスクがよりスムーズになるでしょう。
はじめに：データ集計とsum関数の役割
データ分析プロジェクトでは、まず生データを読み込み、次にデータの探索的分析（EDA）を行います。このEDAの初期段階や、その後の特徴量エンジニアリング、レポート作成など、様々な局面で数値列の合計値を計算する必要があります。
- 単純な合計: ある列全体の合計を知りたい。
- 行または列の合計: 各行の合計値、あるいは各列の合計値を知りたい。
- グループごとの合計: カテゴリ別に集計した合計値を知りたい。
- 条件付き合計: 特定の条件を満たすデータのみの合計を知りたい。
Pandasのsum関数は、これらの様々な合計計算要求に対して、直感的かつパワフルな解決策を提供します。Seriesに対しては単一の合計値を、DataFrameに対しては指定した軸に沿った合計値を計算します。
Pandas sum 関数の基本
まずは、SeriesとDataFrameそれぞれにおけるsum関数の最も基本的な使い方を見ていきましょう。
Seriesでの使用
Seriesは1次元のラベル付き配列です。Seriesに対してsum()を呼び出すと、そのSeriesに含まれるすべての数値要素の合計値が計算され、単一のスカラー値として返されます。
例：
“`python
import pandas as pd
import numpy as np
サンプルSeriesを作成
s = pd.Series([10, 20, 30, 40, 50])
Seriesの合計を計算
total_sum_s = s.sum()
print(“Series:”, s)
print(“Seriesの合計:”, total_sum_s)
“`
出力結果：
Series: 0 10
1 20
2 30
3 40
4 50
dtype: int64
Seriesの合計: 150
欠損値（NaN）が含まれている場合、デフォルトではNaNは無視されて計算されます。この挙動については後述のskipna引数で制御できます。
“`python
欠損値を含むSeries
s_with_nan = pd.Series([10, 20, np.nan, 40, 50])
欠損値を無視して合計を計算 (デフォルト)
total_sum_s_nan = s_with_nan.sum()
print(“\nNaNを含むSeries:”, s_with_nan)
print(“NaNを無視した合計:”, total_sum_s_nan)
“`
出力結果：
NaNを含むSeries: 0 10.0
1 20.0
2 NaN
3 40.0
4 50.0
dtype: float64
NaNを無視した合計: 120.0
DataFrameでの使用
DataFrameは2次元のラベル付きデータ構造です。DataFrameに対してsum()を呼び出すと、デフォルトでは各列（列方向、垂直方向）ごとの合計が計算されます。結果として、元のDataFrameの列ラベルをインデックスとするSeriesが返されます。
例：
“`python
サンプルDataFrameを作成
data = {‘A’: [1, 2, 3, 4],
‘B’: [5, 6, 7, 8],
‘C’: [9, 10, 11, 12]}
df = pd.DataFrame(data)
DataFrameの各列の合計を計算 (デフォルト)
column_sums = df.sum()
print(“DataFrame:\n”, df)
print(“\n各列の合計:\n”, column_sums)
“`
出力結果：
“`
DataFrame:
A B C
0 1 5 9
1 2 6 10
2 3 7 11
3 4 8 12
各列の合計:
A 10
B 26
C 42
dtype: int64
“`
DataFrameでは、合計を計算する方向（軸）を指定することができます。これがsum関数における最も重要な引数の一つであるaxisです。
sum関数の主要な引数
sum関数はいくつかの引数を持っており、これらを使い分けることで合計計算の挙動を詳細に制御できます。主要な引数は以下の通りです。
axis: 合計を計算する軸を指定します。skipna: 欠損値（NaN）を無視するかどうかを指定します。level: MultiIndexを持つ場合に、特定のレベルでグループ化して合計を計算します。numeric_only: 数値型の列のみを対象とするかどうかを指定します。min_count: 合計を計算するために必要な、非NaN値の最小数を指定します。
これらの引数について、それぞれ詳しく見ていきましょう。
axis 引数：合計計算の方向を指定する
axis引数は、DataFrameの合計計算において、どの方向（軸）で計算を行うかを指定します。
axis=0または'index': 各列について、行方向に合計を計算します。（デフォルト）axis=1または'columns': 各行について、列方向に合計を計算します。
例：
“`python
上記で使用したDataFrame
print(“DataFrame:\n”, df)
axis=0 (デフォルト): 各列の合計
column_sums_explicit = df.sum(axis=0)
print(“\naxis=0 (各列の合計):\n”, column_sums_explicit)
axis=1: 各行の合計
row_sums = df.sum(axis=1)
print(“\naxis=1 (各行の合計):\n”, row_sums)
“`
出力結果：
“`
DataFrame:
A B C
0 1 5 9
1 2 6 10
2 3 7 11
3 4 8 12
axis=0 (各列の合計):
A 10
B 26
C 42
dtype: int64
axis=1 (各行の合計):
0 15
1 18
2 21
3 24
dtype: int64
“`
axis=0を指定すると、結果は列名をインデックスとするSeriesになります。これはDataFrameの各列を下方向に合計した結果です。
axis=1を指定すると、結果は行インデックスをインデックスとするSeriesになります。これはDataFrameの各行を右方向に合計した結果です。
どちらの軸で計算を行うかは、データの構造と分析の目的に依存します。例えば、「各商品の売上合計」を知りたい場合は商品が列、「各日の総売上」を知りたい場合は日がインデックス（行）になっている、といったケースでaxisを適切に使い分けます。
skipna 引数：欠損値（NaN）の扱いを制御する
skipna引数は、合計計算において欠損値（NaN）をどのように扱うかを指定します。
skipna=True: 欠損値を無視して、存在する非NaN値のみで合計を計算します。（デフォルト）skipna=False: 欠損値が一つでも含まれている場合に、合計結果をNaNとします。
デフォルトではskipna=Trueとなっており、これがデータ分析では一般的な挙動です。欠損値がある行や列全体を合計不可能とするのではなく、利用可能なデータから可能な限りの合計値を計算します。
例：
“`python
欠損値を含むDataFrame
data_nan = {‘A’: [1, 2, np.nan, 4],
‘B’: [5, np.nan, 7, 8],
‘C’: [9, 10, 11, 12],
‘D’: [np.nan, np.nan, np.nan, np.nan]} # 全てNaNの列
df_nan = pd.DataFrame(data_nan)
print(“NaNを含むDataFrame:\n”, df_nan)
skipna=True (デフォルト): NaNを無視して合計
column_sums_skipna_true = df_nan.sum(axis=0, skipna=True)
row_sums_skipna_true = df_nan.sum(axis=1, skipna=True)
print(“\nskipna=True (デフォルト):\n”)
print(“各列の合計:\n”, column_sums_skipna_true)
print(“各行の合計:\n”, row_sums_skipna_true)
skipna=False: NaNが含まれると合計もNaN
column_sums_skipna_false = df_nan.sum(axis=0, skipna=False)
row_sums_skipna_false = df_nan.sum(axis=1, skipna=False)
print(“\nskipna=False:\n”)
print(“各列の合計:\n”, column_sums_skipna_false)
print(“各行の合計:\n”, row_sums_skipna_false)
“`
出力結果：
“`
NaNを含むDataFrame:
A B C D
0 1.0 5.0 9 NaN
1 2.0 NaN 10 NaN
2 NaN 7.0 11 NaN
3 4.0 8.0 12 NaN
skipna=True (デフォルト):
各列の合計:
A 7.0
B 20.0
C 42.0
D 0.0
dtype: float64
各行の合計:
0 15.0
1 12.0
2 18.0
3 24.0
dtype: float64
skipna=False:
各列の合計:
A NaN
B NaN
C 42.0
D NaN
dtype: float64
各行の合計:
0 NaN
1 NaN
2 NaN
3 NaN
dtype: float64
“`
skipna=Trueの場合、例えば列’A’は1+2+4=7、列’B’は5+7+8=20となります。列’D’は全てNaNなので合計は0.0になります（非NaN値の合計が0）。
skipna=Falseの場合、列’A’にはNaNが含まれるため合計はNaN、列’B’も同様にNaN、列’C’はNaNを含まないため合計は42.0、列’D’は全てNaNなので合計もNaNとなります。行方向も同様の挙動を示します。
skipna=Falseは、データに一つでも欠損がある場合はその合計は無効としたい、といった厳密なケースで使用されます。
level 引数：MultiIndexでの合計計算
DataFrameやSeriesがMultiIndex（複数の階層を持つインデックス）を持つ場合、level引数を使用して、特定のインデックスレベルでグループ化しながら合計を計算することができます。
例：
“`python
MultiIndexを持つSeriesを作成
multi_index_s = pd.Series([1, 2, 3, 4, 5, 6],
index=pd.MultiIndex.from_product([[‘A’, ‘B’], [1, 2, 3]],
names=[‘Outer’, ‘Inner’]))
print(“MultiIndex Series:\n”, multi_index_s)
全体の合計
total_sum_multi_s = multi_index_s.sum()
print(“\n全体の合計:”, total_sum_multi_s)
‘Outer’ レベルでグループ化して合計
sum_by_outer = multi_index_s.sum(level=’Outer’)
print(“\n’Outer’レベルごとの合計:\n”, sum_by_outer)
‘Inner’ レベルでグループ化して合計
sum_by_inner = multi_index_s.sum(level=’Inner’)
print(“\n’Inner’レベルごとの合計:\n”, sum_by_inner)
“`
出力結果：
“`
MultiIndex Series:
Outer Inner
A 1 1
2 2
3 3
B 1 4
2 5
3 6
dtype: int64
全体の合計: 21
‘Outer’レベルごとの合計:
Outer
A 6
B 15
dtype: int64
‘Inner’レベルごとの合計:
Inner
1 5
2 7
3 9
dtype: int64
“`
DataFrameの場合も同様に、axis引数と組み合わせて使用できます。axis=0の場合は行インデックスのレベル、axis=1の場合は列インデックスのレベルを指定します。
例（DataFrameでのMultiIndex）：
“`python
MultiIndexを持つDataFrameを作成
index = pd.MultiIndex.from_product([[‘A’, ‘B’], [‘X’, ‘Y’]], names=[‘Level1’, ‘Level2’])
columns = pd.MultiIndex.from_product([[‘C1’, ‘C2’], [‘P’, ‘Q’]], names=[‘ColLevel1’, ‘ColLevel2’])
data_multi_df = np.arange(16).reshape(4, 4)
df_multi = pd.DataFrame(data_multi_df, index=index, columns=columns)
print(“MultiIndex DataFrame:\n”, df_multi)
行インデックス Level1 ごとに列方向に合計 (axis=1)
row_sum_by_level1 = df_multi.sum(axis=1, level=’Level1′)
print(“\n行インデックス ‘Level1’ ごとの合計 (axis=1):\n”, row_sum_by_level1)
列インデックス ColLevel1 ごとに行方向に合計 (axis=0)
col_sum_by_level1 = df_multi.sum(axis=0, level=’ColLevel1′)
print(“\n列インデックス ‘ColLevel1’ ごとの合計 (axis=0):\n”, col_sum_by_level1)
“`
出力結果：
“`
MultiIndex DataFrame:
ColLevel1 C1 C2
ColLevel2 P Q P Q
Level1 Level2
A X 0 1 2 3
Y 4 5 6 7
B X 8 9 10 11
Y 12 13 14 15
行インデックス ‘Level1’ ごとの合計 (axis=1):
ColLevel1 C1 C2
Level1
A 10 18
B 42 50
列インデックス ‘ColLevel1’ ごとの合計 (axis=0):
ColLevel1 C1 C2
ColLevel2
P 24 32
Q 28 36
“`
sum(axis=1, level='Level1') は、行インデックスの最上位レベル(‘Level1’)が同じ行をグループ化し、そのグループ内で列方向に合計します。結果は、’Level1’をインデックス、元の列をカラムとするDataFrameになります。
sum(axis=0, level='ColLevel1') は、列インデックスの最上位レベル(‘ColLevel1’)が同じ列をグループ化し、そのグループ内で行方向に合計します。結果は、元の行インデックスをインデックス、’ColLevel1’をカラムとするDataFrameになります。
level引数は、MultiIndexを持つ複雑なデータ構造から、特定の集計レベルでの合計を素早く計算したい場合に非常に便利です。
numeric_only 引数：数値列のみを対象とするか
numeric_only引数は、合計計算の対象を数値型のデータを含む列（DataFrameの場合）や要素（Seriesの場合）に限定するかどうかを指定します。
numeric_only=True: 数値型の列/要素のみを対象とします。非数値型の列/要素は無視されます。numeric_only=False: 可能であれば、非数値型の列/要素に対しても合計（結合など）を試みます。
この引数のデフォルト値はPandasのバージョンによって異なります。
* Pandas 1.x以前では、デフォルトはFalseで、非数値列に対して文字列結合などを試みることがありました（警告が出ることが多い）。
* Pandas 2.0以降では、デフォルトはTrueに変更されました。 これは、非数値列に対する合計操作が意図しない結果を招くことが多いため、より安全な挙動とするための変更です。
現在の標準的なPandasのバージョン（2.0以降）では、特に指定しない限り数値列のみが対象となります。
例：
“`python
数値型と非数値型を含むDataFrame
data_mixed = {‘A’: [1, 2, 3],
‘B’: [4.5, 5.5, 6.5],
‘C’: [‘X’, ‘Y’, ‘Z’],
‘D’: [10, 20, np.nan]}
df_mixed = pd.DataFrame(data_mixed)
print(“数値型と非数値型を含むDataFrame:\n”, df_mixed)
numeric_only=True (Pandas 2.0以降のデフォルト): 数値列のみを対象
column_sums_numeric_only_true = df_mixed.sum(axis=0, numeric_only=True)
print(“\nnumeric_only=True (数値列のみ):\n”, column_sums_numeric_only_true)
numeric_only=False: 非数値列も対象に試みる (通常、エラーや意図しない結果になる)
try-exceptで囲むか、警告を無視する必要がある場合が多い
例として、非数値列を含む合計は通常 TypeError を引き起こします。
Pandas 1.x 以前では文字列結合を試みることもありましたが、2.0以降はデフォルトTrueで安全です。
try:
# Panddas 2.0以降では、数値列以外を対象に含めようとすると通常エラーになります。
# Pandas 1.x 以前では C 列に対して文字列結合 ‘XYZ’ を試みたりしました。
column_sums_numeric_only_false = df_mixed.sum(axis=0, numeric_only=False)
print(“\nnumeric_only=False (エラーまたは警告の可能性):\n”, column_sums_numeric_only_false)
except TypeError as e:
print(f”\nnumeric_only=False を指定した場合に発生したエラー: {e}”)
“`
出力結果（Pandas 2.0以降の環境を想定）：
“`
数値型と非数値型を含むDataFrame:
A B C D
0 1 4.5 X 10.0
1 2 5.5 Y 20.0
2 3 6.5 Z NaN
numeric_only=True (数値列のみ):
A 6.0
B 16.5
D 30.0
dtype: float64
numeric_only=False を指定した場合に発生したエラー: unsupported operand type(s) for +: ‘int’ and ‘str’
“`
numeric_only=Trueの場合、列’C’（文字列型）は無視され、数値型の列’A’, ‘B’, ‘D’のみが合計されます。
numeric_only=Falseの場合、列’C’も合計の対象に含めようとしますが、数値と文字列の合計は定義されていないため、TypeErrorが発生します。
したがって、特に古いバージョンのコードを実行する場合や、意図的に非数値型に対する特別な合計処理（例えば文字列の結合など）を行いたい場合を除いては、numeric_only=Trueを使うか、Pandas 2.0以降のデフォルト挙動に任せるのが安全です。
min_count 引数：合計に必要な非NaN値の最小数
min_count引数は、合計を計算して非NaNの結果を返すために必要な、その軸に沿った非NaN値の最小数を指定します。指定された数よりも非NaN値が少ない場合、合計結果はNaNとなります。
min_count=0: 全ての要素がNaNであっても合計を計算します。この場合、結果は0になります。（これがPandasのデフォルトの挙動であり、skipna=Trueの場合に非NaN値が一つもない場合のデフォルト結果が0になる理由です。）min_count=1以上: 指定した数以上の非NaN値がない場合は結果をNaNとします。
これは、例えば「少なくとも3日分のデータがある場合にのみ、その週の合計を計算したい」といったシナリオで役立ちます。
例：
“`python
欠損値が多く含まれるDataFrame
data_sparse = {‘A’: [1, np.nan, 3, np.nan, 5],
‘B’: [np.nan, np.nan, np.nan, np.nan, np.nan],
‘C’: [6, 7, np.nan, 9, 10]}
df_sparse = pd.DataFrame(data_sparse)
print(“欠損値が多く含まれるDataFrame:\n”, df_sparse)
min_count=0 (デフォルト): NaNのみの場合は0
column_sums_min_0 = df_sparse.sum(axis=0, skipna=True, min_count=0)
print(“\nmin_count=0 (デフォルト):\n”, column_sums_min_0)
min_count=1: 非NaN値が1つ以上あれば合計
column_sums_min_1 = df_sparse.sum(axis=0, skipna=True, min_count=1)
print(“\nmin_count=1:\n”, column_sums_min_1)
min_count=3: 非NaN値が3つ以上なければNaN
column_sums_min_3 = df_sparse.sum(axis=0, skipna=True, min_count=3)
print(“\nmin_count=3:\n”, column_sums_min_3)
“`
出力結果：
“`
欠損値が多く含まれるDataFrame:
A B C
0 1.0 NaN 6.0
1 NaN NaN 7.0
2 3.0 NaN NaN
3 NaN NaN 9.0
4 5.0 NaN 10.0
min_count=0 (デフォルト):
A 9.0
B 0.0
C 32.0
dtype: float64
min_count=1:
A 9.0
B NaN
C 32.0
dtype: float64
min_count=3:
A 9.0
B NaN
C 32.0
dtype: float64
“`
解説：
* 列’A’：非NaN値は1, 3, 5 (3つ)。合計は9.0。min_count=0, 1, 3のいずれも満たすため、結果は9.0。
* 列’B’：非NaN値はなし (0つ)。
* min_count=0：非NaN値が0なので、合計は0.0。
* min_count=1：非NaN値が1未満なので、結果はNaN。
* min_count=3：非NaN値が3未満なので、結果はNaN。
* 列’C’：非NaN値は6, 7, 9, 10 (4つ)。合計は32.0。min_count=0, 1, 3のいずれも満たすため、結果は32.0。
このようにmin_countを使うことで、「十分なデータが存在する場合にのみ合計を計算する」というロジックを簡単に実装できます。
応用的な使用例
sum関数は単独で使用するだけでなく、他のPandas機能と組み合わせることでさらに強力になります。
groupby().sum(): グループごとの合計
データ分析で最も一般的な操作の一つが、カテゴリ別の集計です。Pandasのgroupby()メソッドとsum()関数を組み合わせることで、特定の列の値に基づいてデータをグループ化し、各グループ内の数値列を合計できます。
例：
“`python
売上データサンプル
data_sales = {‘Category’: [‘A’, ‘B’, ‘A’, ‘C’, ‘B’, ‘C’, ‘A’],
‘Value’: [100, 150, 120, 200, 180, 250, 130],
‘Quantity’: [5, 3, 6, 10, 4, 12, 7]}
df_sales = pd.DataFrame(data_sales)
print(“売上データ:\n”, df_sales)
‘Category’ 列でグループ化し、数値列を合計
category_sales_sum = df_sales.groupby(‘Category’).sum()
print(“\nカテゴリごとの合計:\n”, category_sales_sum)
特定の列のみを合計したい場合
category_value_sum = df_sales.groupby(‘Category’)[‘Value’].sum()
print(“\nカテゴリごとの売上金額合計:\n”, category_value_sum)
“`
出力結果：
“`
売上データ:
Category Value Quantity
0 A 100 5
1 B 150 3
2 A 120 6
3 C 200 10
4 B 180 4
5 C 250 12
6 A 130 7
カテゴリごとの合計:
Value Quantity
Category
A 350 18
B 330 7
C 450 22
カテゴリごとの売上金額合計:
Category
A 350
B 330
C 450
Name: Value, dtype: int64
“`
df_sales.groupby('Category').sum()は、’Category’列のユニークな値（’A’, ‘B’, ‘C’）でグループを作成し、各グループ内の数値列（’Value’, ‘Quantity’）をそれぞれ合計します。結果は、’Category’をインデックスとするDataFrameになります。
特定の列（例: ‘Value’）だけを合計したい場合は、groupby()の後に列セレクション['Value']を続けます。結果はSeriesになります。
agg() メソッド内での sum の利用
agg()（または aggregate()）メソッドは、DataFrameやSeriesに対して複数の集計関数を一度に適用したり、異なる列に異なる集計関数を適用したりする場合に使用されます。sum関数もagg()メソッド内で利用できます。
例：
“`python
上記のdf_salesを使用
複数の集計関数を一度に適用
Value列には合計と平均、Quantity列には合計と最大値を適用
agg_results = df_sales.agg({‘Value’: [‘sum’, ‘mean’],
‘Quantity’: [‘sum’, ‘max’]})
print(“agg()メソッドを使用した集計結果:\n”, agg_results)
groupby() と agg() を組み合わせて、グループごとに複数の集計を行う
groupby_agg_results = df_sales.groupby(‘Category’).agg({‘Value’: [‘sum’, ‘mean’],
‘Quantity’: [‘sum’, ‘max’]})
print(“\ngroupby() と agg() を組み合わせた集計結果:\n”, groupby_agg_results)
“`
出力結果：
“`
agg()メソッドを使用した集計結果:
Value Quantity
sum 1030.0 37.0
mean 171.6 7.4
max NaN 12.0
groupby() と agg() を組み合わせた集計結果:
Value Quantity
sum mean sum max
Category
A 350.0 116.67 18 7
B 330.0 165.00 7 4
C 450.0 225.00 22 12
“`
agg()メソッドでは、関数名を文字列（例: 'sum'）または実際の関数オブジェクト（例: np.sum）として指定できます。リストで複数の関数を指定すると、それぞれの集計結果が計算されます。辞書形式で指定すると、列ごとに異なる関数を適用できます。
特定の条件を満たす行/列の合計
ブールインデックス（真偽値のSeriesやDataFrame）を使用して、特定の条件を満たすデータのみを選択し、その合計を計算することもよく行われます。
例：
“`python
上記のdf_salesを使用
‘Value’が200以上の行のみを選択して合計
high_value_sum = df_sales[df_sales[‘Value’] >= 200].sum()
print(“‘Value’が200以上の行の合計:\n”, high_value_sum)
‘Quantity’が10以上の行の’Value’列のみを合計
high_quantity_value_sum = df_sales[df_sales[‘Quantity’] >= 10][‘Value’].sum()
print(“\n’Quantity’が10以上の行の’Value’列合計:”, high_quantity_value_sum)
“`
出力結果：
“`
‘Value’が200以上の行の合計:
Category CB
Value 450
Quantity 22
dtype: object
‘Quantity’が10以上の行の’Value’列合計: 450
“`
最初の例では、条件を満たす行を選択したDataFrameに対してsum()を適用しています。axis=0がデフォルトなので、結果は各列の合計を含むSeriesになります。非数値列である’Category’も含まれていますが、numeric_only=True（デフォルト）のため、数値列のみが合計され、’Category’列は合計されずに元の要素が結合されたり（古いPandasバージョン）、無視されたりします。最新バージョンでは通常無視されます。
2番目の例では、条件を満たす行を選択した後、特定の列['Value']を選択し、そのSeriesに対してsum()を適用しています。これはより意図が明確で、数値合計として結果を得られます。
sum関数使用時の注意点
Pandasのsum関数は非常に便利ですが、いくつかの注意点があります。
- データ型: 合計計算は基本的に数値データに対して行われます。非数値型の列や要素を含むDataFrame/Seriesに対して
sum()を呼び出す場合、numeric_only引数の設定やPandasのバージョンによって挙動が異なります。意図しない文字列結合やエラーを防ぐため、通常は数値列のみを対象とするように注意が必要です。必要であれば、事前にデータ型を確認したり、適切な列を選択したりすることが重要です。 - 欠損値 (NaN):
skipna引数により欠損値の扱いが変わります。デフォルトではskipna=Trueで欠損値は無視されますが、欠損値の存在を合計不可としたい場合はskipna=Falseを指定する必要があります。また、min_countを使うことで、合計計算に必要な非NaN値の数を制御できます。データの欠損状況を理解し、適切な引数設定を行うことが重要です。 - 大規模データ: 非常に大規模なDataFrameに対して
sum()を実行する場合、メモリ使用量や計算時間に注意が必要になることがあります。ほとんどのケースではPandasは効率的に処理を行いますが、極端に大きなデータや、複雑なMultiIndexとlevel引数を組み合わせる場合などは、パフォーマンスプロファイリングが必要になる可能性もあります。 - Pandasのバージョン: 前述したように、
numeric_only引数のデフォルト値はPandas 2.0で変更されました。古いバージョンのコードを実行する際や、異なる環境でコードを共有する際には、このデフォルト値の違いに注意が必要です。明示的にnumeric_only=TrueまたはFalseを指定することで、バージョンによる違いを吸収できます。
これらの注意点を理解しておくことで、sum関数をより安全かつ効果的に利用できます。
まとめ
Pandasのsum関数は、SeriesやDataFrame内の数値データの合計を計算するための基本的かつ強力なツールです。
- Seriesに対しては全体の合計を単一値として返します。
- DataFrameに対しては、
axis引数で指定した方向（デフォルトは列方向）の合計をSeriesとして返します。 skipna引数で欠損値の扱いを、min_count引数で合計に必要な非NaN値の最小数を制御できます。- MultiIndexを持つデータでは、
level引数を使って特定のレベルでのグループ合計を計算できます。 numeric_only引数（Pandas 2.0以降デフォルトTrue）により、数値列のみを対象とすることができます。groupby()やagg()メソッドと組み合わせることで、グループごとの集計や複数の集計関数適用といった、より複雑な分析タスクにも対応できます。
データ分析において、合計値の算出は最初のステップとなることがよくあります。sum関数の様々な引数と応用方法をマスターすることで、データの探索、集計、変換の幅が大きく広がるでしょう。
このガイドが、あなたのPandasを使ったデータ分析の一助となれば幸いです。ぜひ実際のデータでsum関数の様々な使い方を試してみてください。