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

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

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

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

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

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

この記事でわかること

• 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>

東京を指定したのに一部の行が出てこない。同じ地域が別々に集計される。正しい列名なのにKeyErrorになる——原因は、CSVやExcelに紛れ込んだ見えない空白かもしれません。pandasでは、文字列が入った列にstr.strip()を使うと前後の空白を削除できます。

df["地域"] = df["地域"].str.strip()

左側だけならstr.lstrip()、右側だけならstr.rstrip()、列名の前後空白ならdf.columns.str.strip()を使います。この記事では、空白を見つけるところから、削除後に抽出・集計が正しくできることを確認するところまで、Google Colabで試せる例で解説します。

この記事でわかること

• df["列名"].str.strip()で値の前後空白を削除する方法
• str.strip()・str.lstrip()・str.rstrip()の違い
• df.columns.str.strip()で列名の空白を削除する方法
• 半角スペース・全角スペース・タブ・改行・NaNの注意点
• str.strip()・str.replace()・replace()・rename()の使い分け
• unique()やvalue_counts()で修正前後を確認する方法

先に判断基準：値の両端ならstr.strip()、左端だけならstr.lstrip()、右端だけならstr.rstrip()、列名の両端ならdf.columns.str.strip()です。文字列の途中にある空白や、別の値への置換は目的が異なります。

Pandas DataFrame入門シリーズでの位置づけ

空白の除去は、データを読み込んで内容を確認したあと、抽出・集計・結合へ進む前に行う前処理です。

CSV・Excel読込 → 値と型の確認 → 前後空白の除去 → 表記ゆれの修正 → 抽出・集計・結合

Google ColabへのCSV読込はこちらの記事、Excelの読込はread_excel()の記事で詳しく解説しています。

見えない空白が抽出・集計を狂わせる

次の売上データには、地域名の前後に半角スペースや全角スペースが混ざっています。表では違いが分かるよう、半角スペースを␠、全角スペースを□として示します。実際のDataFrameでは、これらは見えにくい文字です。

行	実際の値	見える表記	売上
0	東京	東京	1200
1	東京	␠東京	1800
2	東京	東京␠	1500
3	東京	□東京□	900
4	大阪	大阪	1100
5	NaN	欠損値	700

まずは追加ファイル不要のサンプルデータを作り、空白を除去する前の状態を確認します。repr()を使うと、半角スペースは引用符の内側に見え、全角スペースも位置を確認しやすくなります。

import pandas as pd
import numpy as np

df = pd.DataFrame({
    "地域": ["東京", " 東京", "東京 ", "　東京　", "大阪", np.nan],
    "商品": ["商品A", "商品B", "商品C", "商品D", "商品E", "商品F"],
    "売上": [1200, 1800, 1500, 900, 1100, 700]
})

print("repr()で確認:")
print(df["地域"].map(repr).to_list())

print("\n空白除去前の件数:")
print(df["地域"].value_counts(dropna=False))

print("\n'東京'と完全一致する行:")
display(df[df["地域"] == "東京"] )

repr()で確認:
["'東京'", "' 東京'", "'東京 '", "'\\u3000東京\\u3000'", "'大阪'", 'nan']

空白除去前の件数:

	count
東京	1
東京	1
東京	1
東京	1
大阪	1
nan	1

'東京'と完全一致する行:

	地域	商品	売上
0	東京	商品A	1200

東京、東京、東京、　東京　は、pandasでは別の文字列です。そのため、空白除去前のvalue_counts()では別々に数えられ、== "東京"では空白のない1行しか抽出されません。

値の種類を詳しく調べる方法はunique()・nunique()の記事、件数の確認方法はvalue_counts()の記事も参考にしてください。

str.strip()で文字列の前後空白を削除する

pandasでは、DataFrameの1列分を**Series（シリーズ）**と呼びます。列に入っている文字列をまとめて処理するため、.strを付けてdf["地域"].str.strip()と書きます。

str.strip()は、前後の半角スペース・全角スペース・タブ・改行などを取り除きます。文字列の途中にある空白は残ります。画面では見えない特殊な文字が残る場合もあるため、実データでは処理前後を確認しましょう。

# 処理前の値を残し、比較できるようにする
df["地域_処理前"] = df["地域"]

# 結果を代入して、地域列を更新する
df["地域"] = df["地域"].str.strip()

comparison = df[["地域_処理前", "地域"]].copy()
comparison["処理前_repr"] = comparison["地域_処理前"].map(repr)
comparison["処理後_repr"] = comparison["地域"].map(repr)
display(comparison[["処理前_repr", "処理後_repr"]])

print("空白除去後の件数:")
print(df["地域"].value_counts(dropna=False))

print("\n空白除去後に'東京'と一致する行:")
display(df[df["地域"] == "東京"][["地域", "商品", "売上"]])

	処理前_repr	処理後_repr
0	‘東京’	‘東京’
1	‘ 東京’	‘東京’
2	‘東京 ‘	‘東京’
3	‘\u3000東京\u3000’	‘東京’
4	‘大阪’	‘大阪’
5	nan	nan

空白除去後の件数:

	count
東京	4
大阪	1
nan	1

空白除去後に'東京'と一致する行:

	地域	商品	売上
0	東京	商品A	1200
1	東京	商品B	1800
2	東京	商品C	1500
3	東京	商品D	900

処理後は、空白違いで分かれていた4つの値がすべて東京になります。その結果、value_counts()では東京が4件にまとまり、条件抽出でも4行を取得できます。空白除去によって別々だったカテゴリが統合されるため、集計件数が変わるのは正常です。

処理前	処理後
東京	東京
␠東京	東京
東京␠	東京
□東京□	東京
大阪	大阪
NaN	NaN

NaNは空文字列ではなく欠損値です。str.strip()を使っても欠損値のまま保たれます。欠損値を埋めたい場合は、空白除去とは分けてfillna()を検討します。

重要：df["地域"].str.strip()を実行しただけでは、元の列は変わりません。更新するにはdf["地域"] = ...のように結果を代入します。

str.strip()・str.lstrip()・str.rstrip()の違い

同じ文字列を使うと、どちら側の空白が削除されるかを比較できます。

目的	pandasでの書き方	結果のイメージ
前後を削除	s.str.strip()	␠東京␠ → 東京
左側だけ削除	s.str.lstrip()	␠東京␠ → 東京␠
右側だけ削除	s.str.rstrip()	␠東京␠ → ␠東京

s = pd.Series([" 東京 ", "　大阪　", "商品 A", "\t名古屋\n"])

result = pd.DataFrame({
    "元の値": s.map(repr),
    "strip": s.str.strip().map(repr),
    "lstrip": s.str.lstrip().map(repr),
    "rstrip": s.str.rstrip().map(repr)
})
display(result)

	元の値	strip	lstrip	rstrip
0	‘ 東京 ‘	‘東京’	‘東京 ‘	‘ 東京’
1	‘\u3000大阪\u3000’	‘大阪’	‘大阪\u3000’	‘\u3000大阪’
2	‘商品 A’	‘商品 A’	‘商品 A’	‘商品 A’
3	‘\t名古屋\n’	‘名古屋’	‘名古屋\n’	‘\t名古屋’

strip(chars)は指定した語句を丸ごと削除する機能ではない

strip("abc")は、abcという並びを探して削除する機能ではありません。文字列の両端から、a・b・cのどれかに当たる文字を1文字ずつ取り除きます。それ以外の文字に当たると処理が止まり、文字列の途中にある文字は削除されません。

次の例では、両端にあるH・e・l・o・!は削除されますが、途中のPythonに含まれるoは残ります。

sample = pd.Series(["Helloooo! Python!"])
print(sample.str.strip("Helo!").iloc[0])
# 結果は ' Python'。途中にあるPythonのoは削除されない

 Python

補足：文字以外の値が混ざる列に注意する

1つの列に文字列と数値が混ざっている場合は注意が必要です。.str.strip()を使うと、数値やTrue・Falseは欠損値になります。元からあるNaNも欠損値のままです。実行前に、対象列へ文字列だけが入っているか確認しましょう。

mixed = pd.Series([" 東京 ", 100, True, np.nan], dtype="object")
mixed_result = pd.DataFrame({
    "処理前": mixed.map(repr),
    "処理後": mixed.str.strip().map(repr)
})
display(mixed_result)

	処理前	処理後
0	‘ 東京 ‘	‘東京’
1	100	nan
2	True	nan
3	nan	nan

商品 Aのような文字列途中の空白は、どのstrip系メソッドでも残ります。途中の空白を削除・置換したい場合はstr.replace()の役割です。

空白除去では引数を省略する使い方を基本にすると安全です。

列名の前後空白はdf.columns.str.strip()で削除する

CSVやExcelの見出しに空白が入っていると、df["売上"]と指定しても、実際の列名が" 売上"ならKeyErrorになります。列の値ではなく列名を整える場合は、df.columnsに対してstr.strip()を使います。

変更前の列名	変更後の列名
商品名	商品名
␠売上	売上
地域␠	地域

df_columns = pd.DataFrame(
    [["商品A", 1200, "東京"], ["商品B", 1100, "大阪"]],
    columns=["商品名", " 売上", "地域 "],
)

print("変更前:", [repr(col) for col in df_columns.columns])
df_columns.columns = df_columns.columns.str.strip()
print("変更後:", [repr(col) for col in df_columns.columns])

# 空白除去後は、空白なしの列名で選択できる
display(df_columns[["商品名", "売上", "地域"]])

変更前: ["'商品名'", "' 売上'", "'地域 '"]
変更後: ["'商品名'", "'売上'", "'地域'"]

	商品名	売上	地域
0	商品A	1200	東京
1	商品B	1100	大阪

df.columns.str.strip()は列名の前後空白を取る処理です。売上金額を売上へ変えるように、列名そのものを別名へ変更したい場合はrename()の記事を参照してください。

strip・replace・renameは目的で使い分ける

空白や表記ゆれを直す方法は似て見えますが、処理する場所と目的が違います。

目的	使う方法	主な対象	例
値の前後空白を削除	s.str.strip()	1列の各文字列	␠東京␠ → 東京
値の左端だけ削除	s.str.lstrip()	1列の各文字列	␠東京␠ → 東京␠
値の右端だけ削除	s.str.rstrip()	1列の各文字列	␠東京␠ → ␠東京
文字列の一部を置換	s.str.replace()	各文字列の一部分	商品 A → 商品A
値全体を別の値へ置換	s.replace()	SeriesまたはDataFrameの値	東京都 → 東京
列名の前後空白を削除	df.columns.str.strip()	列名	␠売上 → 売上
列名を別名へ変更	df.rename()	列名・行ラベル	売上金額 → 売上

Pythonの単一文字列textならtext.strip()、pandasの列df["地域"]ならdf["地域"].str.strip()です。値全体の置換や辞書を使った表記統一はpandas replace()の記事で詳しく扱っています。

よくあるミスと注意点

1. 結果を代入せず、元の列も変わったと思う

str.strip()は、空白を削除した新しい結果を返します。元の列は自動では変わらないため、df["地域"] = ...のように対象列へ戻します。

2. 文字列の途中にある空白まで消えると思う

strip()が対象にするのは両端です。商品 Aの中央の空白を変えたい場合はstr.replace()などを検討します。ただし、氏名や住所など、途中の空白に意味があるデータもあるため、一律に消してよいか確認が必要です。

3. NaNと空文字列を同じものとして扱う

NaNは欠損値、""は長さ0の文字列、" "は空白だけの文字列です。空白だけの文字列はstrip()後に""になりますが、自動でNaNにはなりません。

4. 混在列を安易にastype(str)へ変換する

数値や欠損値が混ざる列をastype(str)にすると、欠損値まで文字列の"nan"になる場合があります。まずdtypesで型を確認し、必要な列だけ処理しましょう。型変換はastype()の記事で詳しく解説しています。

5. 全角スペースを見落とす

日本語データには全角スペースが混ざることがあります。引数なしのstr.strip()では一般的な全角スペースも両端から除去できますが、repr()、unique()、value_counts()で処理前後を確認する習慣が大切です。

前処理の流れでstr.strip()を使うタイミング

実際の分析では、次の順番にすると空白による見落としを減らせます。

1. CSVやExcelを読み込む
2. head()・dtypes・unique()・value_counts()で列と値を確認する
3. 文字列値はSeries.str.strip()、列名はdf.columns.str.strip()で前後空白を除去する
4. unique()やvalue_counts()を再実行し、カテゴリが正しく統合されたか確認する
5. 必要ならreplace()で他の表記ゆれを統一する
6. 条件抽出、groupby()、merge()、可視化へ進む

空白除去後の部分一致抽出はstr.contains()の記事、集計はgroupby×aggの記事、DataFrameの結合はmergeの記事へ進むと、分析の流れをつなげて学べます。

複数の文字列列をまとめて処理する方法や、正規表現による連続空白の統一、Unicode正規化、大規模データでの速度最適化もあります。ただし、最初は問題のある列を特定し、1列ずつ安全に確認する方法で十分です。

まとめ

• pandasで文字列の前後空白を削除する基本はSeries.str.strip()
• 左側だけならstr.lstrip()、右側だけならstr.rstrip()
• 列名の前後空白はdf.columns.str.strip()で削除する
• strip()は文字列途中の空白を削除しない
• NaN、空文字列、空白だけの文字列は別の値として考える
• 処理結果を代入し、unique()やvalue_counts()で修正後を確認する
• 空白除去は、データ読込・確認のあと、抽出・集計・結合の前に行う

まずは、見た目が同じ値が別々に集計されていないかを確認してみましょう。前後空白が原因なら、対象の文字列列にstr.strip()を使うことで、その後の抽出や集計を正しく進めやすくなります。

次に読みたい関連記事

• pandas unique()とnunique()の使い方：値の一覧と表記ゆれを確認する
• pandas value_counts()の使い方：修正前後の件数を比較する
• pandas replace()の使い方：値全体の置換や表記統一を行う
• pandas rename()の使い方：列名を別名へ変更する
• pandas str.contains()の使い方：文字列を含む行を抽出する
• Google ColabでCSVを読み込む方法：CSVを読み込んで確認する
• pandas read_excel()の使い方：Excelファイルを読み込む
• pandas astype()の使い方：object型・string型などの型変換を確認する
• Pandas groupby×aggの使い方：整えたデータをグループ別に集計する

カテゴリから探す

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

▲ ページトップへ戻る

str.strip()は半角スペースと全角スペースの両方を削除できますか？

引数を省略したstr.strip()は、文字列の前後にある一般的な半角スペース・全角スペース・タブ・改行などを削除します。ただし、画面では見えない特殊な文字が残る場合もあるため、repr()やunique()で結果を確認してください。

str.strip()とstr.replace()はどう使い分けますか？

前後の空白を取り除くならstr.strip()、文字列の途中を含む特定文字を置換するならstr.replace()です。値全体を別の値へ置換するSeries.replace()・DataFrame.replace()とも目的が異なります。

文字列の途中にある空白も削除できますか？

str.strip()では削除できません。途中の空白にはstr.replace()などを使えますが、氏名や住所の空白まで消してよいかを先に確認しましょう。

列名の前後空白をまとめて削除できますか？

はい。df.columns = df.columns.str.strip()で列名の前後空白をまとめて削除できます。列名を別の名前へ変更する場合はrename()を使います。

str.strip()を使ったのに元のDataFrameが変わらないのはなぜですか？

str.strip()は処理後の新しいSeriesを返すためです。df["地域"] = df["地域"].str.strip()のように対象列へ代入してください。

空白を削除したら別々だったカテゴリは同じ値として集計されますか？

はい。東京、東京、東京がすべて東京になれば、value_counts()やgroupby()では同じカテゴリとして集計されます。削除後に件数が意図どおりか必ず確認してください。

<p>The post pandas str.strip()の使い方｜文字列・列名の前後空白を削除する方法 first appeared on Python Data Lab（Pythonデータラボ）.</p>

]]> https://pythondatalab.com/pandas-str-strip/feed/ 0 https://pythondatalab.com/pandas-corr/ https://pythondatalab.com/pandas-corr/#respond Sun, 09 Aug 2026 09:11:45 +0000 https://pythondatalab.com/?p=2107 pandasのcorr()を使って相関係数・相関行列を求める方法を初心者向けに解説。正負の相関の読み方、Pearson・Spearman・Kendallの違い、欠損値やNaNへの対処、ヒートマップ・散布図で確認する流れまでコード例付きで紹介します。

<p>The post pandas corr()の使い方｜相関係数・相関行列を初心者向けに解説 first appeared on Python Data Lab（Pythonデータラボ）.</p>

]]>

describe()で平均値や標準偏差を確認したあとに、「売上と広告費には関係があるの？」「どの列とどの列が一緒に動いているの？」と気になることはありませんか？

そんなときに使えるのが、Pandasのcorr()です。corr()を使うと、複数の数値列の関係を相関係数としてまとめた「相関行列」を作れます。

ただし、df.corr()を実行して表を出すだけでは十分ではありません。大切なのは、相関係数の符号と大きさを読み、気になる組み合わせを散布図でも確認することです。

この記事では、Google Colabでそのまま試せる小さなDataFrameを使って、corr()の基本から相関行列の読み方、散布図との使い分けまで順番に解説します。

この記事でわかること

• corr()を何のために使うのか
• 相関係数の「1・0・-1」の意味
• DataFrameから相関行列を作り、どこを見ればよいか
• Pearson・Spearman・Kendallの基本的な違い
• corr()とdescribe()・散布図の使い分け
• 文字列型や欠損値があるときの注意点
• 相関係数だけで判断せず、散布図へ進む分析の流れ

この記事のゴールは、corr()で相関行列を作って正しく読み、気になる関係を散布図で確かめられるようになることです。

まず結論：corr()は「列と列の関係」をまとめて確認するときに使う

データを確認するときは、知りたいことによって使う方法を変えると迷いにくくなります。

知りたいこと	主に使う方法	見えるもの
1列の値を要約したい	describe()	平均・標準偏差・四分位数など
複数の数値列の関係を一覧で見たい	corr()	相関係数・相関行列
2列の関係を目で確かめたい	散布図（scatter）	点の散らばり・外れ値・曲線的な関係

つまり、corr()は1列ずつを見るdescribe()と、2列を図で見る散布図の間をつなぐ役割があります。

基本統計量の確認方法を先に知りたい方は、pandas describe()の使い方も参考にしてください。DataFrameそのものがまだ不慣れな場合は、Pandas DataFrame入門から確認すると流れをつかみやすくなります。

相関係数とは？-1〜1の値をどう読むか

相関係数は、2つの数値がどの程度一緒に動くかを**-1から1の範囲**で表した値です。

相関係数の状態	読み方	イメージ
1に近い	正の相関が強い	一方が大きいほど、もう一方も大きい傾向
0付近	直線的な相関が弱い	一方が変わっても、もう一方の増減がはっきりしない
-1に近い	負の相関が強い	一方が大きいほど、もう一方は小さい傾向
1または-1	完全な正・負の相関	点が完全に一直線に並ぶ関係

ここで重要なのは、符号は関係の向き、絶対値は直線的な関係の強さを見る手がかりだということです。たとえば-0.9は「マイナスだから弱い」のではなく、強い負の相関を示します。

また、「0.7以上なら必ず強い」のように数値だけで機械的に判断するのはおすすめできません。何を強いとみなすかは、データの種類や分析目的によって変わります。まずは相関係数で候補を見つけ、元データや散布図も確認するのが基本です。

相関を確認するサンプルDataFrameを作る

ここからは、ある店舗の12期間分のデータを例にします。広告費、売上、気温、返品件数という4つの数値列を用意します。

今回は相関の違いを確認しやすいように、関係がはっきり表れる練習用データを使用します。

この例で知りたいのは、どの列同士が一緒に増減しているのかです。まずは元データを確認しましょう。

import pandas as pd

df = pd.DataFrame({
    "広告費": [10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65],
    "売上": [82, 95, 103, 119, 128, 142, 151, 165, 172, 188, 197, 211],
    "気温": [18, 25, 12, 28, 16, 22, 30, 14, 26, 19, 24, 20],
    "返品件数": [42, 39, 37, 35, 32, 31, 28, 26, 24, 21, 19, 17]
})

df

	広告費	売上	気温	返品件数
0	10	82	18	42
1	15	95	25	39
2	20	103	12	37
3	25	119	28	35
4	30	128	16	32
5	35	142	22	31
6	40	151	30	28
7	45	165	14	26
8	50	172	26	24
9	55	188	19	21
10	60	197	24	19
11	65	211	20	17

元のDataFrameは、1行が1期間の観測データです。この12行から、列同士の関係をまとめた表へ変換するのが次のcorr()です。

pandas corr()の基本的な使い方

DataFrameの相関係数をまとめて求める基本形は、次の1行です。

corr_matrix = df.corr()
corr_matrix.round(3)

	広告費	売上	気温	返品件数
広告費	1.000	0.999	0.121	-0.999
売上	0.999	1.000	0.122	-0.998
気温	0.121	0.122	1.000	-0.114
返品件数	-0.999	-0.998	-0.114	1.000

実行すると、元の12行×4列のデータから、次のような4列×4列の相関行列が得られます。小数第3位に丸めると、おおよそ次の値です。

	広告費	売上	気温	返品件数
広告費	1.000	0.999	0.121	-0.999
売上	0.999	1.000	0.122	-0.998
気温	0.121	0.122	1.000	-0.114
返品件数	-0.999	-0.998	-0.114	1.000

これが「処理前→処理後」の大きな変化です。corr()は各行を個別に表示するのではなく、列と列の組み合わせごとに1つの相関係数を計算します。

相関行列は「対角線以外」を見る

相関行列を初めて見ると、1.000がたくさん並んでいて戸惑うかもしれません。見るポイントは2つです。

1. 対角線はすべて1になる
   • 広告費と広告費のように、同じ列を自分自身と比較しているためです。
2. 上下には同じ組み合わせが重複する
   • 広告費×売上と売上×広告費は同じ関係なので、同じ値になります。

そのため、初心者のうちは対角線ではなく、異なる列同士の値を見ると考えれば十分です。

特定の列との相関だけを確認する

相関行列全体ではなく、たとえば「売上とほかの列の関係だけを見たい」という場合は、列名を指定します。

# 「売上」とほかの列との相関だけを確認
corr_matrix["売上"].drop("売上")

	売上
広告費	0.999175
気温	0.122452
返品件数	-0.998055

corr_matrix["売上"]で売上の列だけを取り出し、drop("売上")で売上自身との相関係数1.0を除いています。特定の指標と関係が強い列を探したいときに便利です。

ヒートマップで相関行列を視覚的に捉える

列数が多いDataFrameでは、相関行列をヒートマップにすると、相関の強さと向きを色で見分けやすくなります。ここでは、先ほど作ったcorr_matrixをそのまま可視化します。

seabornライブラリのheatmap関数を使うと、簡単にヒートマップを作成できます。

!pip install japanize_matplotlib
import seaborn as sns
import matplotlib.pyplot as plt
import japanize_matplotlib # 日本語フォントを有効にする

plt.figure(figsize=(8, 6))
sns.heatmap(corr_matrix, annot=True, cmap='coolwarm', fmt='.3f', linewidths=.5)
plt.title('相関行列のヒートマップ')
plt.show()

このcoolwarm配色では、赤系が正の相関、青系が負の相関、白に近い色が0付近を示します。まず色で気になる組み合わせを見つけ、annot=Trueで表示した数値を確認しましょう。

正の相関・負の相関・弱い相関を同じデータで読む

先ほどの相関行列から、特徴の異なる3つの組み合わせを見てみましょう。

print("広告費と売上      :", round(corr_matrix.loc["広告費", "売上"], 3))
print("広告費と返品件数  :", round(corr_matrix.loc["広告費", "返品件数"], 3))
print("売上と気温        :", round(corr_matrix.loc["売上", "気温"], 3))

広告費と売上      : 0.999
広告費と返品件数  : -0.999
売上と気温        : 0.122

このサンプルでは、次のように読めます。

• 広告費と売上：0.999 → 強い正の相関がある
• 広告費と返品件数：-0.999 → 強い負の相関がある
• 売上と気温：0.122 → 少なくとも強い直線的な相関は見られない

ここで、0.122だから「売上と気温には絶対に何の関係もない」とは断定できません。corr()が捉える関係、とくに標準のPearson相関は直線的な関係が中心です。曲線的な関係や外れ値の影響は、相関係数だけでは見落とすことがあります。

このため、corr()は結論を自動的に出す道具ではなく、詳しく見る組み合わせを探す道具として使うと理解しやすいです。

Pearson・Spearman・Kendallはどう使い分ける？

DataFrame.corr()は、標準ではPearson（ピアソン）の相関係数を計算します。初心者が連続した数値データの直線的な関係を見るなら、まずPearsonから始めればよいでしょう。

method	ざっくりした考え方	初心者が使う場面
pearson	数値の直線的な関係を見る	まず基本として使う
spearman	値の順位にもとづいて単調な関係を見る	順位関係を重視したいとき
kendall	順位の一致・不一致にもとづいて見る	順位データなどで候補になる

指定するときはmethod引数を使います。違いが見えやすいよう、ここだけ小さな比較用データを使います。xが増えるにつれてyも必ず増えますが、最後の値だけ大きく離れています。

method_df = pd.DataFrame({
    "x": [1, 2, 3, 4, 5, 6, 7, 8],
    "y": [1, 2, 3, 4, 5, 6, 7, 100]
})

print("Pearson :", round(method_df.corr(method="pearson").loc["x", "y"], 3))
print("Spearman:", round(method_df.corr(method="spearman").loc["x", "y"], 3))
print("Kendall :", round(method_df.corr(method="kendall").loc["x", "y"], 3))

Pearson : 0.624
Spearman: 1.0
Kendall : 1.0

この例では順位そのものは完全に同じ方向へ動いているため、SpearmanやKendallでは強い関係として表れます。一方、Pearsonは数値の直線的な関係を見るため、最後の大きな値の影響を受けます。

ここでは**「methodによって見ている関係が違う」**と分かれば十分です。Spearman・Kendallの統計理論や数式には深入りしません。通常の数値データで迷ったら、まずPearsonで確認し、分析目的に応じて別の方法を検討しましょう。

corr()でつまずきやすい3つのポイント

corr()は短いコードで使えますが、実際のCSVやExcelから読み込んだデータでは、データ型や欠損値に注意が必要です。

1. 数字に見えても文字列型になっていることがある

たとえばCSVから読み込んだ広告費が文字列になっていると、そのまま数値列として分析できないことがあります。まずdtypesで型を確認する習慣をつけましょう。

df_text = df.copy()
df_text["広告費"] = df_text["広告費"].astype(str)

df_text.dtypes

	0
広告費	object
売上	int64
気温	int64
返品件数	int64

型が混在するDataFrameでは、初心者には数値列を明示してからcorr()を使う方法が分かりやすく、安全です。

numeric_df = df_text.select_dtypes(include="number")
numeric_df.corr().round(3)

	売上	気温	返品件数
売上	1.000	0.122	-0.998
気温	0.122	1.000	-0.114
返品件数	-0.998	-0.114	1.000

DataFrame.corr()にはnumeric_onlyという引数もあります。数値列だけを対象にする書き方としてdf.corr(numeric_only=True)もありますが、なぜ列が対象外になったのかを理解するためにも、先にdtypesで型を確認するのがおすすめです。

数値列だけを選ぶ方法はpandas select_dtypes()の使い方、文字列になった数字を数値型へ直す方法はpandas to_numeric()の使い方で詳しく解説しています。

2. 欠損値があっても「0」として計算されるわけではない

実データには欠損値が含まれることがあります。corr()では、対象となる2列について利用できる観測値を使って相関を計算します。欠損値を勝手に0へ置き換えて計算するわけではありません。

たとえば一部の売上を欠損値にして確認します。

df_missing = df.copy()
df_missing.loc[[2, 7], "売上"] = pd.NA

print(df_missing[["広告費", "売上"]].isna().sum())
df_missing[["広告費", "売上"]].corr().round(3)

広告費    0
売上     2
dtype: int64

	広告費	売上
広告費	1.000	0.999
売上	0.999	1.000

相関係数の計算に必要な最小データ数を決めたい場合は、min_periodsを指定できます。次の例では、広告費と売上の有効な組み合わせが10件しかないのに11件以上を必要とするため、この2列間の相関係数はNaNになります。

# 計算に必要な有効データ数を11件以上に指定
df_missing[["広告費", "売上"]].corr(min_periods=11)

	広告費	売上
広告費	1.0	NaN
売上	NaN	NaN

min_periodsは、少ないデータだけで相関係数が計算されるのを避けたい場合に便利です。PandasではPearson相関とSpearman相関で利用できます。

欠損が多いほど、組み合わせによって計算に使えるデータ数が変わる可能性があります。相関係数を見る前に「何件のデータが残っているのか」を意識しましょう。欠損値の場所や件数の確認は、Pandas isnull()で欠損値を確認する記事につなげて学べます。

なお、isnull()記事で扱っているmissingnoの「欠損パターン同士の相関」と、ここで扱う売上・広告費など通常の数値変数同士の相関は目的が異なります。

3. NaNが出たら「計算できる変化があるか」を確認する

相関係数がNaNになる代表例の1つが、すべて同じ値の列です。値が変化しない列では、通常の相関係数を計算できません。

df_constant = df[["広告費", "売上"]].copy()
df_constant["固定値"] = 1

df_constant.corr().round(3)

	広告費	売上	固定値
広告費	1.000	0.999	NaN
売上	0.999	1.000	NaN
固定値	NaN	NaN	NaN

corr()でNaNを見つけたら、エラーだと決めつけず、列の値がすべて同じではないか、欠損値が多すぎないか、計算に使えるデータが十分あるかを確認してください。

corr()だけで判断せず、散布図で形を確認する

相関係数は複数列を一覧で比較するのに便利ですが、点がどのように散らばっているかまでは分かりません。

たとえば広告費と売上は相関係数が約0.999でした。この関係を散布図でも確認してみましょう。

import matplotlib.pyplot as plt

plt.scatter(df["広告費"], df["売上"])
plt.xlabel("Ad cost")
plt.ylabel("Sales")
plt.title("Ad cost vs Sales")
plt.grid(alpha=0.3)
plt.show()

点が右上がりに並んでいれば、「広告費が大きい期間ほど売上も大きい」という傾向を目でも確認できます。

散布図には、相関係数だけでは気づきにくい次の情報があります。

• 外れた点がないか
• 点が直線ではなく曲線のように並んでいないか
• 一部の点だけが相関係数を大きく動かしていないか

したがって、corr()で候補を探す → 散布図で実際の形を見るという順番が実践的です。散布図の色・サイズ・凡例などは、Matplotlib scatter入門で詳しく解説しています。この記事ではcorr()の結果を確かめるための最小限の描画にとどめます。

データ分析では「確認→相関→可視化」の流れで使う

実際の分析では、いきなりcorr()だけを実行するより、次の順番で進めると迷いにくくなります。

1. head()やdtypesでDataFrameの中身と型を確認する
2. describe()で各数値列の分布をざっくり確認する
3. 必要なら文字列の数字や欠損値を整える
4. corr()で列同士の相関を一覧する
5. 気になる組み合わせを散布図で確認する

つまり、corr()は前処理そのものではなく、整えたDataFrameを探索し、次に詳しく見るべき関係を見つける段階に位置づきます。

この流れを意識すると、df.corr()で表を出して終わるのではなく、分析の次の一手を決められるようになります。

注意：相関が高くても因果関係があるとは限らない

相関係数を読むときに、最も大切な注意点の1つです。

たとえば、このサンプルでは広告費と売上に強い正の相関があります。しかし、この結果だけから**「広告費を増やしたことが売上増加の原因である」**とは断定できません。季節、キャンペーン、来店客数など、別の要因が両方に影響している可能性もあります。

corr()が示すのは、あくまでデータ上の関係です。相関関係と因果関係は別物として扱いましょう。

まとめ：corr()で関係を見つけ、散布図で確かめよう

この記事では、Pandasのcorr()を使って相関係数・相関行列を確認する方法を解説しました。

• corr()は列と列の関係を数値でまとめて確認するメソッド
• 相関係数は-1〜1で、符号は向き、絶対値は直線的な関係の強さを見る手がかり
• 相関行列では、同じ列同士の対角線より異なる列同士を見る
• 標準のPearsonを基本にし、必要に応じてSpearman・Kendallを検討する
• 文字列型や欠損値がある場合は、計算前にデータを確認する
• 相関係数だけでは点の散らばりや外れ値が見えないため、散布図も組み合わせる
• 強い相関があっても、因果関係があるとは限らない

初心者のうちは、describe()で各列を確認 → corr()で列同士の関係を探す → scatterで形を確認という流れを覚えておくと、データ分析を一段進めやすくなります。

関連記事

• Pandas DataFrame入門｜作り方・基本操作をわかりやすく解説
• pandas describe()の使い方｜統計量の意味・include=’all’・info()との違いを解説
• pandas select_dtypes()の使い方｜データ型で列を選ぶ方法を初心者向けに解説
• pandas to_numeric()の使い方｜文字列の数字を数値に変換する方法
• Matplotlib scatter入門：色とサイズで散布図を可視化する方法
• 欠損値を可視化して攻略！Pandas isnullとヒートマップ活用術

カテゴリから探す

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

▲ ページトップへ戻る

pandas corr()とは何ですか？

corr()は、DataFrameやSeriesの数値データについて相関係数を計算するためのメソッドです。DataFrameに使うと、複数の列同士の相関係数をまとめた相関行列を作れます。

相関係数が1、-1、0に近い場合はどういう意味ですか？

1に近いほど強い正の相関、-1に近いほど強い負の相関を示します。0付近なら、少なくとも強い直線的な相関は見られません。ただし、0に近いからといって「あらゆる関係がない」とは断定できません。

corr()で文字列列がある場合はどうすればよいですか？

まずdtypesで型を確認してください。数値に見える文字列は必要に応じてto_numeric()で数値型へ変換します。分析対象を数値列に限定したい場合は、select_dtypes(include="number")で選択してからcorr()を使う方法が分かりやすいです。numeric_only=Trueを指定する方法もあります。

corr()でNaNが出るのはなぜですか？

すべて同じ値の列など、相関係数を計算できない場合はNaNになることがあります。欠損値が多く、2列の組み合わせで利用できるデータが十分にないケースにも注意してください。

PearsonとSpearmanはどう使い分けますか？

通常の数値について直線的な関係を見るなら、まず標準のPearsonが基本です。値そのものより順位関係・単調な関係を重視したい場合にはSpearmanが候補になります。Kendallも順位にもとづく方法ですが、この記事では統計理論の詳細には深入りしません。

DataFrame.corr()とSeries.corr()の違いは何ですか？

DataFrame.corr()は複数列の組み合わせをまとめて相関行列にします。2つのSeriesだけの相関係数が欲しい場合は、たとえばdf["広告費"].corr(df["売上"])のようにSeries.corr()を使えます。複数列を探索するならDataFrame、特定の2列だけならSeriesと考えると分かりやすいです。

corr()と散布図はどちらを使えばよいですか？

どちらか一方ではなく、組み合わせるのがおすすめです。まずcorr()で複数列から気になる組み合わせを見つけ、次に散布図で点の散らばり・外れ値・曲線的な関係を確認します。

相関係数が高ければ因果関係があると言えますか？

言えません。強い相関があっても、別の要因が両方に影響している可能性があります。corr()の結果だけから原因と結果を決めないようにしましょう。

pandasの相関行列はヒートマップにしたほうがよいですか？

列数が少なければ、まずcorr()の表を読めれば十分です。列数が多い場合はヒートマップで色分けすると全体を見やすくできますが、高度な装飾はこの記事の範囲外です。なお、通常の数値列の相関ヒートマップと、missingnoで見る欠損パターンの相関ヒートマップは目的が異なります。

<p>The post pandas corr()の使い方｜相関係数・相関行列を初心者向けに解説 first appeared on Python Data Lab（Pythonデータラボ）.</p>

]]> https://pythondatalab.com/pandas-corr/feed/ 0 https://pythondatalab.com/pandas-resample/ https://pythondatalab.com/pandas-resample/#respond Sun, 31 May 2026 13:12:33 +0000 https://pythondatalab.com/?p=2082 pandasのresample()で日付データを月別・週別・日別に集計する方法を初心者向けに解説。to_datetime()で日付型に変換し、set_index()やon引数を使って売上合計・件数・平均を集計する流れ、groupby()やasfreq()との違いも紹介します。

<p>The post pandas resample()の使い方｜日付データを月別・週別に集計する方法 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() は、日付データを一定の時間単位でまとめるために使います。

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

注文日	カテゴリ	売上
2026-01-05	食品	1200
2026-01-12	日用品	600
2026-02-03	日用品	2600
2026-03-15	食品	1800

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

年月	売上合計
2026-01	4000
2026-02	10980
2026-03	5100

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

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

やりたいこと	使うもの	例
日付を月別・週別・日別にまとめたい	resample()	月別売上、週別件数
カテゴリや店舗ごとにまとめたい	groupby()	カテゴリ別売上、店舗別平均
日付から年・月・曜日を取り出したい	dt	年列、月列、曜日列を追加
文字列の日付を日付型に変換したい	to_datetime()	"2026-01-05" をdatetime型にする

この記事では、このうち 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)

	注文日	カテゴリ	商品	売上	数量
0	2026-03-15	食品	コーヒー	1800	3
1	2026-01-05	食品	パン	1200	2
2	2026-02-03	日用品	洗剤	2600	1
3	2026-01-18	食品	お茶	1500	3
4	2026-03-28	日用品	ティッシュ	900	2
5	2026-02-25	食品	お米	4200	1
6	2026-01-28	日用品	歯ブラシ	700	2
7	2026-02-12	日用品	シャンプー	3200	1
8	2026-03-02	食品	牛乳	1100	2
9	2026-01-12	日用品	ノート	600	3
10	2026-02-05	食品	卵	980	2
11	2026-03-05	食品	ヨーグルト	1300	2

注文日     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)

	注文日	カテゴリ	商品	売上	数量
1	2026-01-05	食品	パン	1200	2
9	2026-01-12	日用品	ノート	600	3
3	2026-01-18	食品	お茶	1500	3
6	2026-01-28	日用品	歯ブラシ	700	2
2	2026-02-03	日用品	洗剤	2600	1
10	2026-02-05	食品	卵	980	2
7	2026-02-12	日用品	シャンプー	3200	1
5	2026-02-25	食品	お米	4200	1
8	2026-03-02	食品	牛乳	1100	2
11	2026-03-05	食品	ヨーグルト	1300	2
0	2026-03-15	食品	コーヒー	1800	3
4	2026-03-28	日用品	ティッシュ	900	2

注文日     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))

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

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

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

状態	注文日の位置	resample()での扱いやすさ
処理前	通常の列	そのままでは基本形のresample()に使いにくい
処理後	DatetimeIndex	df.resample("MS") のように集計できる

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)

	月別売上合計
2026-01-01	4000
2026-02-01	10980
2026-03-01	5100

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

処理前	処理後
注文日ごとに1行ずつ並んだ明細データ	月ごとに売上を合計した集計表
売上の推移が見えにくい	2026年1月、2月、3月の売上合計を比較しやすい

このように、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のラベル日付	MSの売上合計	MEのラベル日付	MEの売上合計	Mのラベル日付	Mの売上合計
0	2026-01-01	4000	2026-01-31	4000	2026-01-31	4000
1	2026-02-01	10980	2026-02-28	10980	2026-02-28	10980
2	2026-03-01	5100	2026-03-31	5100	2026-03-31	5100

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

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

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

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

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

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

指定	意味	使う場面
"D"	日別	日ごとの平均・件数を見たい
"W"	週別	週ごとの注文件数や売上を見たい
"MS"	月別（月初基準）	月別集計を月初の日付で表示したい
"ME"	月別（月末基準）	月別集計を月末の日付で表示したい
"M"	月別（月末基準の古い書き方）	古い記事や古いコードで見かけることがある
"QE"	四半期	四半期ごとに軽くまとめたい
"YE"	年別	年ごとに軽くまとめたい

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

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

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

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

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

出したい値	使う集計
売上合計	sum()
注文件数	count()
平均売上	mean()
数量合計	sum()

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

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

display(monthly_summary)

	売上合計	注文件数	平均売上	数量合計
2026-01-01	4000	4	1000.0	10
2026-02-01	10980	4	2745.0	5
2026-03-01	5100	4	1275.0	9

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

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

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

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

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

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

display(weekly_count)

	週別注文件数
2026-01-11	1
2026-01-18	2
2026-01-25	0
2026-02-01	1
2026-02-08	2
2026-02-15	1
2026-02-22	0
2026-03-01	1
2026-03-08	2
2026-03-15	1
2026-03-22	0
2026-03-29	1

W は週別の集計です。

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

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

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

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

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

display(daily_mean.head(10))

	日別平均売上
2026-01-05	1200.0
2026-01-06	NaN
2026-01-07	NaN
2026-01-08	NaN
2026-01-09	NaN
2026-01-10	NaN
2026-01-11	NaN
2026-01-12	600.0
2026-01-13	NaN
2026-01-14	NaN

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

この例では、注文がない日の平均売上は 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)

	注文日	月別売上合計
0	2026-01-01	4000
1	2026-02-01	10980
2	2026-03-01	5100

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

書き方	特徴
set_index("注文日").resample("MS")	時系列データとして扱う流れがわかりやすい
resample("MS", on="注文日")	インデックスを変えずに日付列を指定できる

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

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

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

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

使うもの	役割	例
resample()	日付を日別・週別・月別などの時間単位で集計する	月別売上、週別件数
groupby()	カテゴリや作成した列ごとに集計する	カテゴリ別売上、店舗別平均
dt	日付から年・月・曜日などを取り出す	月列を作る、曜日列を作る

月別集計は、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)

	年月	月別売上合計
0	2026-01	4000
1	2026-02	10980
2	2026-03	5100

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

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

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

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

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

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

やりたいこと	使うもの	考え方
月別売上の合計を出したい	resample().sum()	期間ごとに集計する
週別の平均を出したい	resample().mean()	期間ごとに集計する
日付の間隔だけそろえたい	asfreq()	指定した頻度の行を作る
欠けている日付を表示したい	asfreq()	集計せず、日付の並びをそろえる
欠けた期間も含めて集計結果を確認したい	resample()	期間の箱を作って集計する

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	resample_D_sum
2026-01-05	1200.0	1200
2026-01-06	NaN	0
2026-01-07	NaN	0
2026-01-08	NaN	0
2026-01-09	NaN	0
2026-01-10	NaN	0
2026-01-11	NaN	0
2026-01-12	600.0	600
2026-01-13	NaN	0
2026-01-14	NaN	0

上の表を見ると、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)

	注文日	売上合計	注文件数	平均売上	数量合計	年月
0	2026-01-01	4000	4	1000.0	10	2026-01
1	2026-02-01	10980	4	2745.0	5	2026-02
2	2026-03-01	5100	4	1275.0	9	2026-03

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() は意味が違います。

見たいもの	使う集計
売上合計	sum()
平均売上	mean()
注文件数	count() または size()

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を初心者向けに解説

カテゴリから探す

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

▲ ページトップへ戻る

<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を読み込んだあと、DataFrameの中から 「一定の範囲に入る行だけ」 を取り出したいことがあります。

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

• 売上が1000円〜5000円の商品だけ見たい
• 2026年1月の注文だけ確認したい
• 年齢が20歳〜40歳の人だけ抽出したい

このような 数値や日付の範囲で行を絞り込む処理 に使えるのが、Pandasの between() です。

between() を使うと、たとえば「売上が1000円以上5000円以下の行」を、次のように短く書けます。

df[df["売上"].between(1000, 5000)]

つまり、between() は 1つの列を「下限〜上限」の範囲で抽出したいときに使う方法 です。

この記事では、between() を使って、数値や日付の範囲で行を抽出する方法を、サンプルデータで順番に確認します。あわせて、範囲の始まりと終わりを含めるかどうか、between() と同じ範囲抽出を、>=・<= や query() で書く方法も確認します。

また、範囲に関係する処理として cut() もあります。ただし、cut() は between() と同じ結果を出すための方法ではありません。between() は「範囲に入る行を抽出する」処理、cut() は「値を区間に分ける」処理です。この違いは、本文後半で具体例を使って確認します。

この記事でわかること

この記事では、次の内容を順番に確認します。

• between() とは何か、範囲抽出の基本
• 数値を範囲で抽出する方法
• 日付を範囲で抽出する方法
• inclusive で数値や日付の範囲の境界値を含める・含めない設定
• between() と >=・<=・query()・cut() の違い
• 範囲抽出後に集計・可視化へつなげる考え方

やりたいこと別：between()を使う場面

between() は、1つの列を「下限〜上限」の範囲で絞りたいときに使います。

between() は、連続した範囲で行を絞り込むときに向いています。

候補リストから選ぶ場合や、文字列を含む行を探す場合は、後半の「between()を使わない場面」で軽く整理します。

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

ここでは、ECサイトの注文データを例にします。

売上 と 注文日 を使って、数値と日付の範囲抽出を確認していきます。

import pandas as pd

data = {
    "注文日": ["2026-01-03", "2026-01-08", "2026-01-15", "2026-01-28", "2026-02-04", "2026-02-12", "日付不明"],
    "商品": ["ノートPC", "マウス", "キーボード", "USBメモリ", "モニター", "Webカメラ", "ケーブル"],
    "カテゴリ": ["PC", "周辺機器", "周辺機器", "周辺機器", "PC", "周辺機器", "周辺機器"],
    "売上": [120000, 1000, 4800, 980, 5000, None, 3200]
}

df = pd.DataFrame(data)
df

この時点では、注文日 は文字列として入っています。日付の範囲抽出をするときは、あとで pd.to_datetime() を使って日付型に変換します。

数値を範囲で抽出する方法

ここからは、売上 列を使って between() の動きを確認します。

between() は、いきなり行を取り出すのではなく、まず各行が範囲内かどうかを判定します。

まずbetween()で範囲内かどうかを判定する

between() は、最初に各行の値が指定した範囲に入っているかどうかを、True / False で判定します。

たとえば、売上 が1000円以上5000円以下かどうかを判定してみます。

df["売上"].between(1000, 5000)

True は範囲内、False は範囲外という意味です。

この判定結果を使うと、次のステップで True の行だけを抽出できます。

判定結果を使って行を抽出する

範囲内かどうかを判定できたら、その条件を df[...] に入れます。

これで、売上 が1000円以上5000円以下の行だけを抽出できます。

売上範囲内 = df[df["売上"].between(1000, 5000)]
売上範囲内

このコードでは、売上 が1000円以上5000円以下の行だけが残ります。

ポイントは、1000円ちょうどの行も、5000円ちょうどの行も含まれることです。between() は、初期設定では両端の値を含みます。

between() は、売上だけでなく、年齢・点数・価格など、範囲で絞りたい数値列にも同じように使えます。

日付を範囲で抽出する方法

between() は、数値だけでなく日付にも使えます。

ただし、CSVから読み込んだ日付列は、文字列のままになっていることがあります。日付の範囲抽出をする前に、pd.to_datetime() で日付型に変換しておきます。

df["注文日"] = pd.to_datetime(df["注文日"], errors="coerce")
df

このセルを実行すると、df["注文日"] は日付型に変換されます。

そのため、以降の df では、日付として変換できなかった "日付不明" は NaT と表示されます。

errors="coerce" を指定すると、日付に変換できない値は NaT に変わります。

今回のデータでは、"日付不明" は日付として変換できません。errors="coerce" を指定しないとエラーになりますが、指定しておけば NaT に変換され、処理を続けられます。

次に、2026年1月1日から2026年1月31日までの注文だけを抽出します。

開始日 = pd.to_datetime("2026-01-01")
終了日 = pd.to_datetime("2026-01-31")

一月注文 = df[df["注文日"].between(開始日, 終了日)]
一月注文

このように、between() を使うと、指定期間内の日付データだけを取り出せます。

日付の範囲抽出では、次の流れを意識すると安全です。

1. pd.to_datetime() で日付型に変換する
2. 開始日と終了日を決める
3. between(開始日, 終了日) で抽出する

日付変換そのものを詳しく確認したい場合は、関連記事の to_datetime() を読むと理解しやすくなります。

抽出した結果は、必要な列だけ表示して確認すると見やすくなります。

一月注文[["注文日", "商品", "売上"]]

指定した日付範囲に入る行だけが残っていることを確認できます。

inclusiveで数値や日付の範囲の境界値を含める・含めない設定

between() は、境界値を含めるかどうかを inclusive で指定できます。

たとえば、1000円以上5000円以下なのか、1000円より大きく5000円未満なのかで、結果が変わります。

まずは、初期設定と同じ inclusive="both" を確認します。

df[df["売上"].between(1000, 5000, inclusive="both")]

1000円ちょうど、5000円ちょうどの行がどちらも含まれます。

次に、両端を含めない inclusive="neither" を見てみましょう。

df[df["売上"].between(1000, 5000, inclusive="neither")]

この場合は、1000円ちょうどと5000円ちょうどの行は含まれません。

初心者がつまずきやすいのは、境界値を含むと思っていたのに含まれていない、またはその逆です。抽出条件を書くときは、「以上・以下」なのか「より大きい・未満」なのかを先に決めておきましょう。

範囲抽出で欠損値があるときの注意点

ここまでで、数値と日付の範囲抽出を確認しました。

次に、抽出対象の列に欠損値がある場合の動きを確認します。

between() では、NaN や日付型の欠損値は範囲内として扱われません。

実際に、売上 が欠損している行がどう判定されるか確認してみましょう。

ここでは、欠損値がどのように判定されるかを見やすくするために、商品・売上・範囲内 だけを並べた確認用のDataFrameを作ります。

元の df を変更しているわけではなく、判定結果を確認するための表です。

pd.DataFrame({
    "商品": df["商品"],
    "売上": df["売上"],
    "範囲内": df["売上"].between(1000, 5000)
})

売上 が欠損している行は、範囲内 が False になります。

欠損値は、1000以上とも5000以下とも判断できないためです。欠損値をどう扱うかは、分析目的によって変わります。

between()と>=・<=・query()・cut()の違い

between() と似た処理は、比較演算子や query() でも書けます。また、範囲に関係するメソッドとして cut() もあります。

ここでは、混同しやすい違いだけを整理します。

同じ範囲条件を、between() と比較演算子で比べてみましょう。

# between()を使う書き方
df[df["売上"].between(1000, 5000)]

# 比較演算子を使う書き方
df[(df["売上"] >= 1000) & (df["売上"] <= 5000)]

1つの列を範囲で絞るだけなら、between() のほうが読みやすいことが多いです。

一方で、「売上が5000円以上」「カテゴリが周辺機器」「注文日が1月以降」のように複数条件を組み合わせる場合は、通常の条件式や query() も選択肢になります。

query()で書く場合

同じ条件を query() で書くと、次のようになります。

df.query("1000 <= 売上 <= 5000")

query() は便利ですが、列名や文字列条件の書き方に慣れが必要です。

この記事では、まず 1つの列を範囲で絞るなら between() と覚えるのがおすすめです。

cut()は抽出ではなく分類に使う

between() と cut() は、どちらも「範囲」に関係しますが、役割は違います。

between() は、範囲に合う行を残すための方法です。

df[df["売上"].between(1000, 5000)]

一方で、cut() は値を区間ごとのラベルに分けたいときに使います。ここでは違いを確認するために、軽く例だけ示します。

df["売上帯"] = pd.cut(
    df["売上"],
    bins=[0, 1000, 5000, 200000],
    labels=["低め", "中くらい", "高め"]
)

df[["商品", "売上", "売上帯"]]

cut() は行を取り出すというより、値をカテゴリに分ける処理です。

今回の記事の主役は、あくまで 範囲で行を抽出する between() です。区間分けを詳しく学びたい場合は、cut() の記事に進むとよいです。

between()を使わない場面も確認しておく

between() は、数値や日付を「下限〜上限」の範囲で絞るときに使います。

一方で、次のような条件では、between() ではなく別のメソッドを使う方が自然です。

たとえば、商品名が「マウス」または「キーボード」の行を取り出したい場合は isin()、商品名に「PC」を含む行を探したい場合は str.contains() が向いています。

この記事では between() を中心に扱うため、isin() と str.contains() は詳しく扱いません。必要に応じて関連記事で確認してください。

抽出したデータを集計して確認する

between() は、抽出して終わりではありません。抽出したデータを集計すると、条件に合うデータの傾向を確認しやすくなります。

データ分析では、必要な行だけを取り出したあとに、件数を数えたり、カテゴリ別に集計したり、グラフにしたりすることが多いです。

ここでは、売上が1000円以上5000円以下の商品だけに絞ったあと、カテゴリ別に件数を数えてみます。

売上範囲内 = df[df["売上"].between(1000, 5000)]

売上範囲内["カテゴリ"].value_counts()

value_counts() を使うと、抽出後のデータにどのカテゴリが多いかを確認できます。

次に、カテゴリ別の売上合計も確認してみます。

売上範囲内.groupby("カテゴリ")["売上"].sum()

この流れは、実務でもよく使います。

CSV読み込み → 型確認 → 必要な範囲で抽出 → 集計 → 可視化 という流れの中で、between() は「必要な行だけを取り出す」ための前処理として使えます。

必要に応じてグラフで確認する

集計結果は、必要に応じてグラフで確認できます。

本格的なグラフ調整はMatplotlibの記事で扱うため、ここでは「抽出後のデータを可視化につなげられる」ことだけ確認します。

!pip install japanize-matplotlib > /dev/null

import matplotlib.pyplot as plt
import japanize_matplotlib

集計結果 = 売上範囲内.groupby("カテゴリ")["売上"].sum()

集計結果.plot(kind="bar")
plt.title("カテゴリ別の売上合計")
plt.xlabel("カテゴリ")
plt.ylabel("売上")
plt.show()

between() で絞り込んだあとに集計・可視化すると、必要な範囲だけに注目してデータを見やすくなります。

たとえば、全体では高額商品の影響が大きすぎる場合でも、1000〜5000円の商品だけに絞ることで、中価格帯の商品傾向を確認しやすくなります。

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

between() はシンプルですが、初心者がつまずきやすいポイントがあります。

数値の範囲抽出では、必要に応じて先に数値型へ変換します。

数値の範囲抽出では、列が文字列になっている場合に pd.to_numeric() で数値型へ変換します。

日付の範囲抽出では、pd.to_datetime() で日付型へ変換してから between() を使います。

between() は、基本的に1つの列を下限〜上限で絞るときに使います。

複数列にまたがる複雑な条件を扱う場合は、通常の条件式や query() も候補にしましょう。

between()は前処理・抽出で使う

between() は、集計や可視化の前に、必要な行だけを取り出すための処理です。

たとえば、次のような流れで使います。

CSV読み込み → 型の確認 → 数値・日付の変換 → 範囲抽出 → 集計 → 可視化

つまり、between() は、すべてのデータを見る前に、分析したい範囲に絞り込むための前処理として使えます。

まとめ：between()は数値・日付の範囲抽出を読みやすくする方法

この記事では、Pandasの between() を使って、数値や日付の範囲で行を抽出する方法を解説しました。

ポイントを整理します。

• between() は、1つの列を下限〜上限で絞りたいときに使う
• 数値だけでなく、日付の範囲抽出にも使える
• 初期設定では、両端の境界値を含む
• 数値や日付の範囲の境界値を含めるかどうかは inclusive で指定できる
• NaN や NaT は範囲内として扱われない
• 文字列の数字は to_numeric()、日付文字列は to_datetime() で整えてから使う
• 候補リストなら isin()、文字列検索なら str.contains()、区間分けなら cut() を使う
• 抽出後は value_counts() や groupby()、Matplotlib可視化へつなげると分析に活かしやすい

まずは、「1つの列を下限〜上限で抽出したいときは between()」 と覚えておくと、条件式を読みやすく書けるようになります。

次に読みたい関連記事

範囲抽出の前後で使いやすい記事をまとめます。

• pandas 条件抽出（filtering）入門｜AND/OR・query関数・複数条件の指定方法
  条件抽出全体、AND/OR、query() を整理したいときにおすすめです。

• Pandas locとilocの違い｜行・列の抽出/スライス/条件指定を図解で解説
  行・列の指定方法や、条件指定との関係を整理したいときに役立ちます。

• pandas isinの使い方と仕組み｜リスト・複数条件・not isin・処理速度まで徹底解説
  候補リストに含まれる行を抽出したいときに参考になります。

• pandas str.contains()の使い方｜文字列を含む行を抽出・na=Falseも解説
  文字列を含む行を抽出したいときに使います。

• pandas to_numeric()の使い方｜文字列の数字を数値に変換する方法
  文字列の数字を数値に直してから範囲抽出したいときにおすすめです。

• pandas to_datetime()の使い方｜文字列の日付変換とformat・NaT対処を初心者向けに解説
  日付の範囲抽出をする前に、日付型への変換を確認したいときに役立ちます。

• pandas dtの使い方｜日付から年・月・曜日を取り出す方法を初心者向けに解説
  日付を抽出したあと、年・月・曜日を取り出して集計したいときにおすすめです。

• pandas cut()の使い方｜bins・labelsで数値を区間分けする方法を解説
  範囲で抽出するのではなく、価格帯や年代などに分類したいときに使います。

• Pandas groupby×aggの使い方｜基本の集計とaggの書き方を例で解説
  範囲抽出したデータをカテゴリ別・月別に集計したいときに役立ちます。

• pandas value_counts()の使い方｜件数集計・割合表示・欠損値の数え方を解説
  抽出後の件数を数えたいときにおすすめです。

• Matplotlib 棒グラフ入門：横棒・グループ化・積み上げまで解説
  集計結果を棒グラフで見やすくしたいときに参考になります。

▲ ページトップへ戻る

<p>The post pandas between()の使い方｜数値・日付を範囲で抽出する方法 first appeared on Python Data Lab（Pythonデータラボ）.</p>

CSVやExcelを読み込むと、DataFrameにはいろいろな種類の列が混ざっていることがあります。

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

• 商品名 や 地域 のような文字列の列
• 売上 や 数量 のような数値の列
• 注文日 のような日付の列
• キャンペーン対象 のような True / False の列

このようなデータでは、列の種類によって次に行う処理が変わります。

数値列は平均・合計・統計量の確認に使いやすく、文字列やカテゴリ列は件数集計に使いやすく、日付列は月別・曜日別の分析に使いやすいです。

つまり、データ型ごとに列を分けておくと、その後の確認・集計・分析に進みやすくなります。

そこで便利なのが、Pandasの select_dtypes() です。

select_dtypes() を使うと、列名ではなく データ型 を基準にして、数値列・文字列が入っている列・日付列などをまとめて選べます。

たとえば、数値列だけを選びたい場合は、次のように書きます。

df.select_dtypes(include="number")

この記事では、pandas select_dtypes の基本を、Google Colabでそのまま試せるサンプルデータを使って解説します。

この記事でわかること

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

• select_dtypes() でできること
• データ型ごとに列を分けるメリット
• dtypes や info() で型を確認してから列を選ぶ流れ
• 数値列だけを選ぶ方法
• 文字列が入っている列だけを選ぶ方法
• 日付列だけを選ぶ方法
• category 型や bool 型も選べること
• exclude で特定の型を除外する方法

この記事のゴールは、select_dtypes() を使って、DataFrameから数値列・文字列が入っている列・日付列をデータ型ごとに選び、その後の確認・集計・分析に進みやすくすることです。

まずdtypesで型を確認してからselect_dtypes()を使う

select_dtypes() は、Pandasの前処理で 型を確認したあと に使うと便利です。

いきなり select_dtypes() を使うのではなく、まず df.dtypes や df.info() で、各列がPandas上でどのデータ型として扱われているかを確認します。

df.dtypes は、列ごとのデータ型だけを簡単に確認したいときに使います。
一方、df.info() では、データ型に加えて、行数・欠損していない値の数・メモリ使用量などもまとめて確認できます。

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

1. CSVやExcelを読み込む
2. head() でデータの中身を確認する
3. df.dtypes や df.info() で列ごとのデータ型を確認する
4. 数字や日付に見える列が、Pandas上でどの型として扱われているか確認する
5. 必要に応じて to_numeric()、to_datetime()、astype() で型を整える
6. select_dtypes() で、数値列・文字列が入っている列・日付列などをまとめて選ぶ

この流れにすると、「見た目は数字でも、Pandas上では文字列として扱われている」「日付に見えても、まだ日付型ではない」といった状態に気づきやすくなります。

上で確認したように、select_dtypes() のメリットは、データ型ごとに列を分けられることです。

数値列、文字列が入っている列、日付列では、次に行う処理が異なります。
そのため、先に select_dtypes() で列を種類ごとに整理しておくと、確認・集計・分析へ進みやすくなります。

ただし、型が違う列を混ぜたまま、同じ方法で集計・可視化できるわけではありません。
数値列なら統計量の確認、文字列やカテゴリ列なら件数集計、日付列なら月別・曜日別の分析のように、列の種類に合った処理を選ぶことが大切です。

この流れで出てくる基本操作が不安な場合は、以下の記事も参考になります。dtypes や info() による型の確認方法は、info()・describe()の記事で解説しています。

• Pandas DataFrame入門｜作り方・基本操作をわかりやすく解説
• pandas head()の使い方｜先頭行を確認してデータの中身を把握する方法
• Pandas info()とdescribe()の違い｜欠損値・型・統計量の見方を例で解説
• pandas to_numeric()の使い方｜文字列の数字を数値に変換する方法
• pandas to_datetime()の使い方｜文字列の日付変換と format・NaT 対処を初心者向けに解説
• pandas astype()の使い方｜文字列・数値への型変換とエラー対処を初心者向けに解説

select_dtypes()とは？

select_dtypes() は、DataFrameの列を データ型（dtype）で選ぶ メソッドです。

dtype は、Pandasで使われる「データ型」を表す言葉です。この記事では、基本的には「データ型」として説明します。

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

df.select_dtypes(include=選びたい型)

または、特定の型を除外したい場合は次のように書きます。

df.select_dtypes(exclude=除外したい型)

まず、初心者が最初に覚えるなら、次の3つで十分です。

ポイントは、select_dtypes() は 型を変換するメソッドではない ということです。

見た目が数字や日付のように見えても、Pandas上のデータ型が違うと、期待した列として選ばれないことがあります。
そのため、select_dtypes() を使う前後では、df.dtypes やdf.info()でデータ型を確認することが大切です。

まずはサンプルデータを作る

今回は、ネットショップの注文データをイメージしたDataFrameを使います。

このデータには、数値・文字列・日付・真偽値が混ざっています。
実際のCSVやExcelデータでも、このようにいろいろな型の列が混ざっていることがよくあります。

import pandas as pd
raw_df = pd.DataFrame({
    "注文ID": [1001, 1002, 1003, 1004, 1005],
    "商品名": ["ノートPC", "マウス", "キーボード", "モニター", "USBメモリ"],
    "地域": ["東京", "大阪", "東京", "福岡", "大阪"],
    "売上": ["120000", "3000", "8000", "35000", "不明"],
    "数量": [1, 2, 1, 1, 3],
    "割引率": [0.10, 0.00, 0.05, 0.15, 0.00],
    "注文日": ["2026-05-01", "2026-05-02", "2026-05-03", "2026-05-04", "2026-05-05"],
    "キャンペーン対象": [True, False, True, True, False],
    "メモ": ["初回購入", "リピート", "法人", "初回購入", "リピート"]
})

raw_df

上のデータでは、売上 は数字のように見えます。
しかし、最後に "不明" という文字が入っているため、この時点では数値列として扱えない可能性があります。

まずは、dtypes で列ごとの型を確認してみましょう。

raw_df.dtypes

dtypes を見ると、列ごとのデータ型を確認できます。
同じように、info() でも各列のデータ型は Dtype として確認できます。

ここで大切なのは、見た目が数字かどうかではなく、Pandasがどの型として認識しているか です。

たとえば、売上 は数字に見えますが、"不明" が混ざっているため、数値ではなく object 型として扱われています。

では、この状態で数値列だけを選ぶとどうなるか確認してみましょう。

まずは変換前のデータで数値列だけを選んでみる

数値列だけを選びたい場合は、include="number" を指定します。

まずは、型を変換する前の raw_df で数値列だけを選んでみます。

raw_df.select_dtypes(include="number")

実行結果を見ると、注文ID、数量、割引率 は選ばれますが、売上 は含まれていません。

理由は、売上 がPandas上では数値型ではなく object 型として扱われているためです。
このように、数字に見える列でも、データ型が文字列系のままだと include="number" では選ばれません。

売上 を数値列として扱いたい場合は、先に to_numeric() で数値型に変換します。

売上を数値型に変換する

ここでは、売上 を数値列として扱えるようにします。

売上 には "不明" が混ざっているため、そのままでは数値型にできません。
そこで、pd.to_numeric() の errors="coerce" を使い、数値に変換できない値を NaN にします。

数値変換の詳しい使い方は、以下の記事で解説しています。

• pandas to_numeric()の使い方｜文字列の数字を数値に変換する方法

df = raw_df.copy()

df["売上"] = pd.to_numeric(df["売上"], errors="coerce")

df