import pandas as pd

df = pd.DataFrame({
    "日付": ["2026-08-01", "2026-08-02", "2026-08-03", "2026-08-04", "2026-08-05"],
    "売上": [100, 120, 90, 135, 150]
})

df["日付"] = pd.to_datetime(df["日付"])
df = df.sort_values("日付").reset_index(drop=True)
df

df["前日売上"] = df["売上"].shift(1)
df

df["2日前売上"] = df["売上"].shift(2)
df["翌日売上"] = df["売上"].shift(-1)

df[["日付", "売上", "前日売上", "2日前売上", "翌日売上"]]

df["前日差"] = df["売上"] - df["前日売上"]
df["前日比"] = (df["売上"] - df["前日売上"]) / df["前日売上"]

df[["日付", "売上", "前日売上", "前日差", "前日比"]]

result = df[["日付", "売上", "前日売上", "前日差", "前日比"]].copy()
result["前日比（表示用）"] = result["前日比"].map(
    lambda x: f"{x:.1%}" if pd.notna(x) else "—"
)
result

comparison = df[["日付", "売上"]].copy()
comparison["shift_前の値"] = comparison["売上"].shift(1)
comparison["diff_差額"] = comparison["売上"].diff()
comparison["pct_change_増減率"] = comparison["売上"].pct_change(fill_method=None)
comparison

df_unsorted = pd.DataFrame({
    "日付": pd.to_datetime(["2026-08-03", "2026-08-01", "2026-08-02"]),
    "売上": [90, 100, 120]
})

df_unsorted["前の行の売上"] = df_unsorted["売上"].shift(1)
df_unsorted

df_sorted = df_unsorted[["日付", "売上"]].sort_values("日付").reset_index(drop=True)
df_sorted["前日売上"] = df_sorted["売上"].shift(1)
df_sorted

<p>The post pandas shift()の使い方｜前の行・次の行の値を取得して比較する方法 first appeared on Python Data Lab（Pythonデータラボ）.</p>

日別売上を見て、「前日より100円増えた」ことは分かっても、「何％増えたか」の計算で迷うことはありませんか。

Pandasでは、前の行からの増減率をpct_change()で計算できます。

df["前日比"] = df["売上"].pct_change(fill_method=None)

最初に覚えるポイントは3つです。

1. 結果の0.1は10％増加を表す
2. 最初の行は比較元がないためNaNになる
3. 比較するのは暦上の前日ではなくデータ上の前の行

したがって「前日比」と呼べるのは、日付が1日間隔で古い順に並んでいる場合です。この記事では日別売上を例に、基本的な使い方から結果の読み方、periods、0や欠損値の注意点まで解説します。

目次

1. この記事でわかること
2. 先に結論：増減率を求めるならpct_change()を使う
3. pct_change()の計算式と結果の読み方
4. 日別売上のサンプルデータを用意する
5. pct_change()の前に日付型と並び順を確認する
6. pct_change()で前の行からの増減率を計算する
7. どの値と比較したかを表で確認する
8. 増減率をパーセントで表示する
9. periodsで2行前からの増減率を計算する
10. 正の値・負の値・0・NaNをどう読むか
11. コードは動くが結果を誤解しやすい場面
    1. 前の行は必ずしも前日ではない
    2. 比較元が0の場合は無限大になる
    3. 欠損値を安易に0で埋めない
    4. 日付を並び替えないと計算結果が変わる
12. 日別売上と前日比を折れ線グラフで確認する
13. データ分析の流れでpct_change()を使う位置
14. まとめ
15. 関連記事
    1. カテゴリから探す
    2. pct_change()の0.1は何％ですか？
    3. 最初の行がNaNになるのはなぜですか？
    4. 前日比と前月比は計算できますか？
    5. pct_change()とdiff()の違いは何ですか？
    6. 比較元が0の場合はどうなりますか？
    7. 欠損値がある場合はどうなりますか？
    8. 結果をパーセント表示できますか？
    9. 前日比が合わないのはなぜですか？
    10. DataFrameの複数列にも使えますか？
    11. axisやfreqも覚える必要がありますか？

この記事でわかること

• pct_change()で前の行からの増減率を求める方法
• 0.1や-0.2をパーセントで読む方法
• 最初の行がNaNになる理由
• periodsで比較する行を変える方法
• 日付の並び、欠損値、比較元が0の場合の注意点
• diff()・shift()・rolling()との使い分け

この記事のゴールは、日付と行順を確認してからpct_change()を使い、増減率を正しく計算・解釈できるようになることです。

先に結論：増減率を求めるならpct_change()を使う

似た処理は、知りたい内容によって使い分けます。

機能	何を求めるか	選ぶ場面	主な注意点
pct_change()	前の行からの増減率	前日比・前月比を知りたい	結果は割合。0.1は10％
diff()	前の行との差	何円・何個増えたか知りたい	単位は元データと同じ
shift()	前の行の値	現在値と比較元を並べたい	それ自体は差や率を計算しない
rolling()	直近数行の集計値	移動平均で変動を滑らかにしたい	増減率を求める処理ではない

たとえば、売上が1,000円から1,100円になった場合、diff()の結果は100円、pct_change()の結果は0.1、つまり10％です。

増減した量ならdiff()、増減した割合ならpct_change()と判断すると迷いにくくなります。

pct_change()の計算式と結果の読み方

pct_change()は、現在の値を前の行と比べて、どれだけ増減したかを割合で返します。

増減率 = (現在の値 − 前の行の値) ÷ 前の行の値

結果を読むときは、符号と100倍した値に注目します。

結果	パーセントでの読み方	意味
0.10	10％	10％増加
-0.20	-20％	20％減少
0.00	0％	変化なし
1.00	100％	2倍になった
-1.00	-100％	0になった

たとえば0.1は0.1％ではなく、10％増加です。

日別売上のサンプルデータを用意する

ここでは、5日分の日付と売上を持つDataFrameを使います。Google Colabで上から順番に実行できます。

import pandas as pd
import numpy as np

df = pd.DataFrame({
    "日付": ["2026-08-18", "2026-08-19", "2026-08-20", "2026-08-21", "2026-08-22"],
    "売上": [1000, 1100, 990, 990, 1188]
})

df

	日付	売上
0	2026-08-18	1000
1	2026-08-19	1100
2	2026-08-20	990
3	2026-08-21	990
4	2026-08-22	1188

売上は1,000円、1,100円、990円、990円、1,188円と変化しています。この同じデータで、差額と増減率の違いを確認します。

pct_change()の前に日付型と並び順を確認する

pct_change()は、日付の意味を読み取って「前日」を探すのではなく、現在の行と前の行を比較します。そのため、計算前に日付型へ変換し、古い日付から並べることが重要です。

df["日付"] = pd.to_datetime(df["日付"])
df = df.sort_values("日付").reset_index(drop=True)

df.dtypes

	0
日付	datetime64[ns]
売上	int64

日付がdatetime64[ns]になっていることを確認します。そのうえでsort_values()を使い、日付の昇順に整えています。

日付変換の詳細は「pandas to_datetime()の使い方」、並び替えは「pandas 並び替え（sort）入門」で確認できます。

pct_change()で前の行からの増減率を計算する

売上列にpct_change()を使います。fill_method=Noneを明示すると、欠損値を自動的に前の値で補わずに計算できます。

df["前日比"] = df["売上"].pct_change(fill_method=None)

df

	日付	売上	前日比
0	2026-08-18	1000	NaN
1	2026-08-19	1100	0.1
2	2026-08-20	990	-0.1
3	2026-08-21	990	0.0
4	2026-08-22	1188	0.2

前日比列では、2行目が0.1、3行目が-0.1、4行目が0.0、5行目が0.2になります。

• 1,000円から1,100円：10％増加
• 1,100円から990円：10％減少
• 990円から990円：変化なし
• 990円から1,188円：20％増加

最初の行がNaNになるのは、比較する前の行が存在しないためです。エラーではありません。

どの値と比較したかを表で確認する

結果だけでは計算の向きが分かりにくいため、shift()で比較元、diff()で増減額を表示します。現在値・比較元・結果を横に並べると、どの値を分母にしたか確認できます。

comparison = df[["日付", "売上"]].copy()
comparison["前の行の売上"] = comparison["売上"].shift(1)
comparison["増減額"] = comparison["売上"].diff()
comparison["増減率"] = comparison["売上"].pct_change(fill_method=None)
comparison["増減率（%）"] = comparison["増減率"] * 100

comparison

	日付	売上	前の行の売上	増減額	増減率	増減率（%）
0	2026-08-18	1000	NaN	NaN	NaN	NaN
1	2026-08-19	1100	1000.0	100.0	0.1	10.0
2	2026-08-20	990	1100.0	-110.0	-0.1	-10.0
3	2026-08-21	990	990.0	0.0	0.0	0.0
4	2026-08-22	1188	990.0	198.0	0.2	20.0

2行目では、現在の売上1,100円から比較元の1,000円を引き、その100円を1,000円で割っています。

現在の売上	前の行の売上	増減額	計算	増減率
1,100	1,000	100	(1100 - 1000) / 1000	0.10＝10％
990	1,100	-110	(990 - 1100) / 1100	-0.10＝-10％
990	990	0	(990 - 990) / 990	0.00＝0％
1,188	990	198	(1188 - 990) / 990	0.20＝20％

役割は次のように整理できます。

• shift()：比較元の値を確認する
• diff()：増減した量を求める
• pct_change()：増減した割合を求める

増減率をパーセントで表示する

pct_change()の結果を数値としてパーセントに直す場合は、100を掛けます。分析に使える数値のまま保持するため、%記号を含む文字列には変換しません。

df["前日比（%）"] = (df["前日比"] * 100).round(1)

df[["日付", "売上", "前日比", "前日比（%）"]]

	日付	売上	前日比	前日比（%）
0	2026-08-18	1000	NaN	NaN
1	2026-08-19	1100	0.1	10.0
2	2026-08-20	990	-0.1	-10.0
3	2026-08-21	990	0.0	0.0
4	2026-08-22	1188	0.2	20.0

前日比の0.1と、前日比（%）の10.0は同じ変化を表します。前者は割合、後者は100倍したパーセント値です。

列を追加する基本については「pandasで新しい列を追加する方法」で詳しく確認できます。

periodsで2行前からの増減率を計算する

periodsは、何行前と比較するかを指定する引数です。初期値は1です。periods=2にすると2行前と比較します。

df["2行前比"] = df["売上"].pct_change(periods=2, fill_method=None)
df["2行前比（%）"] = (df["2行前比"] * 100).round(1)

df[["日付", "売上", "2行前比", "2行前比（%）"]]

	日付	売上	2行前比	2行前比（%）
0	2026-08-18	1000	NaN	NaN
1	2026-08-19	1100	NaN	NaN
2	2026-08-20	990	-0.01	-1.0
3	2026-08-21	990	-0.10	-10.0
4	2026-08-22	1188	0.20	20.0

最初の2行は、2行前の比較元がないためNaNになります。

3行目の売上990円は2行前の1,000円と比べて1％減少、4行目の990円は2行前の1,100円と比べて10％減少、5行目の1,188円は2行前の990円と比べて20％増加しています。

periods=2は「2日前」ではなく2行前です。日付が1日間隔で並んでいるときだけ、2日前との比較と一致します。

正の値・負の値・0・NaNをどう読むか

結果は次のように読みます。

結果	判断
正の値	比較元より増加
負の値	比較元より減少
0.0	比較元から変化なし
NaN	比較元がない、または計算に必要な値が欠けている

注意したいのは0です。100から0への変化は-100％ですが、0から100への増加率は計算できません。比較元の0を分母にできないため、増加と減少は単純に対称にはなりません。

コードは動くが結果を誤解しやすい場面

前の行は必ずしも前日ではない

次のデータでは、8月19日の次が8月22日です。pct_change()は8月22日を8月19日と比較します。

business_days = pd.DataFrame({
    "日付": pd.to_datetime(["2026-08-18", "2026-08-19", "2026-08-22"]),
    "売上": [1000, 1100, 1210]
})

business_days["前の行からの増減率"] = business_days["売上"].pct_change(fill_method=None)
business_days

	日付	売上	前の行からの増減率
0	2026-08-18	1000	NaN
1	2026-08-19	1100	0.1
2	2026-08-22	1210	0.1

8月22日の結果は10％ですが、これは8月21日との前日比ではなく、データ上の前の行である8月19日からの増減率です。

営業日データなら「前営業日比」と呼べます。暦上の前日比が必要な場合は、日付の間隔を確認し、必要に応じて日次の行をそろえてから計算します。月次データなら同じ考え方で前月比を計算できます。

比較元が0の場合は無限大になる

比較元が0の場合、増減率の計算では0による割り算が発生します。

zero_example = pd.DataFrame({
    "売上": [100, 0, 50]
})

zero_example["増減率"] = zero_example["売上"].pct_change(fill_method=None)
zero_example

	売上	増減率
0	100	NaN
1	0	-1.0
2	50	inf

100から0への変化は-1.0、つまり-100％です。一方、0から50への変化はinf（無限大）になります。

これはコードの失敗ではなく、比較元が0なので通常の増減率を定義できないためです。0を都合のよい別の値に置き換えるのではなく、元データで0が何を意味するか確認し、必要なら該当行を別扱いにします。

欠損値を安易に0で埋めない

欠損値があるデータでは、比較に必要な値がそろわない行がNaNになります。

missing_example = pd.DataFrame({
    "売上": [100, np.nan, 120]
})

missing_example["増減率"] = missing_example["売上"].pct_change(fill_method=None)
missing_example

	売上	増減率
0	100.0	NaN
1	NaN	NaN
2	120.0	NaN

2行目は現在値が欠損し、3行目は比較元となる2行目が欠損しているため、どちらも増減率を計算できません。

欠損値を0で埋めてから計算すると、実際には観測されていない「売上0円」を作り、-100％やinfを発生させる可能性があります。補完する場合は、列の意味と欠損理由を確認してください。欠損値の扱いは「pandas fillna()の使い方」で詳しく解説しています。

Pandasのバージョンによる欠損値補完の挙動へ依存しないよう、この記事ではfill_method=Noneを明示しています。

日付を並び替えないと計算結果が変わる

pct_change()は現在の行順を使います。日付が降順や不規則な順番のままでもコードは動きますが、前日比としては誤った結果になることがあります。

計算前に次の3点を確認します。

1. 日付列がdatetime型になっている
2. 日付が古い順に並んでいる
3. 各行の日付間隔が目的に合っている

CSVを読み込んだ直後は、head()・dtypes・日付の並びを確認してから計算すると安全です。

日別売上と前日比を折れ線グラフで確認する

最後に、売上と前日比を同じ期間で可視化します。左軸が売上、右軸が前日比です。日本語をColabで表示するため、最初の実行時にjapanize-matplotlibを読み込みます。

%pip -q install japanize-matplotlib

import matplotlib.pyplot as plt
import japanize_matplotlib

fig, ax1 = plt.subplots(figsize=(9, 5))

ax1.plot(df["日付"], df["売上"], marker="o", color="tab:blue", label="売上")
ax1.set_xlabel("日付")
ax1.set_ylabel("売上（円）", color="tab:blue")
ax1.tick_params(axis="y", labelcolor="tab:blue")
ax1.grid(alpha=0.3)

ax2 = ax1.twinx()
ax2.plot(df["日付"], df["前日比（%）"], marker="s", color="tab:red", label="前日比")
ax2.axhline(0, color="gray", linewidth=1)
ax2.set_ylabel("前日比（%）", color="tab:red")
ax2.tick_params(axis="y", labelcolor="tab:red")

lines1, labels1 = ax1.get_legend_handles_labels()
lines2, labels2 = ax2.get_legend_handles_labels()
ax1.legend(lines1 + lines2, labels1 + labels2, loc="upper left")

plt.title("日別売上と前日比の推移")
fig.autofmt_xdate()
plt.tight_layout()
plt.show()

売上が同じ990円だった8月21日は前日比が0％、1,188円へ増えた8月22日は20％になります。

グラフでは、売上の水準と増減率を混同しないことが重要です。売上が最も大きい日と、増加率が最も大きい日は必ずしも一致しません。折れ線グラフの基本設定は「Matplotlib 折れ線グラフ入門」で確認できます。

データ分析の流れでpct_change()を使う位置

pct_change()は、データを読み込んですぐ使うのではなく、日付と値を確認した後の「変化を計算する」段階で使用します。

1. CSVなどからDataFrameを読み込む
2. head()やdtypesで内容を確認する
3. to_datetime()で日付型へ変換する
4. sort_values()で日付順に並べる
5. pct_change()で増減率を計算する
6. rolling()や折れ線グラフで傾向を確認する

期間ごとの合計値を作る場合は、先にresample()で月次などへ集計してからpct_change()を使います。移動平均で短期変動を滑らかにする場合は「pandas rolling()の使い方」、期間集計は「pandas resample()の使い方」を参照してください。

まとめ

• pct_change()は前の行からの増減率を計算する
• 0.1は10％増加、-0.2は20％減少を表す
• 最初の行は比較元がないためNaNになる
• periods=2は2日前ではなく2行前との比較になる
• 前日比として使う前に、日付型・並び順・日付間隔を確認する
• 比較元が0の場合はinf、欠損値を含む比較はNaNになることがある
• 増減量はdiff()、比較元はshift()、平滑化はrolling()を使う

まずは「割合ならpct_change()」「量ならdiff()」と使い分けましょう。そのうえで、結果が前日比・前営業日比・前月比のどれに当たるかを確認することが大切です。

関連記事

• pandas diff()の使い方｜前の行との差分・前日からの増減を計算する方法
• pandas rolling()の使い方｜移動平均・window・NaNを初心者向けに解説
• pandas resample()の使い方｜日付データを月別・週別に集計する方法
• pandas 並び替え（sort）入門｜sort_values・sort_indexの違い
• pandas to_datetime()の使い方｜文字列の日付変換とNaT対処
• pandasで新しい列を追加する方法
• pandas fillna()の使い方｜欠損値を埋める方法
• Matplotlib 折れ線グラフ入門
• Pandas DataFrame入門｜作り方と基本操作

カテゴリから探す

• ◀ Pandas 基礎
• ◀ Pandas 抽出・前処理
• ◀ Pandas 集計・変形
• ▶ Matplotlib　可視化

▲ ページトップへ戻る

<p>The post pandas pct_change()の使い方｜前日比・増減率の計算方法 first appeared on Python Data Lab（Pythonデータラボ）.</p>

日別売上を見ながら、「前日よりいくら増えたのか」を1行ずつ計算するのは大変です。pandasのdiff()を使えば、現在の行から1つ前の行を引いた差分をまとめて計算できます。

先に結論を示すと、前の行からの増減「量」を求める基本形はdf["売上"].diff()です。ただし、diff()は日付そのものではなく、DataFrameの現在の行順に沿って計算します。時系列データでは、日付型への変換と日付順の並び替えを先に済ませることが重要です。

この記事では日別売上を例に、引き算の向き、先頭がNaNになる理由、periodsの意味、shift()・pct_change()・rolling()との違いまで、Google Colabで実行しながら確認します。

この記事でわかること

• diff()で前の行との差分を求める方法
• 差分が正・負・0になる意味
• 先頭行がNaNになる理由
• periodsで比較する行を変える方法
• 日付順に並べてから計算する理由
• diff()・shift()・pct_change()・rolling()の使い分け
• 計算結果を「前日差」列としてDataFrameに追加する方法

DataFrame自体がまだよく分からない場合は、先にPandas DataFrame入門を読むと理解しやすくなります。CSVから試したい場合は、Google ColabでCSVを読み込む方法も参考にしてください。

先に結論：増減量を求めるならdiff()を使う

diff()の標準の計算は、次のとおりです。

現在の行の値 − 1つ前の行の値

たとえば、前日の売上が1,000円、当日の売上が1,300円なら、差分は300です。前日より200円減った場合は-200になります。

目的が似ているメソッドは、求めたい結果で使い分けます。

この記事の中心は、増減「量」を求めるdiff()です。移動平均はpandas rolling()の使い方、期間別集計はpandas resample()の使い方で詳しく解説しています。

日別売上のサンプルデータを用意する

Google Colabで次のセルを実行してください。増加・減少・変化なしをすべて確認できるように、日付の順番を一部入れ替えたデータを用意します。

import pandas as pd

df = pd.DataFrame({
    "日付": ["2026-08-01", "2026-08-03", "2026-08-02", "2026-08-04", "2026-08-05", "2026-08-06"],
    "売上": [1000, 1300, 1200, 1300, 1300, 1100]
})

df

このままdiff()を使うと、表示されている行順で計算されます。8月3日の次に8月2日があるため、その結果を「前日差」とは呼べません。先に日付型と並び順を整えます。

diff()の前に日付型と並び順を整える

まずto_datetime()で日付列を日付型に変換し、sort_values()で昇順に並べます。並び替え後のインデックスもreset_index(drop=True)で振り直しておくと、行順を確認しやすくなります。

df["日付"] = pd.to_datetime(df["日付"])
df = df.sort_values("日付").reset_index(drop=True)

df

日付の変換方法はpandas to_datetime()の使い方、並び替えの詳細はpandas 並び替え（sort）入門で確認できます。

ここでは日付が1日刻みで連続しているため、1つ前の行との差を「前日差」として扱えます。

diff()で前の行との差を計算する

売上列にdiff()を使って、結果だけを確認します。

df["売上"].diff()

結果は上から順にNaN, 200, 100, 0, 0, -200となります。diff()を実行しただけでは、元のDataFrameに列は追加されていません。

処理前・計算対象・処理後を表で確認する

それぞれの行で行われている計算は次のとおりです。

diff()は逆向きではなく、現在行から前の行を引く処理です。したがって、結果の符号は次のように読みます。

diff()の結果を「前日差」列として追加する

分析しやすいように、差分を新しい列へ代入します。

df["前日差"] = df["売上"].diff()

df

これで元の売上と前日差を横に並べて確認できます。先頭行のNaNはエラーではありません。1行目には比較する前日の行がないためです。

整数の売上列でも、先頭にNaNが入るため、結果は通常200.0のような小数で表示されます。計算が間違っているわけではありません。列追加の基本は、pandasで新しい列を追加する方法で詳しく解説しています。

periodsで何行前と比較するかを変更する

diff()のperiodsは、何行ずらした値と比較するかを指定します。標準はperiods=1です。

ここで重要なのは、periods=2が必ず「2日前」を意味するわけではなく、2行前を意味することです。日付が毎日連続している場合に限り、2行前と2日前が一致します。

df["1行前との差"] = df["売上"].diff(periods=1)
df["2行前との差"] = df["売上"].diff(periods=2)

df[["日付", "売上", "1行前との差", "2行前との差"]]

比較対象は次のように変わります。

たとえば8月3日の売上1,300円について、1行前との差は1,300 − 1,200 = 100、2行前との差は1,300 − 1,000 = 300です。

periodsに負の値を指定するとどうなる？

負の値を指定すると、後ろの行と比較できます。たとえばperiods=-1は「現在行 − 次の行」です。引き算の向きを混同しやすいため、初心者のうちは標準のperiods=1を中心に使えば十分です。

df[["日付", "売上"]].assign(
    次の行との差=df["売上"].diff(periods=-1)
)

並び順が違うとdiff()の結果も変わる

diff()は日付を見て自動的に前日を探すメソッドではありません。画面上の1つ前の行と比較します。

最初に用意した並び順のまま計算した場合と、日付順に整えてから計算した場合を比べます。

df_unsorted = pd.DataFrame({
    "日付": pd.to_datetime(["2026-08-01", "2026-08-03", "2026-08-02", "2026-08-04"]),
    "売上": [1000, 1300, 1200, 1300]
})

変更前 = df_unsorted.assign(行間差=df_unsorted["売上"].diff())

df_sorted = df_unsorted.sort_values("日付").reset_index(drop=True)
変更後 = df_sorted.assign(前日差=df_sorted["売上"].diff())

print("変更前：日付順ではない状態")
display(変更前)
print("変更後：日付順に並べた状態")
display(変更後)

変更前：日付順ではない状態

変更後：日付順に並べた状態

変更前では8月2日の直前に8月3日があるため、8月2日の差は1,200 − 1,300 = -100です。これは前日差ではなく、単なる行間差です。変更後は8月1日、2日、3日、4日の順になるため、前日からの増減として解釈できます。

時系列データでは、diff()の直前に日付列と並び順を確認する習慣をつけましょう。

前日差を正しく読むための2つの注意点

日付が欠けていると「前の行」と「前日」は一致しない

次は8月2日のデータがない例です。日付順には並んでいますが、8月3日の1つ前の行は8月1日です。

df_gap = pd.DataFrame({
    "日付": pd.to_datetime(["2026-08-01", "2026-08-03", "2026-08-04"]),
    "売上": [1000, 1300, 1200]
})

df_gap["前の行との差"] = df_gap["売上"].diff()
df_gap

8月3日の結果300は、8月1日との比較です。8月2日の売上が存在しないため、厳密には「前日差」ではありません。

つまり、diff(periods=1)の1は1日ではなく1行です。「前日差」と表現する前に、日付が1日刻みで連続しているか確認してください。

途中に欠損値があると差分もNaNになる

売上の途中に欠損値があると、その値を使う差分は計算できません。

df_missing = pd.DataFrame({
    "日付": pd.date_range("2026-08-01", periods=5, freq="D"),
    "売上": [1000, 1200, None, 1500, 1600]
})

df_missing["前日差"] = df_missing["売上"].diff()
df_missing

8月3日は売上自体が欠損しているためNaNです。8月4日も、比較する1行前の8月3日が欠損しているためNaNになります。8月5日は8月4日の値があるため、再び計算できます。

欠損値を理由なく0で埋めると、「売上が本当に0だった」と解釈される恐れがあります。欠損が未記録なのか、売上0を意味するのかを確認してから処理してください。埋め方の判断はpandas fillna()の使い方で解説しています。

diff()・shift()・pct_change()・rolling()を同じデータで比較する

似た処理の違いを、同じ売上データで確認します。shift(1)は前の行の売上、pct_change()は変化率、rolling(3).mean()は直近3行の移動平均を返します。

df_compare = df[["日付", "売上"]].copy()
df_compare["前の行の値_shift"] = df_compare["売上"].shift(1)
df_compare["増減量_diff"] = df_compare["売上"].diff()
df_compare["増減率_pct_change"] = df_compare["売上"].pct_change(fill_method=None)
df_compare["3行移動平均_rolling"] = df_compare["売上"].rolling(3).mean()

df_compare

たとえば8月2日は、前の行の値が1,000円、増減量が200円、増減率が0.2（20%）です。3行移動平均は3行分の値が揃う8月3日から計算されます。

• 何円変わったかを知りたい：diff()
• 何％変わったかを知りたい：pct_change()
• 前の値そのものを使いたい：shift()
• 短期的な変動をならしたい：rolling()

目的を先に言葉にすると、メソッドを選びやすくなります。

補足：DataFrame全体や列方向にもdiff()を使える

ここまでは、日別売上の前日差を求めるため、売上のSeriesにdiff()を使いました。diff()は数値列からなるDataFrame全体にも使用でき、標準では各列について1つ前の行との差を計算します。文字列列などが含まれる場合は、差分を求めたい数値列を選んで実行するのが安全です。

また、axis=1を指定すると、同じ行にある列同士の差を計算できます。たとえば「4月売上」と「5月売上」の差を横方向に求める場合です。

df_monthly = pd.DataFrame({
    "4月売上": [1000, 1500],
    "5月売上": [1200, 1400]
}, index=["商品A", "商品B"])

df_monthly.diff(axis=1)

5月売上列には「5月売上 − 4月売上」が表示されます。最初の4月売上列は左側に比較する列がないためNaNです。

ただし、時系列データの前日差を求める目的なら、対象の売上列に行方向のdiff()を使う基本形を優先してください。列方向の差分は、月別列などが横に並んだデータで必要になったときに使えば十分です。

diff()でよくあるミスと対処法

1. 日付順に並べず「前日差」と解釈する

diff()は現在の行順で計算します。時系列データでは、日付型への変換と並び替えを先に済ませます。

2. 先頭のNaNをエラーだと思う

先頭行には比較する前の行がないため、標準ではNaNになります。正常な結果なので、理由なく0で埋めないようにします。

3. periodsを日数だと思う

periods=2は2日前ではなく2行前との比較です。

4. diff()を表示しただけで列が追加されたと思う

df["売上"].diff()は結果を返しますが、元のDataFrameを変更しません。「前日差」列として残す場合は、新しい列へ代入します。

5. 負の値を計算ミスだと思う

標準のdiff()は現在行から前の行を引きます。負の値は、前の行より減少したことを示します。

6. 前日比率を求めたいのにdiff()を使う

diff()が返すのは増減量です。「前日より何％増えたか」を求める場合はpct_change()を選びます。

データ分析の流れでdiff()を使う位置

diff()は、読み込んだデータを確認・整形したあとに、変化を表す列を作る処理として使えます。

1. CSVをDataFrameに読み込む
2. head()やinfo()で列とデータ型を確認する
3. 日付列をto_datetime()で日付型に変換する
4. sort_values()で日付順に並べる
5. diff()で前の行からの増減列を作る
6. 増減が大きい日を確認する
7. 必要に応じてrolling()やresample()で傾向を集計する
8. 折れ線グラフなどで可視化する

このように、diff()はデータの確認・前処理から時系列分析や可視化へ進む橋渡しになります。

売上と前日差をグラフで確認する

最後に、売上と前日差を上下2つの折れ線グラフで確認します。尺度が異なるため、同じ軸へ無理に重ねず、グラフを分けます。

Google Colabで日本語のタイトルや軸ラベルを文字化けさせないため、最初に次のセルを1回実行してjapanize_matplotlibを読み込みます。

%pip install -q japanize-matplotlib
import japanize_matplotlib

import matplotlib.pyplot as plt

fig, axes = plt.subplots(2, 1, figsize=(9, 6), sharex=True)

axes[0].plot(df["日付"], df["売上"], marker="o")
axes[0].set_ylabel("売上")
axes[0].set_title("日別売上")
axes[0].grid(alpha=0.3)

axes[1].plot(df["日付"], df["前日差"], marker="o", color="tab:orange")
axes[1].axhline(0, color="gray", linewidth=1)
axes[1].set_ylabel("前日差")
axes[1].set_xlabel("日付")
axes[1].set_title("前日からの増減")
axes[1].grid(alpha=0.3)

fig.autofmt_xdate()
plt.tight_layout()
plt.show()

上段では売上水準、下段では前日からの増減を確認できます。0より上なら増加、下なら減少です。グラフの色・線種・凡例などを整えたい場合は、Matplotlib折れ線グラフの描き方を参考にしてください。

まとめ

diff()を使うと、DataFrameやSeriesで前の行との差分を簡単に計算できます。

• 標準のdiff()は「現在行 − 1つ前の行」を計算する
• 正の値は増加、負の値は減少、0は変化なしを表す
• 先頭行のNaNは比較相手がないためで、エラーではない
• periodsで比較する行を変更でき、periods=2は原則として2行前を意味する
• 時系列データは、日付型と並び順を確認してから計算する
• 日付が欠けている場合、前の行との差を前日差とは限らない
• 増減率にはpct_change()、前の値にはshift()、移動平均にはrolling()を使う

まずは、日付変換→日付順に並び替え→diff()で差分列を追加という順番を覚えましょう。これで日別売上やアクセス数について、前回からの増減を正しく確認できるようになります。

関連記事

• Pandas DataFrame入門｜作り方・基本操作をわかりやすく解説
• Google ColabでCSVを読み込む方法｜アップロード・Drive・read_csv
• pandas to_datetime()の使い方｜文字列の日付変換とformat・NaT対処
• pandas 並び替え（sort）入門｜sort_values・sort_indexの違い
• pandas rolling()の使い方｜移動平均・window・NaNを解説
• pandas resample()の使い方｜月別・週別に集計する方法
• Matplotlib折れ線グラフの描き方
• Pandasロードマップ

仕様を確認したい場合は、pandas公式ドキュメント：DataFrame.diffも参考になります。

▲ ページトップへ戻る

<p>The post pandas diff()の使い方｜前の行との差分・前日からの増減を計算する方法 first appeared on Python Data Lab（Pythonデータラボ）.</p>

日別売上やアクセス数を折れ線グラフにしても、値が大きく上下していると「増えているのか、単にばらついているだけなのか」が分かりにくいことがあります。

このようなときに使えるのが、pandasのrolling()です。直近の複数行を少しずつずらしながら平均を計算し、短期的な変動をならして傾向を見やすくできます。

先に結論を示すと、rolling(window=3).mean()は、原則として現在行を含む直近3行の平均を求めます。データが1日1行で日付も連続していれば、「3日移動平均」として読めます。ただし、window=3自体が自動的に3日間を意味するわけではありません。

また、結果の先頭に出るNaNはエラーではありません。3行分のデータがまだそろっていないためです。

最初に覚える手順は、「日付順に並べる → rolling()で計算する → 元の値と比べる」の3つだけです。

この記事では、Google Colabで実行できる日別売上データを使い、3日・7日移動平均、min_periods、resample()との違い、折れ線グラフでの確認までを順番に解説します。

この記事でわかること

• rolling()を使う場面と基本的な書き方
• rolling(window=3).mean()のwindowが表す範囲
• 3日移動平均と7日移動平均の計算方法
• 先頭にNaNが出る理由とmin_periodsの役割
• rolling()・resample()・通常のmean()の違い
• center=Trueで結果を置く位置を変える方法
• 行数指定とrolling("3D")による期間指定の違い
• 元の値と移動平均を折れ線グラフで比較する方法

この記事のゴールは、目的に合ったwindowを選び、移動平均列を作って、元の値と比較しながら傾向を説明できるようになることです。

rolling()は直近の複数行をずらしながら計算する

rolling()の「rolling window」は、日本語では「移動窓」と考えると分かりやすいでしょう。

たとえばwindow=3なら、対象範囲を次のように1行ずつ移動させます。

1. 1〜3行目を使って計算する 2. 2〜4行目を使って計算する 3. 3〜5行目を使って計算する

平均を求める場合の基本形は次のとおりです。

df["売上"].rolling(window=3).mean()

列を1つ選ぶとSeriesになるため、これはSeriesにrolling()を適用して平均を求める書き方です。複数の数値列を選んだDataFrameにもrolling()を使えますが、この記事では1列に絞って仕組みを確認します。

rolling()・resample()・通常のmean()の違い

似て見える処理でも目的が異なります。最初に次の基準で選びましょう。

迷ったときは、出力後も1日ごとの行を残したいかで判断します。 1日ごとの行を残して傾向をならすならrolling()、月別・週別などに行をまとめるならresample()です。列全体を代表する平均値が1つだけ必要なら、通常のmean()を使います。

月別・週別集計は、pandas resample()の使い方で詳しく解説しています。

日別売上のサンプルデータを用意する

Google Colabで次のコードを実行してください。2026年8月1日から14日まで、1日1行で日付が連続するデータです。

売上は日ごとに上下しますが、全体として少しずつ増える値にしています。このデータなら、移動平均によって短期的な上下がならされる様子を確認できます。

import pandas as pd
import matplotlib.pyplot as plt

df = pd.DataFrame({
    "日付": [
        "2026-08-01", "2026-08-02", "2026-08-03", "2026-08-04",
        "2026-08-05", "2026-08-06", "2026-08-07", "2026-08-08",
        "2026-08-09", "2026-08-10", "2026-08-11", "2026-08-12",
        "2026-08-13", "2026-08-14"
    ],
    "売上": [100, 160, 120, 190, 150, 220, 180, 250, 210, 280, 230, 310, 270, 340]
})

df

自分のCSVをGoogle Colabへ読み込む手順は、Google ColabでCSVを読み込む方法を参照してください。DataFrame自体の基本操作を確認したい場合は、Pandas DataFrame入門が役立ちます。

rolling()の前に日付型と並び順を確認する

移動平均は「直前の行」を使うため、行の順番が重要です。日付が文字列のままならdatetime型に変換し、古い日付から新しい日付の順へ並べます。

今回は日付が連続する1日1行のデータなので、window=3を3日移動平均として説明できます。欠損日があるデータでは、同じコードは「直近3日」ではなく直近3行の平均です。

df["日付"] = pd.to_datetime(df["日付"])
df = df.sort_values("日付").reset_index(drop=True)

df.dtypes

日付がdatetime64[ns]になっていれば変換できています。

• 日付変換の詳しい方法：pandas to_datetime()の使い方
• 並び替えの詳しい方法：pandas 並び替え（sort）入門
• 日付をインデックスにする方法：pandas set_index()の使い方

rolling(window=3).mean()で3日移動平均を計算する

売上列にrolling(window=3).mean()を適用し、結果を「3日移動平均」という新しい列へ追加します。

df["3日移動平均"] = df["売上"].rolling(window=3).mean()

df[["日付", "売上", "3日移動平均"]]

window=3が対象にする値を処理前後表で確認する

最初の5行は次のように計算されます。

8月3日の値は、(100 + 160 + 120) ÷ 3 = 126.67です。次の行では対象が1行ずれ、8月2日〜4日の売上を平均します。

この表で重要なのは、各行の結果が、その行と直前2行から作られていることです。移動平均は元の行数を保ちながら各行に対応する平均を返し、列全体の平均を1つだけ返すdf["売上"].mean()とは異なります。

先頭2行がNaNになる理由

初期設定では、windowに指定した数の有効な値がそろうまで結果を計算しません。window=3の場合は次の状態になります。

• 1行目：利用できる値が1個だけなのでNaN
• 2行目：利用できる値が2個だけなのでNaN
• 3行目：3個そろうので移動平均を計算

したがって、先頭のNaNはエラーではなく、同じ条件の3行平均をまだ計算できないことを示す正常な結果です。単純にfillna(0)で0へ置き換えると、「平均売上が0だった」と誤解されるので避けましょう。

min_periods=1で途中から計算する場合

min_periodsは、結果を計算するために最低限必要な有効値の数です。min_periods=1を指定すると、最初の行から結果が出ます。

df["3日移動平均_min1"] = (
    df["売上"]
    .rolling(window=3, min_periods=1)
    .mean()
)

df[["日付", "売上", "3日移動平均", "3日移動平均_min1"]].head(5)

初期設定とmin_periods=1の違いを整理します。

min_periods=1はNaNを減らせますが、先頭の値は3個ではなく1個または2個の平均です。すべての行を同じ条件で比較したい場合は、初期設定のNaNを残すほうが分かりやすいことがあります。

center=Trueは結果を中央の行に置く

初期設定のcenter=Falseでは、計算結果をwindowの末尾、つまり現在行に置きます。center=Trueを指定すると、結果をwindowの中央に置きます。

同じ3つの値を平均しても、結果が表示される行が変わります。

center比較 = pd.DataFrame({
    "日付": df["日付"],
    "売上": df["売上"],
    "center=False": df["売上"].rolling(window=3).mean(),
    "center=True": df["売上"].rolling(window=3, center=True).mean()
})

center比較.head(6)

たとえば100・160・120の平均126.67は、初期設定では3行目の8月3日、center=Trueでは中央に当たる2行目の8月2日に表示されます。

この記事の移動平均は「現在までの直近値から傾向を見る」ことが目的なので、以降は初期設定のcenter=Falseを使います。

3日移動平均と7日移動平均を使い分ける

次に、同じ売上データへ7行の移動平均も追加します。サンプルは1日1行で日付が連続しているため、ここでは7日移動平均として扱えます。

df["7日移動平均"] = df["売上"].rolling(window=7).mean()

df[["日付", "売上", "3日移動平均", "7日移動平均"]]

windowを大きくすると線は滑らかになりますが、急な上昇や下降が遅れて表れます。3日と7日のどちらが常に優れているわけではなく、どの程度の短期変動をならしたいかで選びます。

なお、移動平均は過去の値をならして見せる方法であり、将来を予測する機能ではありません。

rolling().mean()とrolling().sum()の違い

rolling()の後ろには、目的に合った集計メソッドを続けます。

• mean()：直近の平均を求め、変動をならす
• sum()：直近の合計を求める

たとえば「直近3日間の売上合計」を求める場合は、sum()を使います。

df["直近3日売上合計"] = df["売上"].rolling(window=3).sum()

df[["日付", "売上", "3日移動平均", "直近3日売上合計"]].head(7)

同じwindowでも、mean()は傾向をならす用途、sum()は直近期間の累計を確認する用途に向いています。

rolling()の後ろで使える主な集計メソッド

rolling()は対象範囲を決める処理です。その後ろに、目的に合った集計メソッドを続けます。

初心者は、まずmean()とsum()を使い分けられれば十分です。ほかのメソッドも書き方は同じで、必要になったときに選べます。

元の売上と移動平均を折れ線グラフで比較する

数値表だけでなく、元の売上、3日移動平均、7日移動平均を同じグラフへ描くと、windowによる滑らかさの違いが分かります。

ここではグラフの装飾ではなく、元の値の上下が移動平均でどのようにならされるかに注目してください。

plt.figure(figsize=(10, 5))
plt.plot(df["日付"], df["売上"], marker="o", alpha=0.55, label="Daily sales")
plt.plot(df["日付"], df["3日移動平均"], linewidth=2.5, label="3-row moving average")
plt.plot(df["日付"], df["7日移動平均"], linewidth=2.5, label="7-row moving average")

plt.xlabel("Date")
plt.ylabel("Sales")
plt.title("Daily sales and moving averages")
plt.grid(alpha=0.3)
plt.legend()
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

3日移動平均は元の売上の変化に比較的早く反応し、7日移動平均はさらに滑らかになります。一方で、windowが大きいほど直近の変化が遅れて見える点には注意が必要です。

グラフの色・線種・凡例などを詳しく設定したい場合は、Matplotlib折れ線グラフの描き方を参照してください。

rolling(3)とrolling(“3D”)は対象範囲が違う

ここまで使ったrolling(3)は直近3行を対象にします。一方、日付をインデックスにした時系列データでは、rolling("3D")のように実際の期間を指定できます。

違いが分かるように、8月3日と4日が欠けたデータで比較します。

df_gap = pd.DataFrame({
    "日付": pd.to_datetime(["2026-08-01", "2026-08-02", "2026-08-05", "2026-08-06"]),
    "売上": [100, 160, 120, 190]
}).set_index("日付")

df_gap["直近3行平均"] = df_gap["売上"].rolling(3).mean()
df_gap["直近3日平均"] = df_gap["売上"].rolling("3D").mean()

df_gap

8月5日の「直近3行平均」は8月1日・2日・5日の3行を使います。一方、「直近3日平均」は実際の日付間隔を見るため、8月5日時点の直近3日内にある値だけが対象です。

1日1行で日付が連続していれば両者は似た結果になりますが、欠損日や不規則な時刻があるデータでは一致しません。期間指定にはDatetimeIndexが必要です。この記事の中心は行数ベースの移動平均なので、期間指定はこの違いだけ押さえれば十分です。

rolling()でよくあるミスと注意点

window=3を必ず3日間だと思ってしまう

数値のwindow=3は基本的に3行です。1日に複数行がある場合や、日付が抜けている場合は3日間と一致しません。期間ベースではrolling("7D")のような指定もできますが、日付インデックスなどの前提が増えるため、この記事では詳しく扱いません。

日付順に並べず計算する

rolling()は現在の行順を使います。日付が前後したままでは、時間の流れに沿った移動平均になりません。先にdatetime型へ変換し、sort_values()で並べ替えましょう。

先頭のNaNをエラーだと思う

必要な値がwindowの数に達していないためです。0埋めで隠すのではなく、NaNが生じる理由を確認します。

rolling()だけで元のDataFrameが変わると思う

rolling()の計算結果は自動的に元のDataFrameへ追加されません。残したい場合は、この記事の例のように新しい列へ代入します。列追加の基本は、pandasで新しい列を追加する方法で確認できます。

欠損値があっても同じように計算できると思う

元データに欠損値があると、window内の有効値の数とmin_periodsによって結果が変わります。まず欠損の場所と意味を確認し、必要な件数を満たしているか判断してください。

データ分析の流れでrolling()を使う位置

rolling()は、データを読み込んだ直後ではなく、日付や並び順を整えた後に使います。

1. CSVやExcelを読み込む 2. head()やdtypesで内容と型を確認する 3. 日付列をto_datetime()で変換する 4. 日付順に並べ替える 5. 必要に応じてresample()で時間単位を整える 6. rolling()で短期変動をならす 7. 折れ線グラフで元の値と比較する

年・月・曜日を取り出して別の切り口で集計したい場合は、pandas dtの使い方へ進んでください。

発展的な機能には、開始行から対象範囲を広げるexpanding()、新しい値へ大きな重みを付けるewm()、グループ別に計算するgroupby().rolling()などがあります。center=Trueによる結果位置の変更や欠損日の補間も含め、これらは基本を理解してから学べば十分です。

まとめ

• rolling()は、直近の複数行を1行ずつずらしながら計算する
• rolling(window=3).mean()は、原則として現在行を含む直近3行の平均を求める
• 数値のwindowは基本的に行数であり、自動的に日数を意味するわけではない
• 3行そろう前のNaNはエラーではなく、同じ条件で計算できないことを示す
• min_periods=1なら先頭から計算できるが、利用する値の数が行ごとに異なる
• center=Trueを指定すると、計算結果をwindowの中央に置ける
• rolling(3)は直近3行、rolling("3D")は実際の直近3日間を対象にする
• window=3は変化へ比較的早く反応し、window=7は滑らかだが反応が遅くなる
• 傾向を見るならmean()、直近の合計を見るならsum()を使う
• 集計単位を変えるresample()と、値をならすrolling()は目的が異なる
• 計算前に日付型と並び順を確認し、計算後は元の値とグラフで比較する

まずはこの記事のサンプルで3日移動平均を実行し、windowを7へ変えたときに結果がどのように変化するか確認してみてください。

次に読みたい関連記事

• Google ColabでCSVを読み込む方法｜アップロード・Drive・read_csv
• Pandas DataFrame入門｜作り方・基本操作をわかりやすく解説
• pandas to_datetime()の使い方｜文字列の日付変換とformat・NaT対処
• pandas 並び替え（sort）入門｜sort_values・sort_indexの違い
• pandas set_index()の使い方｜列をインデックスにする方法
• pandas dtの使い方｜日付から年・月・曜日を取り出す方法
• pandas resample()の使い方｜日付データを月別・週別に集計
• pandasで新しい列を追加する方法
• Matplotlib折れ線グラフの描き方

▲ ページトップへ戻る

<p>The post pandas rolling()の使い方｜移動平均・window・NaNを初心者向けに解説 first appeared on Python Data Lab（Pythonデータラボ）.</p>

CSVやExcelを読み込んだあと、注文日・来店日・売上日などの日付列はあるのに、次のような集計で迷うことがあります。

• 月ごとの売上合計を出したい
• 週ごとの注文件数を数えたい
• 日別の平均売上を確認したい
• 集計した結果を折れ線グラフで見たい

このようなときに役立つのが、pandasの resample() です。

resample() は、日付データを日別・週別・月別などの時間単位でまとめて集計するためのメソッドです。

イメージとしては、1行ずつ並んでいる日付データを「1日ごと」「1週間ごと」「1か月ごと」の箱に分け、その箱ごとに合計・平均・件数を計算する処理です。

たとえば、1件ずつ並んでいる注文データから、月別売上や週別件数を作りたいときに使います。

この記事では、to_datetime() で日付列を整えるところから、resample() で月別・週別・日別に集計し、最後にグラフ化へつなげる流れまで、Google Colabで試しやすいサンプルデータを使って解説します。

この記事でわかること

この記事では、次の内容を学びます。

• resample() が何をするメソッドか
• resample() を使う前に日付列を datetime 型にする理由
• set_index() してから resample() する基本
• on="日付列" で日付列を指定して集計する方法
• 日別・週別・月別に集計する方法
• sum()、mean()、count() の使い分け
• groupby()・dt・resample() の違い
• resample() と asfreq() の違い
• 集計結果を reset_index() で扱いやすい表に戻す方法
• 集計結果をグラフ化へつなげる流れ

この記事のゴールは、日付列をdatetime型に整え、resample()で日別・週別・月別に集計し、集計結果を表やグラフで確認できるようになることです。

関連する前提知識

この記事は、日付データを「時間のまとまり」で集計する記事です。

先に次の内容を確認しておくと、より理解しやすくなります。

• Google ColabでCSVを読み込む方法｜Drive連携とpandas read_csvを初心者向けに解説
• pandas to_datetime()の使い方｜文字列の日付変換と format・NaT 対処を初心者向けに解説
• pandas dtの使い方｜日付から年・月・曜日を取り出す方法を初心者向けに解説
• pandas set_index()の使い方｜列をインデックスにする・drop=False・index_col・reset_indexとの違いを解説
• Pandas groupby×aggの使い方｜基本の集計とaggの書き方を例で解説

ただし、この記事では必要な部分を順番に確認するため、最初から読んでも進められるようにしています。

まず結論：resample()は日付を時間単位でまとめるときに使う

resample() は、日付データを一定の時間単位でまとめるために使います。

たとえば、次のような明細データがあるとします。

このような1件ずつのデータを、次のように月別にまとめたいときに resample() が役立ちます。

ポイントは、resample() が「カテゴリごと」ではなく、日付を基準にして、日別・週別・月別などの時間のまとまりで集計することです。

最初に判断基準を整理すると、次のようになります。

この記事では、このうち resample() を中心に扱います。

サンプルデータを用意する

ここでは、注文日・カテゴリ・商品・売上・数量を持つ小さな売上データを使います。

実際のCSVでは日付順に並んでいるとは限らないため、サンプルデータもあえて少し日付順をばらしています。

import pandas as pd

df = pd.DataFrame({
    "注文日": [
        "2026-03-15", "2026-01-05", "2026-02-03", "2026-01-18",
        "2026-03-28", "2026-02-25", "2026-01-28", "2026-02-12",
        "2026-03-02", "2026-01-12", "2026-02-05", "2026-03-05"
    ],
    "カテゴリ": [
        "食品", "食品", "日用品", "食品",
        "日用品", "食品", "日用品", "日用品",
        "食品", "日用品", "食品", "食品"
    ],
    "商品": [
        "コーヒー", "パン", "洗剤", "お茶",
        "ティッシュ", "お米", "歯ブラシ", "シャンプー",
        "牛乳", "ノート", "卵", "ヨーグルト"
    ],
    "売上": [1800, 1200, 2600, 1500, 900, 4200, 700, 3200, 1100, 600, 980, 1300],
    "数量": [3, 2, 1, 3, 2, 1, 2, 1, 2, 3, 2, 2]
})

display(df)
print(df.dtypes)

注文日     object
カテゴリ    object
商品      object
売上       int64
数量       int64
dtype: object

注文日 は日付のように見えますが、この時点では object 型です。

resample() で日付を基準に集計するには、日付列を datetime 型に変換する必要があります。

CSVやExcelを読み込んだ直後は、まず dtypes や info() で型を確認するのが大切です。

resample()を使う前に日付列をdatetime型にする

注文日 を pd.to_datetime() で datetime 型に変換します。

ここでは、変換後に日付順で並び替えておきます。
日付順に並んでいなくても集計自体はできますが、表示や確認がしやすくなります。

df_date = df.copy()

df_date["注文日"] = pd.to_datetime(df_date["注文日"])
df_date = df_date.sort_values("注文日")

display(df_date)
print(df_date.dtypes)

注文日     datetime64[ns]
カテゴリ            object
商品              object
売上               int64
数量               int64
dtype: object

注文日 の型が datetime64[ns] になりました。

これで、pandasがこの列を「日付として扱える状態」になりました。

日付変換そのものを詳しく知りたい場合は、pandas to_datetime()の使い方で、format や NaT の考え方を確認できます。

方法1：日付列をインデックスにしてresample()する

resample() の基本は、日付列をインデックスにしてから集計する書き方です。

ここでは、set_index("注文日") で 注文日 をインデックスにします。

df_time = df_date.set_index("注文日")

display(df_time)
print(type(df_time.index))

<class 'pandas.core.indexes.datetimes.DatetimeIndex'>

注文日 がインデックスになり、DatetimeIndex として扱われるようになりました。

set_index() の詳しい使い方は、pandas set_index()の使い方で確認できます。

月別売上を集計する：resample(“MS”).sum()

まずは、月別の売上合計を出します。

ここでは resample("MS") を使います。

• MS は、月初基準の月別集計です
• ME は、月末基準の月別集計です
• 古い記事では M と書かれていることがありますが、最近のpandasでは月末基準を表すなら ME を使う方が安全です
• sum() は、売上を合計するために使います

「月別売上を知りたい」場合は、平均ではなく合計を出すことが多いため、ここでは sum() を使います。

この記事では、月ごとの結果を表で見たときに読みやすいように、月初の日付で表示される MS を中心に使います。

monthly_sales = df_time.resample("MS")["売上"].sum().to_frame("月別売上合計")

display(monthly_sales)

1件ずつ並んでいた明細データが、月ごとの売上合計にまとまりました。

このように、resample() は時系列データを「見やすい単位」にまとめるときに役立ちます。

出力例で見る：MS・ME・Mの違い

MS と ME の違いは、集計結果の「ラベル日付」に出ます。

• MS：月初の日付で表示されます
• ME：月末の日付で表示されます
• M：古い記事や古いコードで見かける月末基準の書き方です

売上合計の金額は同じでも、表示される日付ラベルが変わる点を確認してみましょう。

monthly_ms = df_time.resample("MS")["売上"].sum().reset_index()
monthly_ms.columns = ["MSのラベル日付", "MSの売上合計"]

monthly_me = df_time.resample("ME")["売上"].sum().reset_index()
monthly_me.columns = ["MEのラベル日付", "MEの売上合計"]

# 古い記事では resample("M") を見かけることがあります。
# 最近のpandasでは月末基準を表す場合、resample("ME") を使う方が安全です。
try:
    import warnings

    with warnings.catch_warnings():
        warnings.simplefilter("ignore", FutureWarning)
        monthly_m = df_time.resample("M")["売上"].sum().reset_index()

    monthly_m.columns = ["Mのラベル日付", "Mの売上合計"]
    display(pd.concat([monthly_ms, monthly_me, monthly_m], axis=1))

except Exception:
    print("このpandas環境では resample('M') を実行できません。月末基準は resample('ME') を使ってください。")
    display(pd.concat([monthly_ms, monthly_me], axis=1))

MS は 2026-01-01、2026-02-01 のように月初の日付で表示されます。

一方、ME は 2026-01-31、2026-02-28 のように月末の日付で表示されます。

古い記事で見かける M は、月末基準の古い書き方として出てくることがあります。新しく記事を書く場合や、これから学ぶ場合は、月末基準なら ME、月初基準なら MS と覚えておくと混乱しにくいです。

頻度指定の基本：D・W・MS・MEを使い分ける

resample() のカッコの中には、どの時間単位でまとめるかを指定します。

初心者のうちは、まず次の指定を覚えれば十分です。

検索すると、月別集計の例で resample("M") を見かけることがあります。 ただし、最近のpandasでは M よりも、月末基準なら ME、月初基準なら MS と書く方がわかりやすく、今後も安心です。

この記事では、月別の表として見やすいように、主に "MS" を使います。

複数の集計をまとめて出す

月別に、売上合計・注文件数・平均売上・数量合計をまとめて出すこともできます。

ここでは、次のように集計します。

売上合計と平均売上は意味が違います。
また、count() は指定した列の欠損値を数えません。今回のように 売上 列に欠損がない前提なら注文件数として使えますが、行数そのものを数えたい場合は size() も候補になります。
見出しや表の名前と、実際に使う集計方法がズレないように注意しましょう。

monthly_summary = df_time.resample("MS").agg(
    売上合計=("売上", "sum"),
    注文件数=("売上", "count"),
    平均売上=("売上", "mean"),
    数量合計=("数量", "sum")
)

display(monthly_summary)

この表を見ると、月ごとの売上合計だけでなく、注文件数や平均売上も確認できます。

実務では、売上合計だけを見ると「2月が大きい」とわかります。
さらに注文件数や平均売上を見ると、「件数が多いのか、1件あたりの売上が大きいのか」も確認しやすくなります。

週別件数を集計する：resample(“W”).count()

次に、週ごとの注文件数を数えてみます。

ここでは「売上の合計」ではなく、「何件の注文があったか」を見たいので、count() を使います。今回のサンプルでは 売上 列に欠損がないため、売上 を数えることで注文件数を確認できます。

weekly_count = df_time.resample("W")["売上"].count().to_frame("週別注文件数")

display(weekly_count)

W は週別の集計です。

週別集計では、週の区切り方によって結果の見え方が変わることがあります。
初心者のうちは、まず「週ごとにざっくり件数を見る」用途で使い、細かい週の開始日・終了日の指定は必要になったときに確認すれば十分です。

日別平均を集計する：resample(“D”).mean()

次に、日別の平均売上を確認します。

ここでは resample("D") で日別にまとめ、mean() で平均を出します。

daily_mean = df_time.resample("D")["売上"].mean().to_frame("日別平均売上")

display(daily_mean.head(10))

日別にすると、注文がない日も期間として表示されることがあります。

この例では、注文がない日の平均売上は NaN になります。
これはエラーではなく、「その日に集計できるデータがなかった」という意味です。

欠損期間の補完や ffill()、interpolate() などの処理は便利ですが、この記事では深入りしません。
まずは、resample() によって空の期間が見えることがある、と理解しておきましょう。

方法2：on引数で日付列を指定してresample()する

resample() は、必ず set_index() しないと使えないわけではありません。

日付列が datetime 型になっていれば、on="注文日" のように指定して集計できます。

インデックスを変更したくない場合は、この書き方が便利です。

monthly_sales_on = (
    df_date
    .resample("MS", on="注文日")["売上"]
    .sum()
    .reset_index(name="月別売上合計")
)

display(monthly_sales_on)

on="注文日" を使うと、注文日 をインデックスにしなくても月別集計ができます。

初心者の学習では、まず set_index() する基本形を理解し、慣れてきたら on 引数を使うとよいです。

groupby()・dt・resample()の違い

日付データを扱うときは、groupby()、dt、resample() の違いで迷いやすいです。

ここで一度、使い分けを整理します。

月別集計は、dt.month で月列を作って groupby() する方法でもできます。
ただし、年をまたぐデータで「月」だけを使うと、2025年1月と2026年1月が混ざる可能性があります。

日付の流れに沿って月別・週別にまとめたい場合は、resample() を使うと自然です。

比較用：dtで年月列を作ってgroupby()する方法

比較のために、dt.to_period("M") で年月列を作り、groupby() で月別集計する例も確認します。

これは resample() の代わりに使える場面もありますが、この記事ではあくまで違いを理解するための補足です。

df_group = df_date.copy()

df_group["年月"] = df_group["注文日"].dt.to_period("M")

monthly_groupby = (
    df_group
    .groupby("年月")["売上"]
    .sum()
    .reset_index(name="月別売上合計")
)

display(monthly_groupby)

dt と groupby() を組み合わせても月別集計はできます。

ただし、今回のように「日付を時間単位でまとめる」ことが目的なら、resample() を使うと、日別・週別・月別への切り替えがしやすくなります。

dt の詳しい使い方は pandas dtの使い方 で、カテゴリ別集計は Pandas groupby×aggの使い方 で確認できます。

補足：resample()とasfreq()の違い

時系列データの記事では、resample() と一緒に asfreq() というメソッドを見かけることがあります。

初心者のうちは、まず次のように分けて考えると十分です。

resample() は、日付を一定期間の箱に分けて、その箱ごとに合計・平均・件数などを計算します。

一方、asfreq() は、日付の頻度をそろえるための処理です。基本的には集計をするメソッドではありません。

この記事では、月別売上や週別件数のように「期間ごとに集計する」ことが目的なので、主役は resample() です。ここでは、asfreq() が集計ではなく日付の間隔をそろえる処理であることを、短いコードで確認します。

daily_asfreq = df_time["売上"].asfreq("D").to_frame("asfreq_D")
daily_resample_sum = df_time["売上"].resample("D").sum().to_frame("resample_D_sum")

daily_compare = pd.concat([daily_asfreq, daily_resample_sum], axis=1)

display(daily_compare.head(10))

上の表を見ると、asfreq("D") は日付の間隔を日別にそろえるだけなので、注文がない日は NaN になります。

一方、resample("D").sum() は日別の箱を作って売上を合計するため、注文がない日は合計が0のように表示されることがあります。

つまり、集計したいなら resample()、日付の並びをそろえたいなら asfreq() と考えると分かりやすいです。

集計結果をreset_index()で通常の表に戻す

resample() の結果は、日付がインデックスになっていることが多いです。

このままでも分析できますが、CSVに保存したり、他の表と結合したり、WordPress記事で表として見せたりする場合は、reset_index() で通常の列に戻すと扱いやすくなります。

monthly_summary_reset = monthly_summary.reset_index()

monthly_summary_reset["年月"] = monthly_summary_reset["注文日"].dt.strftime("%Y-%m")

display(monthly_summary_reset)

reset_index() によって、インデックスだった 注文日 が通常の列に戻りました。

さらに strftime("%Y-%m") を使うと、2026-01 のような年月表示も作れます。

reset_index() の詳しい使い方は、pandas reset_index()の使い方で確認できます。

集計結果をグラフで確認する

月別集計ができたら、折れ線グラフや棒グラフにすると推移を確認しやすくなります。

ここでは、月別売上合計を簡単な折れ線グラフで表示します。
グラフ装飾は深入りせず、集計結果を可視化につなげる流れだけ確認します。

なお、Google Colabでは日本語フォント設定をしていないと、グラフ内の日本語ラベルが文字化けすることがあります。ここでは、まず resample() の集計結果を確認することを優先し、グラフのタイトルや軸ラベルは英語表記にしています。

ここでは月別の集計結果を折れ線グラフにします。日付ラベルが重ならないように、x軸の表示をYYYY-MM形式にし、ラベルを少し回転させています。

import matplotlib.pyplot as plt
import matplotlib.dates as mdates

plot_df = monthly_summary_reset.copy()

fig, ax = plt.subplots(figsize=(8, 4))
ax.plot(plot_df["注文日"], plot_df["売上合計"], marker="o")

ax.set_title("Monthly Sales")
ax.set_xlabel("Month")
ax.set_ylabel("Sales")
ax.grid(True)

# x軸の日付ラベルが重ならないように、表示形式と角度を調整します
ax.xaxis.set_major_formatter(mdates.DateFormatter("%Y-%m"))
plt.xticks(rotation=45, ha="right")
plt.tight_layout()

plt.show()

このように、resample() で月別に集計すると、売上の推移をグラフで確認しやすくなります。

折れ線グラフの設定を詳しく知りたい場合は、Matplotlib折れ線グラフの描き方を参考にしてください。
月別売上を棒グラフで比較したい場合は、Matplotlib 棒グラフ入門も役立ちます。

よくあるミスと確認ポイント

resample() でつまずきやすいポイントを整理します。

日付列がobject型のままになっている

日付に見えても、object 型のままだと resample() でうまく扱えません。

まず pd.to_datetime() で日付型に変換しましょう。

DatetimeIndexまたはonで指定した日付列が必要

resample() は、日付列そのものを自動で探してくれるわけではありません。

基本形では、日付列をインデックスにします。
インデックスにしたくない場合は、on="注文日" のように指定します。

売上合計・平均・件数を混同しない

sum()、mean()、count() は意味が違います。

count() は、指定した列の欠損値を数えません。欠損を含む列で件数を数える場合は、count() と size() の違いに注意します。

「月別売上を集計する」という見出しなら sum()、
「平均を出す」という見出しなら mean() を使うように、説明とコードを一致させることが大切です。

月だけでgroupbyすると年をまたいだときに混ざる

dt.month だけで集計すると、2025年1月と2026年1月が同じ「1月」としてまとまる可能性があります。

年をまたぐデータでは、dt.to_period("M") を使うか、resample() で年月を意識した集計にする方が安全です。

欠損期間が出ることがある

日別や週別で集計すると、データがない期間が表示されることがあります。
平均なら NaN、合計なら0のように見える場合があります。

これは、resample() が時間の区切りを作って集計しているためです。

resample()はデータ分析の流れのどこで使うか

resample() は、データ分析の流れの中では「日付を使った集計」の場面で使います。

全体の流れで見ると、次の位置づけです。

1. CSVやExcelを読み込む
2. head() や info() でデータを確認する
3. to_datetime() で日付列を日付型にする
4. 必要に応じて sort_values() で日付順に並べる
5. resample() で日別・週別・月別に集計する
6. reset_index() で表として扱いやすくする
7. Matplotlibで推移を可視化する

つまり、resample() は、単独で覚えるよりも、日付変換・集計・可視化へ進む流れの中で覚えると使いやすくなります。

なお、移動平均を出す rolling() や、頻度をそろえる asfreq() も時系列データで使われます。
ただし、この記事では resample() の基本に集中するため、詳しい使い方は別記事で扱う範囲です。

まとめ

この記事では、pandasの resample() を使って、日付データを月別・週別・日別に集計する方法を解説しました。

重要なポイントは次のとおりです。

• resample() は、日付データを日別・週別・月別などの時間単位で集計するために使う
• 使う前に、日付列を pd.to_datetime() で datetime 型に変換する
• 基本形では、set_index("日付列") で日付をインデックスにしてから resample() する
• インデックスを変えたくない場合は、on="日付列" を使える
• 月別売上なら sum()、平均売上なら mean()、件数なら count() を使う
• カテゴリ別にまとめたいなら groupby()、年・月・曜日を取り出したいなら dt、時間単位でまとめたいなら resample() を使う
• 集計結果は reset_index() で通常の表に戻すと扱いやすい
• 月別集計の結果は、折れ線グラフや棒グラフにすると推移を確認しやすい

resample() を使えるようになると、CSVやExcelで読み込んだ日付付きデータから、月別売上・週別件数・日別平均などを作れるようになります。

日付データを前処理して、集計し、可視化する流れの中で、とても役立つメソッドです。

次に読みたい関連記事

日付集計をさらに理解するには、次の記事も参考になります。

• pandas to_datetime()の使い方｜文字列の日付変換と format・NaT 対処を初心者向けに解説
• pandas dtの使い方｜日付から年・月・曜日を取り出す方法を初心者向けに解説
• pandas set_index()の使い方｜列をインデックスにする・drop=False・index_col・reset_indexとの違いを解説
• pandas reset_index()の使い方｜インデックスを振り直す・drop=Trueを初心者向けに解説
• Pandas groupby×aggの使い方｜基本の集計とaggの書き方を例で解説
• pandas 並び替え（sort）入門｜sort_values・sort_indexの違いと複数列ソート
• Matplotlib折れ線グラフの描き方：色・線種・凡例を完全解説
• Matplotlib 棒グラフ入門：横棒・グループ化・積み上げまで解説
• Google ColabでCSVを読み込む方法｜Drive連携とpandas read_csvを初心者向けに解説

▲ ページトップへ戻る

<p>The post pandas resample()の使い方｜日付データを月別・週別に集計する方法 first appeared on Python Data Lab（Pythonデータラボ）.</p>

CSVを読み込んだあと、「地域ごとに購入あり・購入なしの件数を見たい」「年代ごとに満足度の分布を確認したい」と思うことがあります。

このように、2つの列の組み合わせごとの件数を表で見たいときに便利なのが、pandasの crosstab() です。

crosstab() を使うと、たとえば「地域×購入有無」「年代×満足度」のようなクロス集計表を短いコードで作れます。

基本形は次のとおりです。

pd.crosstab(df["行にしたい列"], df["列にしたい列"])

この記事では、pandasの crosstab() を使って、2つの列を組み合わせたクロス集計表を作る方法を解説します。あわせて、value_counts()、groupby()、pivot_table() との違い、割合表示、合計行・合計列も整理します。

この記事でわかること

この記事では、crosstab() で2つの列の組み合わせを集計する方法を学びます。

具体的には、次の内容を扱います。

• pd.crosstab() の基本的な使い方
• 1列だけを見る value_counts() との違い
• 2つの列を組み合わせたクロス集計表の作り方
• 合計行・合計列を追加する方法
• 件数を割合で表示する方法
• 欠損値があるときの注意点
• crosstab() が役立つ実践的な場面

crosstab() は、value_counts() で1列の件数を確認したあとに、2つの列の関係を表で見たいときに使うメソッドです。

crosstab()が役立つ場面

crosstab() は、2つの列の組み合わせごとの件数を見たい場面で役立ちます。

この記事では、まず 地域×購入有無 と 年代×満足度 の例で、基本的なクロス集計を確認します。

サンプルデータを作成する

ここでは、地域・年代・商品カテゴリ・購入有無・満足度を含む小さなデータを使います。

実務ではCSVから読み込むことが多いですが、この記事ではGoogle Colabでそのまま試せるように、DataFrameを直接作成します。

import pandas as pd

df = pd.DataFrame({
    "地域": ["東京", "東京", "東京", "大阪", "大阪", "大阪", "名古屋", "名古屋", "福岡", None],
    "年代": ["20代", "20代", "30代", "40代", "40代", "30代", "20代", "30代", "40代", "30代"],
    "商品カテゴリ": ["PC", "PC", "文房具", "家具", "家具", "文房具", "PC", "文房具", "家具", "PC"],
    "購入有無": ["購入あり", "購入あり", "購入あり", "購入なし", "購入なし", "購入なし", "購入あり", "購入なし", "購入なし", "購入あり"],
    "満足度": ["高い", "高い", "普通", "低い", "低い", "普通", "高い", "普通", "低い", None]
})

df

このデータでは、クロス集計後の傾向が見えやすいように、次のような特徴を入れています。

地域 と 満足度 には、あえて欠損値も入れています。
あとで、欠損値がある場合の注意点も確認します。

1列だけならvalue_counts()で確認する

crosstab() は2つの列の組み合わせを見る方法です。

一方、1つの列だけの件数を見たい場合は、value_counts() のほうが簡単です。

まずは、地域 列だけの件数を確認してみます。

df["地域"].value_counts()

value_counts() では、地域ごとの件数を確認できます。

ただし、これだけでは「地域ごとに購入あり・購入なしが何件あるか」は見えません。

1列だけを見るなら value_counts()、2つの列の組み合わせを見るなら crosstab() と考えるとわかりやすいです。

2つの列を組み合わせたクロス集計表を作る

ここからは、pd.crosstab() を使って実際にクロス集計表を作ります。

まずは、地域 と 購入有無 を指定して、地域ごとの購入状況を集計します。

地域×購入有無を集計する

「地域ごとに、購入あり・購入なしが何件あるか」を確認する例です。

pd.crosstab(df["地域"], df["購入有無"])

この結果を見ると、行に 地域、列に 購入有無 が並びます。

たとえば、このサンプルデータでは、東京は「購入あり」が多く、大阪は「購入なし」が多いことがわかります。

crosstab() は元のDataFrameを書き換える処理ではなく、集計結果として新しい表を作る処理です。

行と列を入れ替えると見え方が変わる

crosstab() では、最初に指定した列が行、2つ目に指定した列が列になります。

次のコードでは、先ほどとは逆に、購入有無 を行、地域 を列に置いてみます。

pd.crosstab(df["購入有無"], df["地域"])

集計している内容は同じでも、pd.crosstab() に指定する列の順番を変えると、行と列が入れ替わります。

初心者のうちは、「比較したいグループ」を1つ目の引数、つまり行側に置くと読みやすくなります。

年代×満足度を集計する

同じ考え方で、年代 と 満足度 の組み合わせも集計できます。

これは、アンケート集計のように「年代ごとに、満足度がどのように分布しているか」を確認する例です。

pd.crosstab(df["年代"], df["満足度"])

この表では、年代ごとに「高い」「普通」「低い」が何件あるかを確認できます。

このサンプルデータでは、20代は「高い」が多く、40代は「低い」が多いことがわかります。

このように、単に満足度全体の件数を見るだけでなく、年代別に分けると傾向が見えやすくなります。
crosstab() は、アンケート集計の入口としても使いやすい方法です。

合計行・合計列を追加する

クロス集計表では、行ごとの合計や列ごとの合計も見たいことがあります。

その場合は、margins=True を指定します。

pd.crosstab(df["地域"], df["購入有無"], margins=True)

margins=True を使うと、合計行・合計列が追加されます。

全体の件数も同時に確認したいときに便利です。

件数を割合で表示する

件数だけでなく、割合で見たい場合は normalize を使います。

normalize は、何を分母にして割合を出すかを指定する引数です。

全体に対する割合を見る

まずは、全体に対する割合を見てみます。

# 全体に対する割合を表示する
pd.crosstab(df["地域"], df["購入有無"], normalize=True)

この表では、全体を1として、それぞれの組み合わせがどれくらいの割合かを表しています。

実務でよく使うのは、次の normalize="index" です。
たとえば、地域ごとに「購入あり」「購入なし」の割合を見たいときに使います。

行ごとの割合を見る

normalize="index" は、行ごとの合計を1として割合を出します。

次の例では、地域ごとに「購入あり」「購入なし」の割合を確認します。

# 行ごとの割合を表示する
# ここでは「地域ごとに、購入あり・購入なしの割合」を見る
pd.crosstab(df["地域"], df["購入有無"], normalize="index")

この表では、各地域の中で「購入あり」「購入なし」がどれくらいの割合かを確認できます。

normalize="index" は、行ごとの割合です。
「年代ごとの満足度割合」を見たい場合も同じ考え方で使えます。

# 行ごとの割合を表示する
# ここでは「年代ごとに、満足度の割合」を見る
pd.crosstab(df["年代"], df["満足度"], normalize="index")

このコードでは、年代ごとに満足度の割合を見ています。

「20代の中では高いが何割か」「30代の中では普通が何割か」のように、行ごとの分布を確認できます。

列ごとの割合を見る

normalize="columns" は、列ごとの合計を1として割合を出します。

次の例では、購入あり・購入なしごとに、地域の構成を確認します。

# 列ごとの割合を表示する
# ここでは「購入あり・購入なしごとに、地域の割合」を見る
pd.crosstab(df["地域"], df["購入有無"], normalize="columns")

この表では、列ごとの合計が1になります。

normalize=True、normalize="index"、normalize="columns" は、分母が違います。
割合を見るときは、「何を1としているのか」を必ず確認しましょう。

小数を見やすく丸める

割合表示では、小数が長く表示されることがあります。

最初は割合の意味を理解することが大切ですが、表として見やすくしたい場合は .round() を使うと便利です。

# 行ごとの割合を、小数第2位まで表示する
pd.crosstab(df["地域"], df["購入有無"], normalize="index").round(2)

この例では、小数第2位まで表示しています。

パーセント表記に整える方法もありますが、この記事では深入りしません。
まずは、normalize の種類によって分母が変わることを理解しておきましょう。

欠損値があるときの注意点

crosstab() で使う列に欠損値があると、その行は集計表に入らない場合があります。

まずは、どの列に欠損値があるかを確認します。

df.isnull().sum()

今回のデータでは、地域 と 満足度 に欠損値があります。

ここでは、地域 が欠損している行を確認してみます。

df[df["地域"].isnull()]

元データは10行あります。

len(df)

10

次に、地域×購入有無 のクロス集計表に合計行・合計列を付けて確認します。

pd.crosstab(df["地域"], df["購入有無"], margins=True)

クロス集計表の合計は9件です。

元データは10行ありますが、地域 が欠損している行は、東京・大阪・名古屋・福岡のどこにも分類できません。

そのため、地域×購入有無 のクロス集計表には入らず、合計が9件になります。

このように、crosstab() で使う列に欠損値があると、集計表の合計件数が元データの行数より少なく見えることがあります。

欠損値を「未回答」として集計したい場合は、fillna() で置き換えてから crosstab() を使います。

df_filled = df.copy()
df_filled["地域"] = df_filled["地域"].fillna("未回答")
df_filled["満足度"] = df_filled["満足度"].fillna("未回答")

pd.crosstab(df_filled["地域"], df_filled["購入有無"], margins=True)

ここでは、欠損値を「未回答」として扱いました。

ただし、欠損値をすべて機械的に埋めればよいわけではありません。
未回答なのか、入力漏れなのか、分析対象外なのかを考えてから処理しましょう。

実務では、件数表から割合表示につなげる

crosstab() は、件数表を作って終わりではなく、合計や割合を確認すると傾向が見えやすくなります。

基本の流れは、次のとおりです。

1. value_counts() で1列の件数を確認する
2. crosstab() で2つの列の組み合わせを集計する
3. margins=True で合計を見る
4. normalize で割合を見る

まずは、件数表を作る → 合計を見る → 割合を見る の順番で確認すると、結果を読み取りやすくなります。

まとめ

この記事では、pandasの crosstab() を使って、2つの列を組み合わせたクロス集計表を作る方法を解説しました。

ポイントを整理します。

• crosstab() は、2つの列の組み合わせを件数表にしたいときに使う
• 1列の件数確認なら value_counts() が向いている
• 2列の組み合わせを見るなら crosstab() がわかりやすい
• 数値列の合計や平均を出したい場合は、groupby() や pivot_table() が向いている
• margins=True で合計行・合計列を追加できる
• normalize を使うと、件数を割合で表示できる
• normalize=True、normalize="index"、normalize="columns" は分母が違う
• 欠損値がある場合は、集計前に isnull() で確認すると安全

なお、values や aggfunc を使う発展的な集計もありますが、初心者はまず「2つの列の件数表を作る」基本形を押さえれば十分です。

crosstab() を使えるようになると、単に1列の件数を見るだけでなく、2つの列の関係を表で確認できるようになります。

「地域×購入有無」「年代×満足度」など、2つの列の組み合わせを表で確認できるため、value_counts() の次に覚えておきたいメソッドです。

次に読みたい関連記事

crosstab() を理解したら、次の記事に進むと、データ分析の流れがつながりやすくなります。

• pandas value_counts()の使い方｜件数集計・割合表示・欠損値の数え方を解説
  1列の件数集計を復習したい場合におすすめです。

• Pandas groupby×aggの使い方｜基本の集計とaggの書き方を例で解説
  カテゴリ別に売上合計や平均を出したい場合に役立ちます。

• Pandas pivotとpivot_tableの違い｜重複データ対応と集計方法
  表の形を変えながら、より柔軟に集計したい場合におすすめです。

• pandas melt()の使い方｜横持ちデータを縦持ちに変換する方法
  集計しやすい縦長データに整える方法を学べます。

• 欠損値を可視化して攻略！Pandas isnullとヒートマップ活用術
  集計前に欠損値を確認したい場合におすすめです。

• pandas fillna()の使い方｜欠損値を0・平均値・中央値・最頻値で埋める方法を初心者向けに解説
  欠損値をどう扱うかを学びたい場合に役立ちます。

▲ ページトップへ戻る

<p>The post pandas crosstab()の使い方｜2つの列をクロス集計・割合表示する方法 first appeared on Python Data Lab（Pythonデータラボ）.</p>

CSVを読み込んだあと、月別の売上や科目別の点数が横に並んでいて、集計しにくいと感じることがあります。

たとえば、次のような表です。

このような表は、人間が見るにはわかりやすいです。

しかし、Pandasで月ごとに集計したり、グラフ化したりする場合は、次のように「月」と「売上」を列として持つ形のほうが扱いやすくなります。

このように、横に広がった列を縦長にまとめるときに使うのが、Pandasの melt() です。

この記事では、melt() の基本、id_vars と value_vars の使い分け、groupby() やグラフ化へつなげる流れを、初心者向けに順番に解説します。

この記事でわかること

• melt() が何をするメソッドか
• 横持ちデータと縦持ちデータの違い
• id_vars と value_vars の使い分け
• var_name と value_name で列名を整える方法
• melt() 後に行数が増える理由
• value_vars を省略するときの注意点
• melt() 後に groupby() や棒グラフへつなげる流れ

この記事のゴールは、横に広がったDataFrameを、集計・可視化しやすい縦持ちデータに変換できるようになることです。

発展的な内容や環境差が出やすい内容は、本文の後半で補足として扱います。

melt()はどんな場面で使うのか

melt() は、次のように「同じ種類の情報が複数の列に分かれている」ときに役立ちます。

横持ちデータは人間が見る表としては便利です。

一方で、Pandasで集計・条件抽出・グラフ化をする場合は、項目名と値が列として分かれている縦持ちデータのほうが扱いやすいことがあります。

迷ったときは、次のように判断すると整理しやすいです。

つまり、melt() は「横に並んだ同じ種類の列を、1つの項目列と1つの値列にまとめたい」ときに使います。

横持ちデータと縦持ちデータの違い

melt() を理解するには、まず横持ちデータと縦持ちデータの違いを押さえるとわかりやすいです。

melt() は、横持ちデータを縦持ちデータに変換するためのメソッドです。

ポイントは、列名として横に並んでいた情報を、1つの列の値として縦に並べ直すことです。

図解：横に並んだ月別列を縦にまとめる

図のように、1月、2月、3月 のように横に並んだ列を、月 列と 売上 列にまとめます。

このとき、社員名 のように残したい列は id_vars に指定します。

一方で、1月、2月、3月 のように縦へまとめたい列は value_vars に指定します。

melt() は売上を合計する処理ではありません。集計やグラフ化をしやすい形に並べ直す前処理です。

サンプルデータを用意する

ここでは、社員ごとの月別売上データを使います。

1月、2月、3月 が横に並んでいるため、月別に集計したいときには少し扱いにくい形です。

import pandas as pd

df = pd.DataFrame({
    "社員ID": ["E001", "E002", "E003"],
    "社員名": ["佐藤", "鈴木", "田中"],
    "部署": ["営業部", "営業部", "企画部"],
    "1月": [120000, 98000, 150000],
    "2月": [135000, 110000, 142000],
    "3月": [128000, 105000, 160000]
})

df

このデータでは、社員ID、社員名、部署 は社員を説明する列です。

一方で、1月、2月、3月 は、月別の売上を表す列です。

今回目指す形は、次のとおりです。

つまり、社員を説明する列は残し、月別売上の列だけを縦にまとめます。

基本形：melt()で横持ちを縦持ちに変換する

melt() の基本形は次のとおりです。

df.melt(
    id_vars=[残す列],
    value_vars=[縦にまとめる列],
    var_name="項目列の名前",
    value_name="値列の名前"
)

今回の場合は、社員情報を残し、月別売上の列を縦にまとめます。

melt()は3つに分けて考えると迷いにくい

melt() では、最初に次の3つを決めると迷いにくくなります。

初心者が一番迷いやすいのは、id_vars と value_vars の分け方です。

まずは「社員名や部署のように説明として残す列」と「1月・2月・3月のように縦へまとめる列」を分けて考えると、コードを書きやすくなります。

sales_long = df.melt(
    id_vars=["社員ID", "社員名", "部署"],
    value_vars=["1月", "2月", "3月"],
    var_name="月",
    value_name="売上"
)

sales_long

1月、2月、3月 の列が、月 列にまとまりました。

それぞれの金額は、売上 列に入っています。

melt() では、まず「残す列」と「縦にまとめる列」を分けるのがポイントです。

melt()後に行数が増える理由

melt() を初めて使うと、行数が増えることに驚くかもしれません。

今回のデータは、変換前は3人分なので3行です。

しかし、1人につき 1月、2月、3月 の3つの売上があるため、melt() 後は次のように行数が増えます。

melt() は、データを消しているのではありません。

横に並んでいた値を、縦に並べ直しているため、行数が増えるのは自然な動きです。

print("変換前の行数:", len(df))
print("変換後の行数:", len(sales_long))

変換前の行数: 3
変換後の行数: 9

このように、melt() 後は「元の行数 × 縦にまとめた列数」に近い行数になります。

今回であれば、3人 × 3か月なので9行です。

補足：元のindexを残したいときはignore_index=False

melt() は、通常は変換後に新しい連番indexを付けます。

多くの場合はそのままで問題ありません。

ただし、元の行番号やindexを確認しながら変換結果を見たいときは、ignore_index=False を指定できます。

初心者のうちは必須ではありませんが、melt() 後に「元のindexはどうなるのか」で迷ったときに知っておくと便利です。

df.melt(
    id_vars=["社員ID", "社員名", "部署"],
    value_vars=["1月", "2月", "3月"],
    var_name="月",
    value_name="売上",
    ignore_index=False
)

ignore_index=False を指定すると、変換前のindexが残ります。

今回の例では、元データの0行目、1行目、2行目が、それぞれ月の数だけ繰り返されます。

ただし、通常の分析では新しい連番indexで問題ないことが多いため、最初は省略して構いません。

id_varsの意味：そのまま残す列

id_vars には、melt後もそのまま残したい列を指定します。

今回の例では、次の列です。

• 社員ID
• 社員名
• 部署

初心者向けに言うと、id_vars は縦にまとめない列です。

id_vars に入れない列は、結果に残らないことがあります。

後で使いたい列は、id_vars に入れておきましょう。

df.melt(
    id_vars=["社員名"],
    value_vars=["1月", "2月", "3月"],
    var_name="月",
    value_name="売上"
)

この例では、社員名 だけを id_vars にしたため、社員ID と 部署 は結果に残りません。

あとで部署別に集計したいなら、部署 も id_vars に含める必要があります。

value_varsの意味：縦にまとめる列

value_vars には、縦にまとめたい列を指定します。

月別売上データなら、1月、2月、3月 が該当します。

value_vars は、「この列たちを1つの項目列と値列にまとめたい」と指定する場所です。

df.melt(
    id_vars=["社員ID", "社員名", "部署"],
    value_vars=["1月", "3月"],
    var_name="月",
    value_name="売上"
)

この例では、value_vars に 1月 と 3月 だけを指定しています。

そのため、2月 は結果に含まれません。

分析対象にしたい列だけを選んで縦にまとめられるのが、value_vars の便利な点です。

var_nameとvalue_nameで列名をわかりやすくする

var_name と value_name を指定しない場合、melt後の列名は variable と value になります。

df.melt(
    id_vars=["社員ID", "社員名", "部署"],
    value_vars=["1月", "2月", "3月"]
)

このままでも処理はできますが、variable と value だけでは、何を表している列なのかがわかりにくいです。

そこで、次のように指定します。

実務でも記事でも、var_name と value_name は指定しておくと読みやすくなります。

sales_long = df.melt(
    id_vars=["社員ID", "社員名", "部署"],
    value_vars=["1月", "2月", "3月"],
    var_name="月",
    value_name="売上"
)

sales_long

variable と value ではなく、月 と 売上 という列名になりました。

あとで groupby("月") や sales_long["売上"] のように書くときも、意味が読み取りやすくなります。

value_nameは既存の列名と重ならない名前にする

value_name には、melt後の値列の名前を指定します。

この名前は、元のDataFrameにすでにある列名と重ならないようにするのが安全です。

たとえば、元データにすでに 売上 という列があるのに、value_name="売上" と指定すると、列名の重複やエラーの原因になることがあります。

今回のサンプルでは、元データに 売上 列はなく、1月、2月、3月 の値をまとめた列として新しく 売上 という名前を付けています。

細かい点ですが、実務データでは列名が増えやすいため、melt後の列名は元の列名と重ならないように確認しておきましょう。

value_varsを省略した場合の注意点

value_vars は省略できます。

ただし、省略すると、id_vars 以外の列がすべて縦にまとめられます。

df.melt(
    id_vars=["社員ID", "社員名", "部署"],
    var_name="月",
    value_name="売上"
)

今回のデータでは、id_vars 以外が 1月、2月、3月 だけなので問題ありません。

しかし、実際のCSVには 備考、登録日、メモ のような列が含まれることがあります。

その場合、value_vars を省略すると、意図しない列まで縦にまとめられる可能性があります。

初心者のうちは、value_vars を明示するほうが安全です。

value_varsを省略すると不要な列まで入る例

次のように、元データに 備考 列があるケースを考えます。

備考 は売上ではないため、本来は 月 や 売上 にまとめたくない列です。

df_extra = df.copy()
df_extra["備考"] = ["重点顧客", "通常", "確認中"]

df_extra

この状態で value_vars を省略すると、id_vars 以外の列がすべて縦にまとめられます。

つまり、1月、2月、3月 だけでなく、備考 まで 月 列に入ってしまいます。

df_extra.melt(
    id_vars=["社員ID", "社員名", "部署"],
    var_name="月",
    value_name="売上"
)

備考 は売上ではないので、この結果は分析しにくい形です。

このようなミスを防ぐには、縦にまとめたい列を value_vars で明示します。

df_extra.melt(
    id_vars=["社員ID", "社員名", "部署", "備考"],
    value_vars=["1月", "2月", "3月"],
    var_name="月",
    value_name="売上"
)

このように、value_vars を指定すると、売上に関係する月別列だけを縦にまとめられます。

実際のCSVでは、メモ列、登録日、区分、備考などが混ざっていることがあります。初心者のうちは、value_vars を省略せずに明示するほうが安全です。

科目別点数データでもmelt()を使う

月別売上だけでなく、科目別点数のようなデータでも melt() は使えます。

ここでは、国語、数学、英語 が横に並んだデータを、科目 列と 点数 列に変換します。

score_df = pd.DataFrame({
    "生徒ID": ["S001", "S002", "S003"],
    "氏名": ["山田", "田中", "伊藤"],
    "クラス": ["A", "A", "B"],
    "国語": [82, 75, 90],
    "数学": [70, 88, 95],
    "英語": [78, 84, 92]
})

score_df

score_long = score_df.melt(
    id_vars=["生徒ID", "氏名", "クラス"],
    value_vars=["国語", "数学", "英語"],
    var_name="科目",
    value_name="点数"
)

score_long

国語、数学、英語 が 科目 列にまとまり、点数は 点数 列に入りました。

この形にしておくと、科目ごとの平均点を出しやすくなります。

score_long.groupby("科目", as_index=False)["点数"].mean()

この例では、melt() で科目ごとに集計しやすい形へ変換し、その後に groupby() で平均点を計算しています。

melt()した後にgroupby()で集計する

melt() のメリットは、変換後に groupby() へつなげやすいことです。

先ほど作成した sales_long を使って、月ごとの売上合計を確認してみます。

monthly_sales = sales_long.groupby("月", as_index=False)["売上"].sum()

monthly_sales

縦持ちにしておくと、月 という列を基準に集計できます。

melt() は集計の前処理、groupby() は集計本体と考えると整理しやすいです。

melt()した後にvalue_counts()で件数を確認する

melt() 後のカテゴリ列は、value_counts() でも扱いやすくなります。

たとえば、科目別点数データで、科目ごとの行数を確認してみます。

score_long["科目"].value_counts()

この例では、各生徒に3科目分のデータがあるため、各科目が同じ件数になります。

実務では、商品名、カテゴリ、月、地域などを縦持ちにしておくと、カテゴリごとの件数確認がしやすくなります。

melt()した後に棒グラフで可視化する

縦持ちデータに変換すると、Matplotlibの棒グラフにもつなげやすくなります。

ここでは、月ごとの売上合計を棒グラフで表示します。

Google Colabでは、日本語の軸ラベルやタイトルが文字化けする場合があります。この記事では melt() 後にグラフ化へ進む流れを確認することを目的にしているため、基本コードでは英語ラベルを使います。日本語で表示したい場合の対処法は、この後の補足で紹介します。

import matplotlib.pyplot as plt

monthly_sales = sales_long.groupby("月", as_index=False)["売上"].sum()

plt.figure(figsize=(6, 4))
plt.bar(monthly_sales["月"], monthly_sales["売上"])
plt.xlabel("Month")
plt.ylabel("Sales")
plt.title("Monthly Sales")
plt.show()

/usr/local/lib/python3.12/dist-packages/IPython/core/pylabtools.py:151: UserWarning: Glyph 26376 (\N{CJK UNIFIED IDEOGRAPH-6708}) missing from font(s) DejaVu Sans.
  fig.canvas.print_figure(bytes_io, **kw)

流れは次のとおりです。

1. 横持ちデータを用意する
2. melt() で縦持ちデータに変換する
3. groupby() で月別に集計する
4. Matplotlibで棒グラフにする

melt() はグラフを描くメソッドではありません。

ただし、グラフ化しやすいデータの形を作る前処理として役立ちます。

補足：Colabでグラフの日本語ラベルが文字化けするとき

Google ColabでMatplotlibのグラフを描くと、日本語のタイトルや軸ラベルが文字化けすることがあります。

この記事では、まず melt() の流れを理解しやすくするため、基本のグラフでは英語ラベルを使いました。

日本語で表示したい場合は、次のように japanize-matplotlib を使う方法があります。

# Colabで日本語ラベルを使いたい場合
!pip -q install japanize-matplotlib

import matplotlib.pyplot as plt
import japanize_matplotlib

monthly_sales = sales_long.groupby("月", as_index=False)["売上"].sum()

plt.figure(figsize=(6, 4))
plt.bar(monthly_sales["月"], monthly_sales["売上"])
plt.xlabel("月")
plt.ylabel("売上")
plt.title("月別売上")
plt.show()

この補足は、グラフの表示環境に関する内容です。

melt() の使い方そのものは、英語ラベルでも日本語ラベルでも変わりません。

melt()とpivot()・pivot_table()の違い

melt()、pivot()、pivot_table() は、どれもDataFrameの形を変える場面で出てきます。

違いは、変換する向きと集計の有無です。

melt() と pivot() は、ざっくり言うと逆方向の処理です。

# melt()で作った縦持ちデータ
sales_long

# 縦持ちデータを、社員名×月の横持ちデータに戻す例
sales_pivot = sales_long.pivot(
    index="社員名",
    columns="月",
    values="売上"
)

sales_pivot

この記事では melt() を中心に扱っています。

pivot() や pivot_table() の詳しい使い方は、集計表を作る場面で学ぶと理解しやすいです。

melt()とconcat()・merge()の違い

melt() は、1つのDataFrameの形を変える処理です。

concat() や merge() は、複数のDataFrameを結合する処理です。