coin_collector | Python Data Lab（Pythonデータラボ）

pandas drop()の使い方｜行・列を削除するindex・columns・axisを初心者向けに解説

coin_collector — Sat, 12 Sep 2026 09:31:39 +0000

pandasのDataFrameから「この行だけ消したい」「この列は分析に使わないので削除したい」というときは、drop()を使います。

ただし、初めて使うと「axis=0とaxis=1のどちら？」「削除したのに元のDataFrameが変わらない」「上から2行目を消したつもりが別の行が消えた」と迷いやすいメソッドでもあります。

この記事では、Google Colabでそのまま実行できるコードを使い、行・列の削除から複数指定、条件削除、エラー対策まで順番に確認します。

この記事でわかること

drop(index=...)で指定した行を削除する方法
drop(columns=...)で指定した列を削除する方法
行ラベルと「上から何行目」という位置の違い
複数行・複数列や、行と列を同時に削除する方法
drop()が反映されない原因とinplace=Trueの注意点
KeyErrorが出たときの確認方法
drop()・dropna()・drop_duplicates()の使い分け

DataFrameそのものから確認したい方は、先にDataFrameの作り方と基本操作をご覧ください。

先に結論：行はindex、列はcolumnsで削除する

初心者は、次の2つを基本形として覚えると迷いにくくなります。

削除したいもの	推奨コード	指定するもの
1行	`df.drop(index=行ラベル)`	DataFrameのindex
1列	`df.drop(columns="列名")`	DataFrameの列名
複数行	`df.drop(index=[行ラベル1, 行ラベル2])`	行ラベルのリスト
複数列	`df.drop(columns=["列名1", "列名2"])`	列名のリスト

axis=0とaxis=1でも指定できますが、index=・columns=のほうが、行と列のどちらを削除するのかコードから読み取りやすくなります。

pandas drop()とは

DataFrame.drop()は、指定した行ラベルまたは列ラベルを除いたDataFrameを返すメソッドです。

通常は元のDataFrameを直接変更しません。結果を残す場合は、df = df.drop(...)のように変数へ代入します。この点が「実行したのに削除が反映されない」と感じる主な原因です。

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

最初にpandasのバージョンを確認し、5件の売上データを作ります。この記事では、すべてこのDataFrameを使います。

import pandas as pd

print("pandas version:", pd.__version__)

df = pd.DataFrame(
    {
        "商品": ["ノートPC", "マウス", "キーボード", "モニター", "USBメモリ"],
        "地域": ["東京", "大阪", "東京", "名古屋", "大阪"],
        "売上": [1200, 800, 1500, 700, 1100],
        "利益": [240, 160, 300, 140, 220],
    },
    index=[100, 101, 102, 103, 104],
)

print(df)

実行結果

pandas version: 2.2.3
         商品   地域    売上   利益
100   ノートPC   東京  1200  240
101     マウス   大阪   800  160
102   キーボード   東京  1500  300
103    モニター  名古屋   700  140
104  USBメモリ   大阪  1100  220

左端の100〜104が行のindexラベルです。表の上から数えた位置とは別の情報として扱います。

drop()で行を削除する

indexラベルを指定して1行削除する

indexラベル101の行を削除します。目的は「マウスの行を削除する」ことです。

df_row_dropped = df.drop(index=101)
print(df_row_dropped)

実行結果

         商品   地域    売上   利益
100   ノートPC   東京  1200  240
102   キーボード   東京  1500  300
103    モニター  名古屋   700  140
104  USBメモリ   大阪  1100  220

indexラベル101の行だけがなくなりました。元のdfではなく、結果をdf_row_droppedへ代入しています。

複数行をリストでまとめて削除する

複数の行は、indexラベルをリストで渡します。

df_rows_dropped = df.drop(index=[101, 103])
print(df_rows_dropped)

実行結果

         商品  地域    売上   利益
100   ノートPC  東京  1200  240
102   キーボード  東京  1500  300
104  USBメモリ  大阪  1100  220

indexラベル101と103の2行が削除されました。

行ラベルと行番号の違い

drop(index=101)の101は「上から101行目」ではなく、indexラベル101です。

上から2行目を削除したい場合は、df.index[1]でその位置にあるラベルを取得します。Pythonは0から数えるため、[1]が上から2行目です。

second_row_label = df.index[1]
print("上から2行目のindexラベル:", second_row_label)

df_by_position = df.drop(index=second_row_label)
print(df_by_position)

実行結果

上から2行目のindexラベル: 101
         商品   地域    売上   利益
100   ノートPC   東京  1200  240
102   キーボード   東京  1500  300
103    モニター  名古屋   700  140
104  USBメモリ   大阪  1100  220

今回は上から2行目のラベルが101なので、マウスの行が削除されました。indexが並べ替えられていたり、文字列になっていたりしても、位置からラベルを取得すれば意図を明確にできます。

drop()で列を削除する

columnsで1列削除する

「利益」列を削除します。

df_column_dropped = df.drop(columns="利益")
print(df_column_dropped)

実行結果

         商品   地域    売上
100   ノートPC   東京  1200
101     マウス   大阪   800
102   キーボード   東京  1500
103    モニター  名古屋   700
104  USBメモリ   大阪  1100

「利益」列だけがなくなり、「商品」「地域」「売上」は残っています。

複数列をリストでまとめて削除する

df_columns_dropped = df.drop(columns=["地域", "利益"])
print(df_columns_dropped)

実行結果

         商品    売上
100   ノートPC  1200
101     マウス   800
102   キーボード  1500
103    モニター   700
104  USBメモリ  1100

「地域」と「利益」の2列が削除されました。

列番号で指定するときはdf.columnsを使う

上からではなく左から2列目を削除したい場合は、df.columns[1]で列名を取得します。

second_column_name = df.columns[1]
print("左から2列目の列名:", second_column_name)

df_by_column_position = df.drop(columns=second_column_name)
print(df_by_column_position)

実行結果

左から2列目の列名: 地域
         商品    売上   利益
100   ノートPC  1200  240
101     マウス   800  160
102   キーボード  1500  300
103    モニター   700  140
104  USBメモリ  1100  220

左から2列目は「地域」なので、その列が削除されました。列番号を直接columns=1へ渡すのではなく、df.columns[1]から実際の列名を取得する点が重要です。

行と列を同時に削除する

index=とcolumns=は同時に指定できます。ここでは2行と1列を一度に削除します。

df_both_dropped = df.drop(index=[101, 103], columns=["利益"])
print(df_both_dropped)

実行結果

         商品  地域    売上
100   ノートPC  東京  1200
102   キーボード  東京  1500
104  USBメモリ  大阪  1100

indexラベル101・103の行と、「利益」列が同時に削除されています。

axis=0とaxis=1の違い

labelsとaxisを組み合わせる書き方もあります。

axis	対象	`index`・`columns`で書く場合
`axis=0`または`axis="index"`	行	`index=...`
`axis=1`または`axis="columns"`	列	`columns=...`

次の2つは同じ結果になります。

result_with_axis = df.drop(labels="利益", axis=1)
result_with_columns = df.drop(columns="利益")

print("2つの結果は同じ:", result_with_axis.equals(result_with_columns))
print(result_with_axis)

実行結果

2つの結果は同じ: True
         商品   地域    売上
100   ノートPC   東京  1200
101     マウス   大阪   800
102   キーボード   東京  1500
103    モニター  名古屋   700
104  USBメモリ   大阪  1100

Trueと表示されれば、2つの結果は同じです。既存コードを読むためにaxisの意味は必要ですが、自分で書くときはindex=・columns=を使うと取り違えを減らせます。

条件に合う行を削除する

「売上が1000未満の行を削除する」場合は、最初に条件に合う行のindexを取得し、そのindexをdrop()へ渡します。

delete_index = df.index[df["売上"] < 1000]
print("削除対象のindex:", delete_index.tolist())

df_condition_dropped = df.drop(index=delete_index)
print(df_condition_dropped)

実行結果

削除対象のindex: [101, 103]
         商品  地域    売上   利益
100   ノートPC  東京  1200  240
102   キーボード  東京  1500  300
104  USBメモリ  大阪  1100  220

売上が1000未満のindexラベル101と103が削除されました。

同じ結果は「売上が1000以上の行だけ残す」と考えて、条件抽出でも作れます。

df_filtered = df[df["売上"] >= 1000]

print("drop()と条件抽出の結果は同じ:", df_condition_dropped.equals(df_filtered))
print(df_filtered)

実行結果

drop()と条件抽出の結果は同じ: True
         商品  地域    売上   利益
100   ノートPC  東京  1200  240
102   キーボード  東京  1500  300
104  USBメモリ  大阪  1100  220

結果は同じです。削除対象のindexが明確ならdrop()、残す条件をそのまま表現したいなら条件抽出が読みやすいことがあります。条件式を反転させると結果も逆になるため、処理前後の行数を必ず確認しましょう。

条件指定を詳しく確認したい方は、pandasでAND・OR・queryを使って条件抽出する方法も参考にしてください。

処理前後表で確認する

操作	処理前	指定	処理後
1行削除	5行×4列	`index=101`	4行×4列
1列削除	5行×4列	`columns="利益"`	5行×3列
2行・1列を同時削除	5行×4列	`index=[101, 103]`, `columns=["利益"]`	3行×3列
条件削除	5行×4列	売上1000未満	3行×4列

行数・列数はshapeでも検証できます。

print("処理前:", df.shape)
print("1行削除後:", df_row_dropped.shape)
print("1列削除後:", df_column_dropped.shape)
print("行・列の同時削除後:", df_both_dropped.shape)
print("条件削除後:", df_condition_dropped.shape)

実行結果

処理前: (5, 4)
1行削除後: (4, 4)
1列削除後: (5, 3)
行・列の同時削除後: (3, 3)
条件削除後: (3, 4)

drop()が反映されない原因

戻り値を変数へ代入する

通常のdrop()は、削除後の新しいDataFrameを返します。元のdfは変わりません。

temporary_result = df.drop(index=101)

print("削除結果の行数:", len(temporary_result))
print("元のdfの行数:", len(df))

実行結果

削除結果の行数: 4
元のdfの行数: 5

削除結果は4行ですが、元のdfは5行のままです。結果を反映するなら、次のように再代入します。

df = df.drop(index=101)

inplace=Trueの動作と注意点

inplace=Trueを指定すると対象のDataFrameを直接変更し、戻り値はNoneになります。元のサンプルを壊さないよう、コピーで確認します。

df_copy = df.copy()
return_value = df_copy.drop(index=101, inplace=True)

print("戻り値:", return_value)
print("変更後のdf_copy:")
print(df_copy)

実行結果

戻り値: None
変更後のdf_copy:
         商品   地域    売上   利益
100   ノートPC   東京  1200  240
102   キーボード   東京  1500  300
103    モニター  名古屋   700  140
104  USBメモリ   大阪  1100  220

return_valueはNoneですが、df_copyからはindexラベル101の行が削除されています。

次の書き方は、Noneをdfへ代入してしまうので避けてください。

df = df.drop(index=101, inplace=True)  # 誤り：dfがNoneになる

初心者は、処理の結果を追いやすいdf = df.drop(...)を基本にすると安全です。

KeyErrorが出る原因と対処法

存在しない行ラベルや列名を指定すると、既定ではKeyErrorになります。ここでは、存在しない「売上高」列を指定してエラーを確認します。

try:
    df.drop(columns="売上高")
except KeyError as error:
    print(type(error).__name__ + ":", error)

実行結果

KeyError: "['売上高'] not found in axis"

KeyErrorの確認表

確認項目	よくある原因	確認方法
列名	「売上」と「売上高」などの表記違い	`df.columns.tolist()`
行ラベル	位置番号とindexラベルの混同	`df.index.tolist()`
大文字・小文字	`Sales`と`sales`の違い	実際の列名を表示
前後の空白	`"売上 "`のような空白	`repr()`などで確認
行・列	`axis`の指定間違い	`index=`・`columns=`を使う

print("列名:", df.columns.tolist())
print("indexラベル:", df.index.tolist())

実行結果

列名: ['商品', '地域', '売上', '利益']
indexラベル: [100, 101, 102, 103, 104]

errors=”ignore”を使ってよい場面

errors="ignore"を指定すると、存在しないラベルを無視して、存在するラベルだけを削除できます。

df_ignored = df.drop(columns=["利益", "存在しない列"], errors="ignore")
print(df_ignored)

実行結果

         商品   地域    売上
100   ノートPC   東京  1200
101     マウス   大阪   800
102   キーボード   東京  1500
103    モニター  名古屋   700
104  USBメモリ   大阪  1100

「利益」は削除され、「存在しない列」は無視されました。ただし、タイプミスまで見逃すため、手入力したコードのエラー回避として常用しないでください。削除候補が外部データから渡され、存在するものだけ処理したい場合など、意図が明確な場面に限定します。

行削除後のindexを振り直す

行を削除してもindexは自動で連番に戻りません。必要な場合はreset_index(drop=True)を使います。

df_after_drop = df.drop(index=[101, 103])
df_after_reset = df_after_drop.reset_index(drop=True)

print("行削除後:")
print(df_after_drop)
print("\nindexを振り直した後:")
print(df_after_reset)

実行結果

行削除後: 商品地域売上利益 100 ノートPC 東京 1200 240 102 キーボード東京 1500 300 104 USBメモリ大阪 1100 220

indexを振り直した後: 商品地域売上利益 0 ノートPC 東京 1200 240 1 キーボード東京 1500 300 2 USBメモリ大阪 1100 220

drop=Trueを付けると、削除前のindexを新しい列として残さず、0からの連番にできます。詳しくはreset_index()でインデックスを振り直す方法をご覧ください。

drop()・dropna()・drop_duplicates()の違い

名前は似ていますが、削除する対象が異なります。

目的	使うメソッド	代表例
指定した行・列を削除	`drop()`	`df.drop(columns="利益")`
欠損値を含む行・列を削除	`dropna()`	`df.dropna()`
重複行を削除	`drop_duplicates()`	`df.drop_duplicates()`
条件に合う行だけ残す	ブール条件	`df[df["売上"] >= 1000]`

欠損値を削除したい場合：dropna()で欠損値を削除する方法
重複行を削除したい場合：drop_duplicates()で重複行を削除する方法
削除前に重複を確認したい場合：duplicated()で重複行を確認する方法

よくあるミス

ミス	起こること	対処
`df.drop(1)`を「上から2行目」と決めつける	indexラベル1を探す	位置なら`df.index[1]`を使う
列名を指定したのに行として扱われる	`KeyError`になる	`columns="列名"`を使う
戻り値を保存しない	元のdfが変わらない	再代入する
再代入と`inplace=True`を同時に使う	変数が`None`になる	どちらか一方にする
`errors="ignore"`を常用する	タイプミスを見逃す	原則は既定の`raise`で確認
行削除後に連番だと思い込む	indexが飛んだままになる	必要なら`reset_index(drop=True)`

実務例：分析に不要な列と取消データを除く

実務では、最初に不要な管理列を削除し、その後に対象外の行を除くことがあります。元データを残しながら、分析用DataFrameを作ります。

raw_df = pd.DataFrame(
    {
        "伝票ID": ["A001", "A002", "A003", "A004"],
        "商品": ["ノートPC", "マウス", "モニター", "キーボード"],
        "売上": [120000, 3000, 35000, 8000],
        "状態": ["確定", "取消", "確定", "確定"],
        "取込メモ": ["batch1", "batch1", "batch2", "batch2"],
    }
)

cancel_index = raw_df.index[raw_df["状態"] == "取消"]
analysis_df = raw_df.drop(index=cancel_index, columns=["取込メモ"])
analysis_df = analysis_df.reset_index(drop=True)

print("処理前:")
print(raw_df)
print("\n処理後:")
print(analysis_df)

実行結果

処理前: 伝票ID 商品売上状態取込メモ 0 A001 ノートPC 120000 確定 batch1 1 A002 マウス 3000 取消 batch1 2 A003 モニター 35000 確定 batch2 3 A004 キーボード 8000 確定 batch2

処理後: 伝票ID 商品売上状態 0 A001 ノートPC 120000 確定 1 A003 モニター 35000 確定 2 A004 キーボード 8000 確定

取消行と分析に不要な「取込メモ」列が除かれ、indexも0から振り直されました。実務では、削除前後の行数やIDを確認し、必要なデータまで消していないか検証してください。

まとめ

行を削除する基本形はdf.drop(index=行ラベル)
列を削除する基本形はdf.drop(columns="列名")
複数指定はリストを渡す
drop()は位置ではなくラベルを指定する
通常は元のDataFrameが変わらないため、結果を再代入する
inplace=Trueの戻り値はNone
KeyErrorが出たらdf.indexとdf.columnsを確認する
行削除後に連番が必要ならreset_index(drop=True)を使う
欠損値にはdropna()、重複にはdrop_duplicates()を使う

まずはindex=とcolumns=を使い分け、処理前後のDataFrameと行数・列数を確認する習慣を付けましょう。

次に読みたい関連記事

公式ドキュメント

pandas.DataFrame.drop

▲ ページトップへ戻る

pandasのdrop()で行を削除するにはどう書きますか？

df.drop(index=行ラベル)と書きます。複数行ならdf.drop(index=[行ラベル1, 行ラベル2])のようにリストで指定します。

pandasのdrop()で列を削除するにはどう書きますか？

df.drop(columns="列名")と書きます。複数列ならcolumns=["列名1", "列名2"]と指定します。

axis=0とaxis=1の違いは何ですか？

axis=0は行、axis=1は列です。自分でコードを書く場合は、意味が明確なindex=・columns=を使うと間違いを減らせます。

drop()を実行しても元のDataFrameに反映されないのはなぜですか？

通常のdrop()は削除後の新しいDataFrameを返し、元のDataFrameを変更しないためです。df = df.drop(...)のように再代入します。inplace=Trueも使えますが、戻り値はNoneです。

drop()・dropna()・drop_duplicates()はどう使い分けますか？

指定した行・列ならdrop()、欠損値を含む行・列ならdropna()、重複行ならdrop_duplicates()を使います。削除の目的に合うメソッドを選びましょう。

The post pandas drop()の使い方｜行・列を削除するindex・columns・axisを初心者向けに解説 first appeared on Python Data Lab（Pythonデータラボ）.

pandas drop_duplicates()の使い方｜subset・keepで重複行を削除

coin_collector — Fri, 11 Sep 2026 15:42:08 +0000

pandasで売上データを整理していると、同じ注文IDが複数行に現れることがあります。しかし、値が重複しているからといって、すぐ削除してよいとは限りません。完全な二重登録だけでなく、金額を訂正した更新後の記録が混ざっている可能性もあるためです。

drop_duplicates()は、重複の正誤を自動判定するメソッドではありません。先にduplicated(keep=False)で候補を確認し、subsetで同一レコードの基準、keepで残す記録を決めてから削除するのが基本です。

この記事では、注文データを使って、重複候補の確認から削除、削除後の検算までをGoogle Colabで順番に実行します。最後には、自分のデータで「なぜこの行を残したか」を説明できる状態を目指します。

この記事でわかること

duplicated()とdrop_duplicates()の役割の違い
subsetで重複を判定する列を選ぶ方法
keep='first'・keep='last'・keep=Falseの選び方
更新日時を確認して最新の記録を残す方法
削除前後の行数・残った値・重複件数を検算する方法
重複が消えない、消えすぎる、元のDataFrameへ反映されない場合の確認方法

drop_duplicates()は、データ分析の「読み込み→状態確認→前処理→集計」のうち、集計前の前処理で使います。前処理全体の順序を先に確認したい場合は、Pandasデータ前処理の基本を参照してください。

先に結論：判定列と残す行を決めてから削除する

重複削除では、次の2点を先に決めます。

どの列が同じなら同一レコードとみなすか：subsetで指定する
重複した記録のどれを残すか：keepで指定する

判断したいこと	選ぶ設定	適する場面	注意点
全列が同じ行だけを削除したい	`subset`を指定しない	完全なコピー行を除く	一部の値が違う更新記録は残る
注文IDなど特定列で判定したい	`subset='注文ID'`	1注文1行に整理する	注文明細が複数行なら消しすぎる
最初の行を残したい	`keep='first'`	先着記録を正とする	デフォルトだが、最初が正しいとは限らない
最後の行を残したい	`keep='last'`	最新記録を残す	先に更新日時で並べる必要がある
重複したグループを全行除外したい	`keep=False`	重複群を保留対象にする	1行も残らない

正しい記録を判断できない場合は、削除せず候補を別のDataFrameへ取り出して確認します。

注文データを用意して処理前の状態を確認する

実行目的

完全に同じ行と、注文IDは同じでも売上・更新日時が異なる行を含むDataFrameを作ります。以降は同じデータを使うため、コード、表、出力の違いを追いやすくなります。

import pandas as pd

orders = pd.DataFrame({
    "注文ID": ["A100", "A101", "A100", "A102", "A101", "A103", "A104", "A104"],
    "商品": ["ペン", "ノート", "ペン", "ファイル", "ノート", "消しゴム", "ペン", "ペン"],
    "売上": [1200, 800, 1200, 500, 900, 300, 600, 600],
    "更新日時": [
        "2026-09-01 09:00", "2026-09-01 10:00", "2026-09-01 09:00",
        "2026-09-02 11:00", "2026-09-03 15:00", "2026-09-03 16:00",
        "2026-09-04 10:00", "2026-09-04 10:00"
    ]
})

orders["更新日時"] = pd.to_datetime(orders["更新日時"])
display(orders)
print("処理前の行数:", len(orders))
print("更新日時のdtype:", orders["更新日時"].dtype)

	注文ID	商品	売上	更新日時
0	A100	ペン	1200	2026-09-01 09:00:00
1	A101	ノート	800	2026-09-01 10:00:00
2	A100	ペン	1200	2026-09-01 09:00:00
3	A102	ファイル	500	2026-09-02 11:00:00
4	A101	ノート	900	2026-09-03 15:00:00
5	A103	消しゴム	300	2026-09-03 16:00:00
6	A104	ペン	600	2026-09-04 10:00:00
7	A104	ペン	600	2026-09-04 10:00:00

処理前の行数: 8
更新日時のdtype: datetime64[ns]

ordersは8行です。注文IDA100とA104は全列が同じ完全重複です。A101は2行ありますが、売上が800から900へ変わり、更新日時も異なります。

ここで見るべきなのは、注文IDだけではありません。A101の2行は更新前後の記録と考えられるため、どちらを残すか判断するには更新日時も必要です。

削除前にduplicated()で重複候補をすべて確認する

実行目的

drop_duplicates()で消す前に、注文IDが重複する行をすべて表示します。keep=Falseは、重複グループの先頭行も含めてすべてTrueにする指定です。

duplicate_mask = orders.duplicated(subset="注文ID", keep=False)
duplicate_candidates = orders.loc[duplicate_mask].sort_values(
    ["注文ID", "更新日時"]
)

display(duplicate_candidates)
print("重複候補の行数:", duplicate_mask.sum())
print("重複している注文ID:", duplicate_candidates["注文ID"].unique().tolist())

	注文ID	商品	売上	更新日時
0	A100	ペン	1200	2026-09-01 09:00:00
2	A100	ペン	1200	2026-09-01 09:00:00
1	A101	ノート	800	2026-09-01 10:00:00
4	A101	ノート	900	2026-09-03 15:00:00
6	A104	ペン	600	2026-09-04 10:00:00
7	A104	ペン	600	2026-09-04 10:00:00

重複候補の行数: 6
重複している注文ID: ['A100', 'A101', 'A104']

重複候補は6行で、注文IDはA100・A101・A104です。A100とA104は完全重複ですが、A101は売上と更新日時が違います。

duplicated()は候補をTrue／Falseで確認し、drop_duplicates()は条件に合う行を実際に削除します。詳しい真偽値の読み方は、pandas duplicated()の使い方で確認できます。

引数なしでは全列が同じ行だけを削除する

実行目的

まず、すべての列が一致する完全重複だけを削除します。元データを残すため、結果をexact_cleanという別のDataFrameへ代入します。

exact_clean = orders.drop_duplicates()

display(exact_clean)
print("処理前の行数:", len(orders))
print("処理後の行数:", len(exact_clean))
print("削除した行数:", len(orders) - len(exact_clean))

	注文ID	商品	売上	更新日時
0	A100	ペン	1200	2026-09-01 09:00:00
1	A101	ノート	800	2026-09-01 10:00:00
3	A102	ファイル	500	2026-09-02 11:00:00
4	A101	ノート	900	2026-09-03 15:00:00
5	A103	消しゴム	300	2026-09-03 16:00:00
6	A104	ペン	600	2026-09-04 10:00:00

処理前の行数: 8
処理後の行数: 6
削除した行数: 2

8行から6行になり、完全に同じA100とA104の2行目が削除されます。一方、A101は売上と更新日時が異なるため2行とも残ります。

「注文IDが同じなら1行にしたい」場合、引数なしでは目的を達成できません。 次にsubsetで判定列を指定します。

subsetで重複を判定する列を選ぶ

subsetには列名を1つ、または列名のリストを指定できます。

指定	重複とみなす条件	このデータでの意味
指定なし	全列が一致	完全なコピー行だけを削除
`subset='注文ID'`	注文IDが一致	1注文を1行にする
`subset=['注文ID', '商品']`	注文IDと商品が両方一致	注文と商品単位で1行にする

実データでは、注文IDが「注文全体」を表すのか「注文明細」を表すのかを確認してください。1つの注文IDに複数商品が正しく含まれるデータでsubset='注文ID'を使うと、必要な明細まで消してしまいます。

実行目的

注文IDを同一レコードの基準として、各注文を1行にします。まずはデフォルトのkeep='first'で先頭行を残します。

first_clean = orders.drop_duplicates(subset="注文ID", keep="first")
display(first_clean)

	注文ID	商品	売上	更新日時
0	A100	ペン	1200	2026-09-01 09:00:00
1	A101	ノート	800	2026-09-01 10:00:00
3	A102	ファイル	500	2026-09-02 11:00:00
5	A103	消しゴム	300	2026-09-03 16:00:00
6	A104	ペン	600	2026-09-04 10:00:00

A101は先に現れた売上800の行が残ります。コードは正常に動いていますが、更新後の売上900を残したい場合には誤った結果です。firstは「正しい行」ではなく、現在の並び順で最初の行を意味します。

複数列の組み合わせで重複を判定する

注文IDだけで判定すると、1つの注文に含まれる別の商品まで削除することがあります。注文明細を商品単位で残す場合は、subsetへ複数の列をリストで指定します。

detail_orders = pd.DataFrame({
    "注文ID": ["A300", "A300", "A300", "A301"],
    "商品": ["ペン", "ノート", "ペン", "ファイル"],
    "売上": [200, 500, 200, 800]
})

order_only = detail_orders.drop_duplicates(subset="注文ID")
order_and_product = detail_orders.drop_duplicates(
    subset=["注文ID", "商品"],
    keep="first",
    ignore_index=True
)

print("処理前")
display(detail_orders)
print("注文IDだけで判定した結果")
display(order_only)
print("注文IDと商品で判定した結果")
display(order_and_product)

処理前

	注文ID	商品	売上
0	A300	ペン	200
1	A300	ノート	500
2	A300	ペン	200
3	A301	ファイル	800

注文IDだけで判定した結果

	注文ID	商品	売上
0	A300	ペン	200
3	A301	ファイル	800

注文IDと商品で判定した結果

	注文ID	商品	売上
0	A300	ペン	200
1	A300	ノート	500
2	A301	ファイル	800

subset="注文ID"では、注文A300の最初の「ペン」だけが残り、正しい明細である「ノート」まで消えます。subset=["注文ID", "商品"]では、注文IDと商品の組み合わせが同じ「ペン」の重複だけを削除し、「ノート」は残ります。

この結果から、subsetは列数を増やせば安全になるのではなく、データの1行が何を表すかに合わせて選ぶ必要があると分かります。

keepで残す行を選ぶ

同じ入力データでkeepだけを変え、残る行を比較します。

実行目的

first・last・Falseの結果から、A101と重複グループ全体がどう変わるかを確認します。

keep_first = orders.drop_duplicates(subset="注文ID", keep="first")
keep_last = orders.drop_duplicates(subset="注文ID", keep="last")
keep_none = orders.drop_duplicates(subset="注文ID", keep=False)

comparison = pd.DataFrame({
    "設定": ["first", "last", "False"],
    "残る注文ID": [
        keep_first["注文ID"].tolist(),
        keep_last["注文ID"].tolist(),
        keep_none["注文ID"].tolist()
    ],
    "A101で残る売上": [
        keep_first.loc[keep_first["注文ID"].eq("A101"), "売上"].tolist(),
        keep_last.loc[keep_last["注文ID"].eq("A101"), "売上"].tolist(),
        keep_none.loc[keep_none["注文ID"].eq("A101"), "売上"].tolist()
    ]
})

display(comparison)

	設定	残る注文ID	A101で残る売上
0	first	[A100, A101, A102, A103, A104]	[800]
1	last	[A100, A102, A101, A103, A104]	[900]
2	False	[A102, A103]	[]

firstではA101の800、lastでは900が残ります。Falseでは重複したA100・A101・A104が全行消え、重複しないA102・A103だけが残ります。

keep=Falseは「2行目以降を削除」ではありません。重複グループを1行も残さない指定です。重複データを保留用に分ける場合には使えますが、各注文を1行残したい処理では選びません。

削除後は行数・残った値・重複件数を検算する

実行目的

「エラーが出なかった」だけで終わらせず、削除行数、残ったA101の売上、残存する注文ID重複を確認します。

before_rows = len(orders)
after_rows = len(latest_orders)
removed_rows = before_rows - after_rows
remaining_duplicates = latest_orders.duplicated(
    subset="注文ID", keep=False
).sum()
a101_sales = latest_orders.loc[
    latest_orders["注文ID"].eq("A101"), "売上"
].iloc[0]

validation = pd.DataFrame({
    "確認項目": ["処理前の行数", "削除した行数", "処理後の行数", "残存する重複行数", "A101で残った売上"],
    "結果": [before_rows, removed_rows, after_rows, remaining_duplicates, a101_sales]
})

display(validation)
print("行数の式が一致:", before_rows - removed_rows == after_rows)

	確認項目	結果
0	処理前の行数	8
1	削除した行数	3
2	処理後の行数	5
3	残存する重複行数	0
4	A101で残った売上	900

行数の式が一致: True

処理前8行から3行を削除し、処理後は5行です。注文IDの残存重複行数は0、A101で残った売上は900です。行数の式もTrueになっています。

ただし、重複数が0でも判定列が正しいとは限りません。最終的には「注文IDだけで1レコードを表せるか」をデータの意味から確認してください。

よくある失敗を現象から確認・修正する

重複が消えない

現象：見た目は同じ値なのに、drop_duplicates()後も複数行が残る
主な原因：前後空白、大文字・小文字、数値と文字列の型違い、subsetの指定違い
確認方法：df.dtypes、df.columns.tolist()、repr()相当の表示、duplicated(subset=..., keep=False)で候補を確認する
修正方法：必要な列だけ空白・表記・型をそろえ、同じsubsetで再確認してから削除する
修正後の確認：削除後に同じsubsetでduplicated(keep=False).sum()が想定件数になったか確認する

必要な行まで消えた

現象：正しい注文明細や異なる観測まで削除された
主な原因：subsetが粗すぎる、またはkeep=Falseを使った
確認方法：削除前データから重複候補を全件表示し、判定列以外の値を比較する
修正方法：商品・明細番号など必要な列をsubsetへ追加する。各グループを1行残すならfirstまたはlastを選ぶ
修正後の確認：削除した行と残った行を注文IDごとに照合する

元のDataFrameへ反映されない

現象：メソッドを実行した後も元の行数が変わらない
主な原因：drop_duplicates()は既定で新しいDataFrameを返し、元データを変更しない
確認方法：戻り値を変数へ代入したか確認する
修正方法：clean_df = df.drop_duplicates(...)のように別変数へ代入する
修正後の確認：len(df)とlen(clean_df)を比較する

inplace=Trueでも変更できますが、初心者は元データと処理後データを比較できるよう、まず別変数への代入をおすすめします。

NaNを含む判定列は削除前に意味を確認する

欠損した注文IDが複数あると、それらが重複候補として扱われる場合があります。しかし「注文ID不明」が同じ注文を意味するとは限りません。実際の挙動を確認します。

missing_id_sample = pd.DataFrame({
    "注文ID": [None, None, "A200"],
    "商品": ["ペン", "ノート", "ファイル"]
})

missing_id_sample["重複候補"] = missing_id_sample.duplicated(
    subset="注文ID", keep=False
)
display(missing_id_sample)

	注文ID	商品	重複候補
0	None	ペン	True
1	None	ノート	True
2	A200	ファイル	False

2つの欠損した注文IDは重複候補になります。ただし、商品が異なるため、同一注文と断定して削除すると情報を失うおそれがあります。判定列に欠損がある場合は、欠損行を別に確認し、補完・保持・除外の方針を決めてください。欠損行の削除は重複行削除とは別の処理です。詳しくはPandas dropna()の使い方を参照してください。

自分のDataFrameへ置き換える前のチェックリスト

subsetに指定する列は、業務上の同一レコードを表しているか
1つのIDに複数明細が存在してよいデータではないか
残す行を決める更新日時・状態・優先順位の列があるか
更新日時は日時型か、欠損していないか、正しく並んでいるか
判定列に前後空白、表記ゆれ、型違い、NaNがないか
元DataFrameを残し、処理後を別変数へ保存したか
削除前後の行数、残った値、残存重複数を確認したか
集計値が想定外に減っていないか

判断根拠がない重複候補は、削除せず別DataFrameへ取り出して確認してください。

重複を削除したデータを集計へつなげる

実行目的

重複除去後の注文データを商品別に集計し、二重計上のない件数と売上合計を確認します。

product_summary = (
    latest_orders.groupby("商品", as_index=False)
    .agg(注文件数=("注文ID", "count"), 売上合計=("売上", "sum"))
    .sort_values("売上合計", ascending=False, ignore_index=True)
)

display(product_summary)
print("集計した注文件数:", product_summary["注文件数"].sum())
print("重複除去後の売上合計:", product_summary["売上合計"].sum())

	商品	注文件数	売上合計
0	ペン	2	1800
1	ノート	1	900
2	ファイル	1	500
3	消しゴム	1	300

集計した注文件数: 5
重複除去後の売上合計: 3500

集計した注文件数は5件、売上合計は3,500です。latest_ordersの5行と件数が一致します。重複削除後は、件数だけでなく合計値も確認すると、削除しすぎや二重計上に気づきやすくなります。

複数列・複数集計へ進む場合は、pandas groupby・aggの使い方を参照してください。

まとめ

drop_duplicates()の前にduplicated(keep=False)で重複候補を確認する
subsetは「何を同一レコードとみなすか」で選ぶ
keepは「どの記録を正として残すか」で選ぶ
最新行を残す場合は、更新日時を日時型へ変換し、並べてからkeep='last'を使う
keep=Falseは重複グループを全行削除するため、目的を確認して使う
削除後は行数、残った値、残存重複数、集計値を検算する
判断できない候補は自動削除せず、元データを残して確認する

重複削除の目的は、単に行数を減らすことではありません。分析に使う正しい観測単位を決め、集計の二重計上や必要データの消失を防ぐことです。

▲ ページトップへ戻る

drop_duplicates()とduplicated()の違いは何ですか？

duplicated()は重複候補をTrue／Falseで確認するメソッド、drop_duplicates()は重複行を除いたDataFrameを返すメソッドです。安全に処理するには、先にduplicated(keep=False)で全候補を表示してから削除します。

複数列が同じ行だけを削除するにはどうしますか？

subset=['注文ID', '商品']のように列名をリストで指定します。指定した列がすべて同じ行が重複と判定されます。列を増やす前に、それらが業務上の同一レコードを表すか確認してください。

最新の行だけを残すにはどうしますか？

更新日時を日時型へ変換し、古い順に並べてからkeep='last'を使います。lastは現在の行順で最後という意味なので、並べ替えずに使っても最新行が残るとは限りません。

実行しても元のDataFrameが変わらないのはなぜですか？

drop_duplicates()は既定で新しいDataFrameを返すためです。clean_df = df.drop_duplicates(...)のように戻り値を代入してください。元データを残せるため、処理前後の比較もしやすくなります。

NaNを含む行はどう判定されますか？

判定列で欠損値が重なる行は重複候補になり得ます。ただし、欠損値同士が同じ実体を示すとは限りません。削除前に欠損行を表示し、同一レコードとして扱ってよいかデータの意味から判断してください。

The post pandas drop_duplicates()の使い方｜subset・keepで重複行を削除 first appeared on Python Data Lab（Pythonデータラボ）.

pandas to_csv()の使い方｜indexなし・文字化け対策・保存先を解説

coin_collector — Thu, 10 Sep 2026 15:14:30 +0000

pandasで前処理や集計を終えたあと、「DataFrameをCSVに保存したいのに、ファイルがどこにあるか分からない」「開いたら左端に余計な列が増えた」「日本語が文字化けした」と困ることがあります。

DataFrameをCSVへ保存する基本形は、次の1行です。

df.to_csv("sales.csv", index=False)

ただし、正しく再利用できるCSVにするには、コードを書く前に次の順で決めることが大切です。

どこへ保存するか
インデックスを残すか
どのアプリで開くかに応じて文字コードを選ぶ
どの列を保存するか
同名ファイルを上書きしてよいか

この記事では、Google Colabで再現できる売上データを使い、保存されたCSVをもう一度読み込んで、行数・列名・日本語が正しいところまで確認します。

この記事でわかること

to_csv()でDataFrameをCSVへ保存する基本形
保存先、index、encoding、columnsの選び方
headerとsepで出力形式を変える方法
余計なUnnamed: 0、文字化け、保存先不明、上書きの確認方法
read_csv()で読み込み直し、保存結果を検算する方法

to_csv()は、前処理・抽出・集計した結果を、共有や再利用のためにファイルへ書き出す処理です。データを整える前工程は、Pandasデータ前処理の基本で確認できます。

先に結論：保存先→index→文字コード→列→上書きの順に決める

確認すること	選ぶ基準	主な指定	注意点
保存先	Colab終了後も残すか	一時領域の相対パス／Google Driveの絶対パス	Colabの一時領域はランタイム終了後に消える
インデックス	行ラベルに意味があるか	通常は`index=False`	顧客IDなど意味のある値まで消さない
文字コード	どのアプリで開くか	UTF-8／`utf-8-sig`	受け渡し先の指定があれば従う
保存列	全列が必要か	`columns=[...]`	列名の空白・表記違いに注意する
書き込み方法	同名ファイルを上書きしてよいか	通常保存／`mode="x"`／`mode="a"`	`mode="a"`は行の追記であり、値の更新ではない

最初は、実在する保存先へindex=Falseで保存し、読み込み直して確認するところから始めるのが安全です。

売上DataFrameを用意する

実行目的

同じデータを記事全体で使い、設定によってCSVの列や文字コードがどう変わるか比較します。商品IDは通常の列として保持し、DataFrameのインデックスは0から始まる連番です。

import pandas as pd
from pathlib import Path

# Colabの一時領域または現在の作業フォルダ内に保存用フォルダを作る
output_dir = Path("python_data_lab_output")
output_dir.mkdir(exist_ok=True)

df = pd.DataFrame({
    "商品ID": [101, 102, 103, 104],
    "商品": ["ノート", "ペン", "ファイル", "付箋"],
    "カテゴリ": ["文具", "文具", "収納", "文具"],
    "売上": [1200, 900, 1500, 600],
    "備考": ["重点商品", None, "在庫確認", "新商品"],
})

print(df)
print("行数・列数:", df.shape)

	商品ID	商品	カテゴリ	売上	備考
0	101	ノート	文具	1200	重点商品
1	102	ペン	文具	900	None
2	103	ファイル	収納	1500	在庫確認
3	104	付箋	文具	600	新商品

行数・列数: (4, 5)

出力では4行5列なので、shapeは(4, 5)です。備考の2行目にあるNoneは欠損値ですが、今回は意味のある未記入として残します。保存のためだけに0や空文字へ置き換えません。

自分のデータでは、保存前に列名・データ型・欠損値をpandas info()の使い方で確認しておくと、保存後の変化を判断しやすくなります。

基本：indexなしでCSVへ保存する

実行目的

連番インデックスをCSVへ含めず、DataFrameの5列だけを保存します。ファイル名だけを指定した相対パスは、現在の作業場所を基準に解釈されます。ここでは作成済みのpython_data_lab_outputフォルダへ保存します。

basic_path = output_dir / "sales_basic.csv"
df.to_csv(basic_path, index=False)

print("保存先:", basic_path)
print("ファイルの存在:", basic_path.exists())
print("保存フォルダ内:", sorted(p.name for p in output_dir.iterdir()))
print("CSVの先頭3行:")
print("\n".join(basic_path.read_text(encoding="utf-8").splitlines()[:3]))

保存先: python_data_lab_output/sales_basic.csv
ファイルの存在: True
保存フォルダ内: ['sales_basic.csv']
CSVの先頭3行:
商品ID,商品,カテゴリ,売上,備考
101,ノート,文具,1200,重点商品
102,ペン,文具,900,

最初に見るのは、次の3点です。

ファイルの存在がTrueになっている
1行目が商品ID,商品,カテゴリ,売上,備考になっている
左端に0、1のようなDataFrameの連番インデックスが追加されていない

to_csv()へ保存先を渡した場合、ファイルが作成されます。戻り値を新しいDataFrameとして使うメソッドではありません。

index=Trueとindex=Falseの違い

to_csv()では、indexの既定値がTrueです。指定を省略すると、DataFrameのインデックスもCSVへ出力されます。

指定	CSVの左端	選ぶ場面	注意点
`index=True`または省略	インデックスが入る	行ラベル自体に意味がある	名前のない連番は再読込時に余計な列になりやすい
`index=False`	インデックスを入れない	0始まりの連番が単なる管理番号	意味のあるIDをインデックスにしている場合は失う
`reset_index()`後に`index=False`	意味のあるインデックスを通常列として入れる	IDを明示的な列名で残したい	列が重複しないか確認する

with_index_path = output_dir / "sales_with_index.csv"
without_index_path = output_dir / "sales_without_index.csv"

df.to_csv(with_index_path)  # index=Trueが既定値
df.to_csv(without_index_path, index=False)

with_index = pd.read_csv(with_index_path)
without_index = pd.read_csv(without_index_path)

print("indexを保存したCSVの列:", with_index.columns.tolist())
print("index=FalseのCSVの列:", without_index.columns.tolist())
print(with_index.head(2))

indexを保存したCSVの列: ['Unnamed: 0', '商品ID', '商品', 'カテゴリ', '売上', '備考']
index=FalseのCSVの列: ['商品ID', '商品', 'カテゴリ', '売上', '備考']

	Unnamed: 0	商品ID	商品	カテゴリ	売上	備考
0	0	101	ノート	文具	1200	重点商品
1	1	102	ペン	文具	900	NaN

indexを省略したCSVを読み込むと、列一覧の先頭にUnnamed: 0が現れます。これは元のデータ列ではなく、列名のない連番インデックスが保存されたものです。

意味のあるインデックスは消さない

商品IDをインデックスにしたあとでindex=Falseにすると、CSVには商品IDが残りません。商品IDを再利用したい場合は、reset_index()で通常列へ戻してから保存します。

indexed_df = df.set_index("商品ID")

lost_id_path = output_dir / "sales_id_lost.csv"
kept_id_path = output_dir / "sales_id_kept.csv"

indexed_df.to_csv(lost_id_path, index=False)
indexed_df.reset_index().to_csv(kept_id_path, index=False)

print("index=FalseでIDを消した列:", pd.read_csv(lost_id_path).columns.tolist())
print("IDを通常列へ戻した列:", pd.read_csv(kept_id_path).columns.tolist())

index=FalseでIDを消した列: ['商品', 'カテゴリ', '売上', '備考']
IDを通常列へ戻した列: ['商品ID', '商品', 'カテゴリ', '売上', '備考']

注目するのは、前者には商品IDがなく、後者には残っている点です。index=Falseを機械的に付けるのではなく、現在のインデックスが単なる連番か、意味のある識別子かを先に確認してください。

日本語の文字化けを防ぐencodingの選び方

encodingは、CSVを利用する環境に合わせて選びます。

主な利用場面	候補	確認方法	注意点
Pythonや多くの現代的なツールで再利用	`utf-8`	同じencodingで読み込み直す	アプリや読み込み方法によっては日本語表示を確認する
日本語をExcelで直接開いて確認	`utf-8-sig`	実際のExcel環境で開く	Excelのバージョンや開き方でも挙動が異なる
受け渡し先から文字コード指定がある	指定された文字コード	相手先の手順で確認	環境を無視して固定しない

utf-8-sigはファイル先頭にBOMを付けたUTF-8です。日本語CSVをExcelで直接開く用途では有力な候補ですが、すべての用途で一律に選ぶ必要はありません。

utf8_path = output_dir / "sales_utf8.csv"
utf8_sig_path = output_dir / "sales_utf8_sig.csv"

df.to_csv(utf8_path, index=False, encoding="utf-8")
df.to_csv(utf8_sig_path, index=False, encoding="utf-8-sig")

print("UTF-8の先頭3バイト:", utf8_path.read_bytes()[:3])
print("UTF-8 with BOMの先頭3バイト:", utf8_sig_path.read_bytes()[:3])

checked_japanese = pd.read_csv(utf8_sig_path, encoding="utf-8-sig")
print("再読み込みした商品:", checked_japanese["商品"].tolist())

UTF-8の先頭3バイト: b'\xe5\x95\x86'
UTF-8 with BOMの先頭3バイト: b'\xef\xbb\xbf'
再読み込みした商品: ['ノート', 'ペン', 'ファイル', '付箋']

utf-8-sigのファイルでは、先頭3バイトがBOMを表すb'\xef\xbb\xbf'になります。再読み込み後の商品が「ノート」「ペン」「ファイル」「付箋」と表示されれば、指定した文字コードで日本語を読めています。

文字化けが起きたら、保存コードだけを見るのではなく、CSVをどのアプリで、どの文字コードとして開いたかも確認します。

必要な列だけcolumnsで保存する

実行目的

社内共有用として、商品・カテゴリ・売上だけを保存します。個人情報や作業用列を含むデータでは、保存前に共有範囲を確認することも重要です。

shared_columns = ["商品", "カテゴリ", "売上"]
shared_path = output_dir / "sales_shared.csv"

df.to_csv(
    shared_path,
    index=False,
    encoding="utf-8-sig",
    columns=shared_columns,
)

shared_df = pd.read_csv(shared_path, encoding="utf-8-sig")
print(shared_df)
print("保存した列:", shared_df.columns.tolist())

	商品	カテゴリ	売上
0	ノート	文具	1200
1	ペン	文具	900
2	ファイル	収納	1500
3	付箋	文具	600

保存した列: ['商品', 'カテゴリ', '売上']

出力は4行3列です。商品IDと備考が含まれず、列順もcolumnsで指定した順になっていることを確認します。

列名を間違えるとKeyErrorになります。自分のデータへ置き換える前に、df.columns.tolist()で実在する列名と前後の空白を確認してください。データ型を基準に列を選びたい場合は、pandas select_dtypes()の使い方へ進めます。

headerとsepは出力形式が必要なときだけ変更する

headerは列名を出力するか、sepは何の文字で列を区切るかを決めます。

通常の単独CSVでは、列名を残す既定のheader=Trueを使う
列名が不要という明確な仕様がある場合だけheader=Falseを使う
CSVは既定のカンマ区切り、TSVが必要な場合はsep="\t"を使う

タブ区切りでは、文字列"t"ではなく、タブ文字を表す"\t"を指定します。

no_header_path = output_dir / "sales_no_header.csv"
tsv_path = output_dir / "sales.tsv"

df[shared_columns].to_csv(no_header_path, index=False, header=False)
df[shared_columns].to_csv(tsv_path, index=False, sep="\t")

print("header=Falseの先頭行:")
print(no_header_path.read_text(encoding="utf-8").splitlines()[0])
print("TSVの先頭行（タブを見える形に変換）:")
print(tsv_path.read_text(encoding="utf-8").splitlines()[0].replace("\t", " [TAB] "))

header=Falseの先頭行:
ノート,文具,1200
TSVの先頭行（タブを見える形に変換）:
商品 [TAB] カテゴリ [TAB] 売上

header=Falseの先頭行は列名ではなく、最初の商品データになります。TSVの先頭行では、3つの列名がタブで区切られています。拡張子だけを.tsvへ変えても区切り文字は変わらないため、sepの指定とセットで確認します。

保存後はread_csv()で読み込み直して検算する

ファイルが存在するだけでは、必要な内容を正しく保存できたとは限りません。共有用CSVを読み込み直し、保存前後を同じ項目で比べます。

確認項目	保存前	再読み込み後	判断
行数	共有対象の4行	4行	一致するか
列数	指定した3列	3列	余計な列や欠落がないか
列名	商品・カテゴリ・売上	同じ3列	名前と順序が一致するか
日本語	商品名・カテゴリ名	同じ文字	文字化けしていないか
インデックス列	保存対象外	`Unnamed: 0`なし	`index=False`が反映されたか

source_for_export = df[shared_columns]
loaded = pd.read_csv(shared_path, encoding="utf-8-sig")

check_result = pd.DataFrame({
    "確認項目": ["行数", "列数", "列名", "Unnamed: 0", "商品名"],
    "結果": [
        len(source_for_export) == len(loaded),
        source_for_export.shape[1] == loaded.shape[1],
        source_for_export.columns.tolist() == loaded.columns.tolist(),
        "Unnamed: 0" not in loaded.columns,
        source_for_export["商品"].tolist() == loaded["商品"].tolist(),
    ],
})

print(check_result)
print("再読み込み後の型:")
print(loaded.dtypes)

	確認項目	結果
0	行数	True
1	列数	True
2	列名	True
3	Unnamed: 0	True
4	商品名	True

	dtype
商品	o	b	j	e	c	t
カテゴリ	o	b	j	e	c	t
売上	i	n	t	6	4

5項目がすべてTrueなら、今回の目的に必要な行・列・日本語・インデックス設定は一致しています。

ただし、CSVはDataFrameの型情報を完全に保存する形式ではありません。日付、カテゴリ型、先頭に0を含むコードなどは、再読み込み時に想定と異なる型になることがあります。ファイルを次の分析へ使う前に、dtypesやinfo()を再確認してください。

よくある失敗を現象から確認・修正する

起きる現象	主な原因	確認する箇所	修正方針	修正後の確認
保存したファイルが見つからない	相対パスの基準を誤解	現在の作業場所、`resolve()`、ファイル一覧	保存先を明示する	`exists()`が`True`
存在しないフォルダへ保存できない	親フォルダがない	保存先の親フォルダ	先にフォルダを作る	目的のファイルがある
`Unnamed: 0`が増える	名前のないindexも保存した	保存時の`index`と再読込後の列名	不要なら`index=False`で保存し直す	列一覧から消える
日本語が文字化けする	保存時と読み手の文字コードが合わない	`encoding`と開くアプリ	用途に合う文字コードで保存し直す	商品名を正しく読める
以前のファイルが消える	同名へ既定モードで上書き	保存先と同名ファイルの有無	別名または`mode="x"`	意図したファイルが両方ある
追記の途中に列名が入る	`mode="a"`でheaderも出力	追記前後の先頭・末尾	追記時だけ`header=False`	列名は先頭の1行だけ
追記後に列がずれる	列順・列数・区切りが不一致	既存CSVと追加DataFrameの列	列をそろえる。難しければ結合後に新規保存	再読込後の各値が正しい列にある

存在しない保存先フォルダを直す

起きる現象

ファイル名は正しいのに、存在しない親フォルダを含むパスへ保存しようとしてエラーになります。

原因と確認方法

to_csv()は、指定した親フォルダを自動では作りません。parent.exists()で確認します。

修正方法

必要なフォルダを作ってから保存します。

nested_path = output_dir / "reports" / "sales_report.csv"

print("修正前に親フォルダがあるか:", nested_path.parent.exists())
nested_path.parent.mkdir(parents=True, exist_ok=True)
df.to_csv(nested_path, index=False)

print("修正後にファイルがあるか:", nested_path.exists())

修正前に親フォルダがあるか: False
修正後にファイルがあるか: True

修正前の親フォルダはFalse、作成して保存した後のファイルはTrueになります。自分のデータでは、フォルダ名のスペルやGoogle Driveのマウント先も同時に確認してください。

上書きと追記はmodeで区別する

通常の保存は、同名ファイルがあると上書きします。既存ファイルを残すならmode="x"、既存CSVの末尾へ行を追加するならmode="a"を使います。mode="a"は値の更新や列の追加ではありません。

目的	mode	注意点
通常保存・上書き	既定の`"w"`	同名ファイルの内容は置き換わる
上書きを防いで新規保存	`"x"`	同名ファイルがあると`FileExistsError`
既存CSVへ行を追記	`"a"`	列順をそろえ、通常は`header=False`

protected_path = output_dir / "sales_protected.csv"
df.to_csv(protected_path, index=False)

try:
    df.to_csv(protected_path, index=False, mode="x")
except FileExistsError:
    print("同名ファイルがあるため、上書きを停止しました:", protected_path.name)

print("既存ファイルは残っているか:", protected_path.exists())

同名ファイルがあるため、上書きを停止しました: sales_protected.csv
既存ファイルは残っているか: True

FileExistsErrorが出たら、別名で保存するか、本当に上書きしてよいか判断します。続いて、列名と順序が同じデータを行方向へ追記する例を確認します。

append_path = output_dir / "sales_append.csv"
base = df[shared_columns].iloc[:3]
new_row = df[shared_columns].iloc[3:]

base.to_csv(append_path, index=False, encoding="utf-8-sig")
new_row.to_csv(
    append_path,
    index=False,
    encoding="utf-8-sig",
    mode="a",
    header=False,
)

appended = pd.read_csv(append_path, encoding="utf-8-sig")
print(appended)
print("追記後の行数:", len(appended))

	商品	カテゴリ	売上
0	ノート	文具	1200
1	ペン	文具	900
2	ファイル	収納	1500
3	付箋	文具	600

追記後の行数: 4

追記後は4行で、列名は先頭の1回だけです。header=Falseを忘れると途中に列名が入ります。列構成が違う場合は追記せず、DataFrameを結合してから新しいCSVとして保存します。

Google Colabで保存するときの注意

この記事の相対パスは、Colabではランタイムの一時領域へ保存されます。ランタイム終了後も残したい場合は、Google Driveをマウントし、実在するDrive内フォルダの絶対パスを指定します。手元のPCへダウンロードする操作と、Driveへ保存する操作は別です。

Driveの接続、パスのコピー、CSVの再読み込みは、Google ColabでCSVを読み込む方法で詳しく確認してください。この記事ではto_csv()の設定と保存結果の検算に集中します。

自分のDataFrameへ置き換える前のチェックリスト

DataFrame名は正しいか
保存する列名と順序をdf.columnsで確認したか
現在のindexは単なる連番か、意味のあるIDか
保存前の行数・列数をdf.shapeで記録したか
欠損値を空欄として出力してよいか
親フォルダは実在するか
同名ファイルを上書きしてよいか
CSVを開くアプリと文字コードは合っているか
追記する場合、既存CSVと列名・順序・区切り文字が同じか
保存後にread_csv()で読み込み直したか

Excelから読み込んだデータをCSVへ変換する場合は、先にpandas read_excel()の使い方でシート・見出し・必要列が正しいか確認してください。

保存したCSVを次の分析へつなげる

CSV保存は分析の終点とは限りません。別のNotebookで読み込み直し、データの状態を確認してから集計へ進めます。

reused = pd.read_csv(shared_path, encoding="utf-8-sig")

print("再利用するデータ:")
print(reused)
print("カテゴリ別の売上合計:")
print(reused.groupby("カテゴリ", as_index=False)["売上"].sum())

再利用するデータ:

	商品	カテゴリ	売上
0	ノート	文具	1200
1	ペン	文具	900
2	ファイル	収納	1500
3	付箋	文具	600

カテゴリ別の売上合計:

	カテゴリ	売上
0	収納	1500
1	文具	2700

再読み込みしたデータから、カテゴリ別の売上合計を計算できました。保存後は、まず列・型・欠損を確認し、その後にpandas groupby・aggの使い方で複数列・複数集計へ進めます。

CSVを読み込み直したときに列名や型が想定と違う場合は、集計へ進む前に原因を修正してください。

まとめ

DataFrameのCSV保存にはto_csv()を使う
最初に保存先を決め、index・文字コード・保存列・上書きの順で判断する
連番インデックスが不要ならindex=Falseを使う
意味のあるIDをインデックスにしている場合は、消す前に通常列へ戻すか判断する
日本語の文字コードは開く環境で選び、Excelで直接開く用途ではutf-8-sigを候補にする
columnsで保存範囲を絞り、headerとsepは必要な仕様がある場合だけ変更する
上書きを防ぐならmode="x"、行を追記する場合だけmode="a"を使う
保存後はread_csv()で読み込み直し、行数・列名・日本語・不要列を検算する

最小コードを実行して終わりにせず、保存されたCSVを次の環境で正しく読めるかまで確認することが、失敗を防ぐポイントです。

▲ ページトップへ戻る

to_csv()でindex=Falseを付けるのはなぜですか？

0から始まる連番インデックスがCSVへ追加され、再読み込み時にUnnamed: 0となるのを防ぐためです。ただし、顧客IDなど意味のあるインデックスは、通常列へ戻して残すか判断してください

CSVをExcelで開くと文字化けする場合はどうしますか？

保存時のencodingと、Excelがどの文字コードとして開いているかを確認します。日本語をExcelで直接開く用途ではencoding="utf-8-sig"を候補にし、実際の利用環境で表示を確認してください。受け渡し先に指定がある場合は、その指定を優先します。

to_csv()で保存したファイルはどこにありますか？

相対パスなら現在の作業場所を基準に保存されます。Path("ファイル名").resolve()で絶対パスを確認できます。Colabの一時領域はランタイム終了後に消えるため、残したい場合はGoogle Driveなどへ保存します。

CSVへ追記するときにヘッダーが重複するのはなぜですか？

mode="a"で追記するときも、既定では列名が出力されるためです。既存CSVと列構成を確認し、行を追記するコードではheader=Falseを指定します。

CSVへ保存するとデータ型や日付形式は保持されますか？

完全には保持されません。CSVは文字で表現されるため、再読み込み時に型が推定されます。先頭の0を持つコード、日付、カテゴリ型、欠損値などは、読み込み後にdtypesやinfo()で確認してください。

Google Colab終了後もCSVを残すにはどうしますか？

Google DriveをマウントしてDrive内の実在パスへ保存するか、ランタイム終了前に端末へダウンロードします。Driveの接続とパス確認は関連記事を参照してください。

保存後に正しく出力できたか確認するにはどうしますか？

read_csv()で読み込み直し、保存前後のshape、列名と順序、日本語、欠損値、Unnamed: 0の有無を比べます。重要なデータでは数行だけでなく、行数や集計値も確認してください。

The post pandas to_csv()の使い方｜indexなし・文字化け対策・保存先を解説 first appeared on Python Data Lab（Pythonデータラボ）.

Pandasデータ前処理の基本｜読み込み後に確認する順番と欠損・型・重複の選び方

coin_collector — Sun, 06 Sep 2026 08:12:27 +0000

CSVやExcelを読み込んだ後、すぐに欠損値を埋めたり行を削除したりしていませんか。Pandasのデータ前処理で大切なのは、決まった処理をすべて行うことではありません。DataFrameの状態を確認し、問題がある列だけを直して、処理後にもう一度確認することです。

この記事では、Google Colabでそのまま実行できる小さな売上データを使い、分析前の確認から空白・型・欠損値・重複候補の判断、集計へ進むまでの流れを解説します。

この記事でわかること

読み込み後に最初に確認する項目
空白、数値文字列、欠損値、重複候補の見分け方
to_numeric()・astype()、fillna()・dropna()を選ぶ基準
前処理後に集計・可視化へ進む目安

先に結論：前処理は「確認→選択→再確認」で進めます

読み込み直後に行うことは、データを一律にきれいにすることではありません。まずinfo()で状態を確認し、問題がある列だけを処理します。

確認で見つかった状態	選ぶ処理	処理しない判断	処理後に確認する項目
前後空白がある	`str.strip()`	空白に意味がある場合	値がそろったか
数値列が文字列	`to_numeric()`	IDなど文字列で保持すべき列	dtypeと変換後のNaN
欠損値がある	保持・`fillna()`・`dropna()`	欠損が重要な情報の場合	件数、補完値、行数
重複候補がある	`duplicated()`で確認	判定列や残す基準が未確定	候補行と行数

1. 実行前のデータを用意する

商品名の前後空白、数値ではない売上、欠損した担当者、重複候補の注文IDを持つ店舗売上データです。実データでも、元データを残して作業用のDataFrameを作ると安全です。

import pandas as pd
from IPython.display import display

raw_df = pd.DataFrame({
    '注文ID': [1001, 1002, 1002, 1003, 1004],
    '商品名': [' ノート ', 'ペン', 'ペン', 'ノート', '消しゴム'],
    '売上': ['1200', '不明', '1500', '900', ''],
    '購入日': ['2026-09-01', '2026-09-01', '2026-09-01', '2026-09-02', '2026-09-02'],
    '担当者': ['佐藤', None, None, '田中', '鈴木']
})
df = raw_df.copy()
display(df)

2. まずinfo()で列・型・欠損値を診断する

実行目的：行数、列名、データ型、欠損値がある列を一度に確認します。出力で見る場所：Non-Null Countが行数より少ない列は欠損を含みます。見た目が数字でもobject型の売上は、計算前に内容を確認します。

print('行数・列数:', df.shape)
print('
列名:', df.columns.tolist())
print('
--- df.info() の出力 ---')
df.info()
print('
列ごとの欠損数:')
display(df.isna().sum().rename('欠損数').to_frame())

この例では担当者に2件の欠損があります。一方、売上の空文字はまだ欠損値として数えられません。詳しい読み方はpandas info()の使い方を参照してください。

3. 空白と数値文字列を、対象列だけ整える

商品名の前後空白を除き、売上を計算できる数値へ変換します。不明や空文字は0円とは限らないため、0を入れず、数値に変換できない値をNaNとして確認します。

df['商品名_clean'] = df['商品名'].str.strip()
df['売上_数値'] = pd.to_numeric(df['売上'], errors='coerce')

display(df[['商品名', '商品名_clean', '売上', '売上_数値']])
print('売上_数値のdtype:', df['売上_数値'].dtype)
print('売上_数値の欠損数:', df['売上_数値'].isna().sum())

sales_problem_rows = df.loc[df['売上_数値'].isna(), ['注文ID', '売上', '売上_数値']]
display(sales_problem_rows)

結果の読み方： ノート はノートにそろい、不明と空文字はNaNになります。errors='coerce'はコードが止まらない一方、変換に失敗した元の値を必ず確認する必要があります。

数値以外の文字が混ざる可能性があるならto_numeric()、すでに正しい値を目的の型へそろえるならastype()が目安です。IDや郵便番号のように文字そのものに意味がある列は数値化しません。詳しくはpandas to_numeric()の使い方、pandas astype()の使い方を参照してください。

4. 欠損値は「何を意味するか」で選ぶ

担当者の欠損は未確認であることを明示する文字列に置き換えます。一方、売上のNaNを0にすると、未確認の売上を0円と誤解させるため補完しません。

df['担当者_clean'] = df['担当者'].fillna('担当者未確認')
display(df[['注文ID', '担当者', '担当者_clean', '売上', '売上_数値']])
print('担当者_cleanの欠損数:', df['担当者_clean'].isna().sum())
print('売上_数値の欠損数:', df['売上_数値'].isna().sum())

注意：fillna(0)を売上へ使うと、未確認の売上が集計へ混ざります。反対にdropna()で行を削除すると、担当者だけが欠損した売上まで失う可能性があります。欠損の列・意味・件数を見てから選んでください。pandas fillna()の使い方、Pandas dropna()・drop_duplicates()の使い方も参照してください。

5. 重複候補は、削除する前に判定列を決める

注文IDが1002の行は2つあります。ただし売上が異なるため、二重登録か修正履歴かは確定できません。まず候補を表示し、何を同一観測とみなすかを決めます。

duplicate_order_rows = df.loc[
    df.duplicated(subset=['注文ID'], keep=False),
    ['注文ID', '商品名_clean', '売上', '売上_数値', '購入日']
]
display(duplicate_order_rows)
print('注文IDが重複している候補行数:', len(duplicate_order_rows))

ここでは削除しません。更新日時・明細番号・取消区分などを確認してから、drop_duplicates()の対象列とkeepを選びます。詳しくはpandas duplicated()の使い方を参照してください。

6. 処理後の状態を再確認して集計へ進む

今回は売上が数値として確認できた行だけを別のDataFrameへ取り出します。元データは削除せず、未確認の売上と重複候補は残します。

sales_ready = df.loc[df['売上_数値'].notna()].copy()
print('元データの行数:', len(df))
print('売上を集計できる行数:', len(sales_ready))
print('売上を集計できない行数:', df['売上_数値'].isna().sum())
sales_ready.info()
display(sales_ready[['注文ID', '商品名_clean', '売上_数値', '担当者_clean']])

この例では集計できる行は3行です。集計結果は「数値として確認できた売上」のみであり、未確認の売上は含まれません。この前提を説明できる状態になってから次へ進みます。

7. 整えたデータを集計へつなげる

product_sales = (
    sales_ready.groupby('商品名_clean', as_index=False)['売上_数値']
    .sum()
    .sort_values('売上_数値', ascending=False)
)
display(product_sales)

結果はノートが2,100、ペンが1,500です。ただし未確認の売上は含みません。グループ別集計はpandas groupby・aggの使い方へ進んでください。日付ごとに分析したい場合はto_datetime()と.dt、resample()を使います。

まとめ

info()で列・型・欠損を確認する。
空白、型、欠損、重複のうち問題があるものだけを処理する。
元の値、行数、欠損数、dtypeを処理後に再確認する。
前提を理解したうえで集計・可視化へ進む。

▲ ページトップへ戻る

欠損値はすべて埋めるべきですか？

いいえ。欠損が何を意味するか、補完すると集計や判断がどう変わるかで決めます。

to_numeric()とastype()はどちらを使えばよいですか？

変換できない値を確認したい場合はto_numeric()、正しい値を目的のdtypeへそろえる場合はastype()が目安です。

重複行はすぐに削除してよいですか？

いいえ。何を同一観測とみなすかを先に決め、duplicated(..., keep=False)で候補を確認してから判断します。

どこまで確認したら集計へ進めますか？

集計に使う列の型、欠損値、対象外にした行数、重複候補の扱いを説明できる状態になったら進みます。

The post Pandasデータ前処理の基本｜読み込み後に確認する順番と欠損・型・重複の選び方 first appeared on Python Data Lab（Pythonデータラボ）.

pandas explode()の使い方｜リスト列を複数行に展開する方法

coin_collector — Thu, 03 Sep 2026 12:17:18 +0000

アンケートの複数回答や商品タグのように、1つのセルに複数の値が入っていて、要素ごとに集計できないことがあります。

セルの値がリスト形式なら、pandasのexplode()を使うと、リストの各要素を1行ずつに展開できます。

df.explode("列名", ignore_index=True)

ただし、カンマ区切りの文字列はそのままでは分割されません。また、展開後は行数が増え、指定していない列の値も繰り返されます。この記事では、コードを動かすだけでなく、行数・インデックス・空リスト・欠損値を確認し、集計結果が正しいか検算する方法まで説明します。

この記事でわかること

explode()でリスト形式の列を1要素1行へ展開する方法
ignore_index=Trueを使う場面
explode()・str.split()・melt()・横方向展開の選び方
複数列を同時に展開する条件
空リスト、NaN、通常の文字列がどう扱われるか
ValueErrorや想定外の行数が生じたときの確認・修正方法
展開後にvalue_counts()で件数を集計し、合計を検算する方法

explode()は、データ確認後、集計や可視化へ進む前にデータの形を整える処理です。

最初に確認：何をどの方向へ分けたいか

似た処理でも、入力データと目的によって使う方法が変わります。

方法	入力の状態	求める結果	選ぶ場面	注意点
`explode()`	セル内がリスト・タプルなど	各要素を縦方向の行へ展開	複数回答、タグ、商品一覧	行数が増え、元インデックスが繰り返される
`str.split()` → `explode()`	セル内がカンマなどで区切られた文字列	文字列を分割してから行へ展開	`"Python,SQL"`のような値	区切り文字と前後空白を確認する
`melt()`	複数の列に値が分かれている	列名と値を縦持ちへ変換	月別列、科目別列など	セル内のリストを分ける処理ではない

今回の目的は「セル内の複数回答を、回答1件につき1行へ変える」ことなので、explode()を選びます。なお、リスト要素を横方向の別列へ広げたい場合はapply(pd.Series)などを使いますが、この記事では深入りしません。

基本例：複数回答のリストを1要素1行へ展開する

実行前のデータを確認する

回答者ID、年代、学びたいテーマを持つアンケートデータを使います。学びたいテーマ列には、文字列ではなくPythonのリストが入っています。

import pandas as pd
import numpy as np

survey = pd.DataFrame({
    "回答者ID": [101, 102, 103],
    "年代": ["20代", "30代", "20代"],
    "学びたいテーマ": [
        ["Python", "pandas"],
        ["pandas", "可視化", "SQL"],
        ["Python"]
    ]
})

survey

	回答者ID	年代	学びたいテーマ
0	101	20代	[Python, pandas]
1	102	30代	[pandas, 可視化, SQL]
2	103	20代	[Python]

実行前は3行です。学びたいテーマ列のリストには、それぞれ2個、3個、1個の要素があります。合計は6個なので、すべてを展開すると6行になるはずです。

回答者ID	年代	学びたいテーマ
101	20代	`[Python, pandas]`
102	30代	`[pandas, 可視化, SQL]`
103	20代	`[Python]`

explode()を実行する

まずは元インデックスを残して展開します。explode()は元のDataFrameを自動で上書きしないため、結果を新しい変数へ代入します。

survey_long = survey.explode("学びたいテーマ")
survey_long

	回答者ID	年代	学びたいテーマ
0	101	20代	Python
0	101	20代	pandas
1	102	30代	pandas
1	102	30代	可視化
1	102	30代	SQL
2	103	20代	Python

出力では、次の3点に注目してください。

学びたいテーマの各要素が別の行になっています。
回答者IDと年代は、展開された各行へ繰り返されています。
左端のインデックスは0, 0, 1, 1, 1, 2となり、元の行番号が保持されています。

インデックスの重複は、重複回答が発生したという意味ではありません。同じ元レコードから展開された行であることを示しています。

ignore_index=Trueで連番にする

元の行番号を残す必要がなく、展開後の行へ0から連番を付けたい場合は、ignore_index=Trueを指定します。

survey_long = survey.explode("学びたいテーマ", ignore_index=True)
survey_long

	回答者ID	年代	学びたいテーマ
0	101	20代	Python
1	101	20代	pandas
2	102	30代	pandas
3	102	30代	可視化
4	102	30代	SQL
5	103	20代	Python

学びたいテーマの内容は同じですが、インデックスが0から5までの連番になりました。

指定	展開後のインデックス	選ぶ場面
`ignore_index=False`（初期値）	元のインデックスを繰り返す	どの元行から展開されたか追跡したい
`ignore_index=True`	0から連番を振り直す	展開後の表を新しいデータとして扱いたい

すでにignore_index=Falseで展開した結果なら、reset_index(drop=True)でも後から連番へ直せます。

展開前後の行数を検算する

コードがエラーなく動いても、期待した件数になっているとは限りません。リスト内の要素数を合計し、展開後の行数と比較します。

expected_rows = survey["学びたいテーマ"].map(len).sum()
actual_rows = len(survey_long)

print(f"展開前の行数: {len(survey)}")
print(f"リスト内の要素数合計: {expected_rows}")
print(f"展開後の行数: {actual_rows}")
print(f"件数は一致: {expected_rows == actual_rows}")

展開前の行数: 3
リスト内の要素数合計: 6
展開後の行数: 6
件数は一致: True

要素数合計と展開後の行数は、どちらも6です。これで、今回のデータでは回答を欠落・重複させず展開できたと確認できます。

ただし、空リストやNaNを含む場合は、単純な要素数合計と展開後行数が一致しないことがあります。後半で、その理由を確認します。

カンマ区切りの文字列は、先にstr.split()で分割する

explode()が展開するのは、リストやタプルなどのlist-likeな値です。"Python, pandas"のような通常の文字列を指定しても、カンマや1文字ごとには分かれません。

次のデータで違いを確認します。

survey_text = pd.DataFrame({
    "回答者ID": [201, 202],
    "学びたいテーマ": ["Python, pandas", "可視化, SQL"]
})

not_split = survey_text.explode("学びたいテーマ", ignore_index=True)
not_split

	回答者ID	学びたいテーマ
0	201	Python, pandas
1	202	可視化, SQL

行数は2行のままで、文字列は分割されていません。これはエラーではなく、explode()の仕様どおりの結果です。

確認方法と修正方法

現象：explode()を実行しても行が増えない
原因：セルの値がリストではなく1つの文字列
確認方法：対象列の値と型を確認する
修正方法：str.split()でリスト化し、前後空白を除いてから展開する

print("変換前の値:", survey_text.loc[0, "学びたいテーマ"])
print("変換前の型:", type(survey_text.loc[0, "学びたいテーマ"]).__name__)

survey_text_fixed = survey_text.assign(
    学びたいテーマ=survey_text["学びたいテーマ"].str.split(",")
)

survey_text_fixed["学びたいテーマ"] = survey_text_fixed["学びたいテーマ"].map(
    lambda items: [item.strip() for item in items]
)

text_long = survey_text_fixed.explode("学びたいテーマ", ignore_index=True)
text_long

変換前の値: Python, pandas
変換前の型: str

	回答者ID	学びたいテーマ
0	201	Python
1	201	pandas
2	202	可視化
3	202	SQL

修正後は4行になり、Python、pandas、可視化、SQLが1行ずつに分かれました。str.split(",")だけでは区切り後の空白が残るため、各要素へstrip()を適用しています。

自分のデータでは、カンマが半角か全角か、セミコロンやパイプで区切られていないかも確認してください。

複数列を同時に展開する

複数列の各要素に対応関係がある場合は、列名のリストを渡して同時に展開できます。次の例では、1番目のテーマと1番目の習熟度、2番目どうしが対応しています。

skills = pd.DataFrame({
    "回答者ID": [301, 302],
    "学びたいテーマ": [["Python", "pandas"], ["SQL", "可視化"]],
    "習熟度": [["入門", "初級"], ["初級", "入門"]]
})

skills_long = skills.explode(
    ["学びたいテーマ", "習熟度"],
    ignore_index=True
)
skills_long

	回答者ID	学びたいテーマ	習熟度
0	301	Python	入門
1	301	pandas	初級
2	302	SQL	初級
3	302	可視化	入門

結果は4行になり、Python―入門、pandas―初級のように対応関係を保って展開されます。

複数列では、行ごとの要素数をそろえる

同時に展開する列は、各行でリストの長さが一致している必要があります。長さが違うとValueError: columns must have matching element countsが発生します。

skills_error = pd.DataFrame({
    "回答者ID": [401, 402],
    "学びたいテーマ": [["Python", "pandas"], ["SQL", "可視化"]],
    "習熟度": [["入門"], ["初級", "入門"]]
})

length_check = skills_error.assign(
    テーマ数=skills_error["学びたいテーマ"].map(len),
    習熟度数=skills_error["習熟度"].map(len)
)
length_check[["回答者ID", "テーマ数", "習熟度数"]]

	回答者ID	テーマ数	習熟度数
0	401	2	1
1	402	2	2

回答者ID401だけ、テーマ数が2、習熟度数が1です。この状態で2列を同時に展開すると、どの習熟度をどのテーマへ対応させるか決められません。

ここでは、元データを確認した結果、pandasの習熟度が未回答だったと分かったものとして、意味を勝手に補わずpd.NAを追加します。

skills_fixed = skills_error.copy()
skills_fixed.at[0, "習熟度"] = ["入門", pd.NA]

fixed_long = skills_fixed.explode(
    ["学びたいテーマ", "習熟度"],
    ignore_index=True
)
fixed_long

	回答者ID	学びたいテーマ	習熟度
0	401	Python	入門
1	401	pandas
2	402	SQL	初級
3	402	可視化	入門

修正後は4行へ展開でき、pandasに対応する習熟度は欠損値として残りました。

重要なのは、エラーを消すためだけに値を複製しないことです。対応関係を元データで確認できない場合は、同時展開を中止するか、欠損として明示してください。

空リスト・NaN・通常の文字列の挙動を確認する

セルの状態によって、展開後の結果が変わります。代表的な入力を1つの表で確認します。

mixed = pd.DataFrame({
    "状態": ["リスト", "空リスト", "NaN", "通常の文字列", "数値"],
    "値": [["Python", "pandas"], [], np.nan, "SQL", 100]
})

mixed_long = mixed.explode("値", ignore_index=True)
mixed_long

	状態	値
0	リスト	Python
1	リスト	pandas
2	空リスト	NaN
3	NaN	NaN
4	通常の文字列	SQL
5	数値	100

入力	展開後の考え方	確認上の注意
要素を持つリスト	要素数だけ行へ展開	指定外列は各行へ複製される
空リスト	`NaN`を持つ1行になる	「回答なし」か「空の選択肢」か、元データの意味を確認する
`NaN`	そのまま1行残る	欠損を削除・補完するかは分析目的で決める
通常の文字列	そのまま残る	区切り文字列なら先に`str.split()`する
数値などのスカラー	そのまま残る	リストとスカラーの混在が意図どおりか確認する

空リストとNaNは展開後の表示が似ていますが、元データでの意味が同じとは限りません。処理前に業務上の定義を確認しましょう。

展開後にvalue_counts()で件数を集計する

最初のアンケートデータに戻り、テーマ別の回答件数を数えます。

theme_counts = (
    survey_long["学びたいテーマ"]
    .value_counts()
    .rename_axis("学びたいテーマ")
    .reset_index(name="回答件数")
)

theme_counts

	学びたいテーマ	回答件数
0	Python	2
1	pandas	2
2	可視化	1
3	SQL	1

Pythonとpandasが2件、可視化とSQLが1件です。回答件数の合計は6件になり、展開後の有効なテーマ数と一致するはずです。

count_total = theme_counts["回答件数"].sum()
valid_total = survey_long["学びたいテーマ"].notna().sum()

print(f"集計表の回答件数合計: {count_total}")
print(f"展開後の有効テーマ数: {valid_total}")
print(f"集計結果は一致: {count_total == valid_total}")

集計表の回答件数合計: 6
展開後の有効テーマ数: 6
集計結果は一致: True

両方とも6件なので、展開から集計までの件数は一致しています。

ここで注意したいのは、展開後のlen(survey_long)が回答者数ではないことです。回答者数を求めるなら回答者ID.nunique()、選択されたテーマの総数を求めるなら展開後の有効行数を使います。何を1件と数えるかを先に決めることが大切です。

自分のデータへ置き換えるときのチェックリスト

df.columnsで対象列名が正しいか
対象セルがリスト・タプル等か、区切り文字列か
文字列なら区切り記号と前後空白が何か
空リスト、NaN、空文字がそれぞれ何を意味するか
複数列を展開する場合、各行で要素数と対応順が一致するか
元インデックスを残す必要があるか
展開後に数えたい単位が、元レコード数か要素数か
展開前の要素数合計と、展開・欠損処理後の件数が整合するか

対象列の型が混在していそうなら、実行前に値と型の組み合わせを確認します。次の例では、リストだけでなく、文字列・欠損値・数値が混ざっているため、そのままexplode()してもすべての行を同じようには展開できないと分かります。

type_check_data = pd.DataFrame({
    "元の値": [["Python", "pandas"], "SQL, 可視化", np.nan, 100]
})

type_check = type_check_data.assign(
    型=type_check_data["元の値"].map(lambda value: type(value).__name__)
)

type_check

	元の値	型
0	[Python, pandas]	list
1	SQL, 可視化	str
2	NaN	float
3	100	int

まとめ

セル内のリストを1要素1行へ展開するにはexplode()を使います。
区切り文字列は、先にstr.split()でリスト化します。
ignore_index=Trueなら、展開後のインデックスを0から振り直せます。
指定外の列は繰り返されるため、展開後の行数を回答者数と混同しないようにします。
複数列を同時に展開するには、各行でリストの長さと要素の対応をそろえます。
空リスト、NaN、通常の文字列、スカラーでは挙動が異なるため、元データの型と意味を確認します。
最後に要素数や集計値を照合し、「コードが動いた」だけでなく「正しく展開できた」ことを検算します。

展開後は、value_counts()で全体件数を確認したり、groupby()とagg()で年代別に集計したりできます。必要に応じて欠損処理や表記ゆれの修正を行い、棒グラフなどの可視化へ進みましょう。

pandas melt()の使い方｜横持ちデータを縦持ちに変換する方法：セル内ではなく、複数の列を縦持ちへ変換したい場合
pandas reset_index()の使い方：展開後のインデックスを後から整理したい場合
pandas value_counts()の使い方：展開した要素の件数・割合を数えたい場合
pandas groupby・aggの使い方：年代などの属性別に集計したい場合
pandas fillna()の使い方：展開後の欠損値を目的に合わせて補完したい場合
pandas str.strip()の使い方：文字列要素の前後空白を削除したい場合
Matplotlib 棒グラフ入門：集計した件数をグラフで比較したい場合

▲ ページトップへ戻る

explode()で文字列が1文字ずつ分かれないのはなぜですか？

通常の文字列はlist-likeな複数要素として展開されず、そのまま残るためです。カンマ区切りなどの文字列なら、先にstr.split()でリスト化してからexplode()を実行します。

複数列を同時に展開するとValueErrorになるのはなぜですか？

同時に展開する列のリスト長が、同じ行の中で一致していない可能性があります。各列へmap(len)を適用して要素数を確認し、元データ上の対応関係に従って長さをそろえるか、同時展開をやめてください。

展開後にインデックスが重複するのは問題ですか？

初期設定では元インデックスを保持するため、正常な動作です。元行を追跡するならそのまま使い、連番が必要ならignore_index=Trueを指定します

空リストとNaNは展開後にどうなりますか？

空リストはNaNを持つ1行になり、もともとのNaNもそのまま残ります。表示が似ていても元データでの意味は異なる場合があるため、削除や補完の前に意味を確認してください。

explode()とmelt()はどう使い分けますか？

セル内のリスト要素を行へ分けるならexplode()、複数の列を「項目名の列」と「値の列」へまとめるならmelt()を使います

展開後の行数が正しいか、どう確認しますか？

欠損や空リストがない単純なデータなら、展開前の各リストの長さを合計し、展開後の行数と比較します。欠損や空リストがある場合は、それらが1行として残る仕様を考慮し、有効値の件数も併せて確認してください。

The post pandas explode()の使い方｜リスト列を複数行に展開する方法 first appeared on Python Data Lab（Pythonデータラボ）.

pandas info()の使い方｜Non-Null Count・データ型・欠損値の見方

coin_collector — Sun, 30 Aug 2026 00:56:45 +0000

CSVを読み込んだあと、「列のデータ型は合っているのか」「欠損値はあるのか」「分析前に何を確認すればよいのか」と迷うことはありませんか。

そんなときに使うのが、Pandasのinfo()です。df.info()を実行すると、DataFrameの行数・列数・列名・欠損していない値の数・データ型・メモリ使用量をまとめて確認できます。

ただし、表示するだけでは十分ではありません。特に重要なのは、Non-Null CountとDtypeを対応させて読むことです。

Non-Null Countが全行数より少ない列 → 欠損値がある
Dtypeが想定と異なる列 → 型変換が必要な可能性がある

この記事では、info()の出力を上から順に読み、問題を発見し、必要な前処理を選び、修正後にもう一度確認するところまで解説します。

この記事でわかること

df.info()で確認できる内容
Non-Null CountとDtypeの読み方
欠損値や想定外のデータ型を見つける方法
info()・shape・dtypes・isnull()・describe()の使い分け
print(df.info())の最後にNoneが表示される理由
確認結果から型変換や欠損値処理へ進む方法

この記事のゴールは、df.info()の結果から問題を発見し、次に必要な前処理を自分で判断できるようになることです。

先に結論：info()はデータの構造を最初に診断するときに使う

info()は、DataFrameの中身を変更するメソッドではありません。現在の構造をまとめて表示する確認用のメソッドです。

CSVを読み込んだら、次の順番で確認すると迷いにくくなります。

行数と列数が想定どおりか
Non-Null Countが全行数より少ない列はないか
Dtypeが想定どおりか
問題があれば、専用の確認・修正方法へ進む

たとえば、Non-Null Countが少なければisnull().sum()、数値にしたい列がobject型ならto_numeric()、日付列がobject型ならto_datetime()で詳しく確認・修正します。

売上データを用意してinfo()を実行する

CSVから読み込んだ状態を想定した、5行の売上データを使います。

日付は文字列
売上にはカンマ付きの数字があり、文字列として保存
返品数には欠損値が1つ存在

まず、実行前のDataFrameを確認しましょう。

import pandas as pd
import numpy as np

df = pd.DataFrame({
    "日付": ["2026-08-01", "2026-08-02", "2026-08-03", "2026-08-04", "2026-08-05"],
    "商品": ["ノート", "ペン", "ノート", "ファイル", "ペン"],
    "売上": ["1,200", "900", "1,500", "800", "1,100"],
    "返品数": [0, np.nan, 1, 0, 2]
})

df

	日付	商品	売上	返品数
0	2026-08-01	ノート	1,200	0.0
1	2026-08-02	ペン	900	NaN
2	2026-08-03	ノート	1,500	1.0
3	2026-08-04	ファイル	800	0.0
4	2026-08-05	ペン	1,100	2.0

日付や売上は見た目だけでは型を判断できません。また、返品数の2行目にはNaNがあります。次にdf.info()を実行し、DataFrame全体の構造を確認します。

df.info()


RangeIndex: 5 entries, 0 to 4
Data columns (total 4 columns):
 #   Column  Non-Null Count  Dtype  
---  ------  --------------  -----  
 0   日付      5 non-null      object 
 1   商品      5 non-null      object 
 2   売上      5 non-null      object 
 3   返品数     4 non-null      float64
dtypes: float64(1), object(3)
memory usage: 292.0+ bytes

出力は、次の順で読みます。

出力項目	確認できること	今回の注目点
`DataFrame`	対象の種類	PandasのDataFrameである
`RangeIndex`	行数とインデックス範囲	5行、インデックスは0〜4
`Data columns`	合計列数	4列
`Column`	列番号と列名	日付・商品・売上・返品数
`Non-Null Count`	欠損していない値の数	返品数だけ4件
`Dtype`	Pandasが認識した型	日付・商品・売上はobject、返品数はfloat64
`dtypes`	型ごとの列数	float64が1列、objectが3列
`memory usage`	DataFrameのおおよそのメモリ使用量	データ規模の目安

最初に見るべきなのは、返品数のNon-Null Countが4であることと、日付・売上がobject型であることです。

info()はデータを表示・診断するだけなので、実行しても元のDataFrameは変わりません。

Non-Null Countから欠損値を見つける

Non-Null Countは、欠損していない値の数です。欠損数ではありません。

今回のDataFrameは全5行です。返品数は4 non-nullなので、欠損数は次のように求められます。

欠損数 = 全行数 − Non-Null Count = 5 − 4 = 1

各列の関係を整理すると、次のようになります。

列名	全行数	Non-Null Count	欠損数
日付	5	5	0
商品	5	5	0
売上	5	5	0
返品数	5	4	1

info()で欠損値の存在は分かりますが、どの行が欠損しているかまでは分かりません。詳しい件数と位置はisnull()で確認します。

# 列ごとの欠損数
df.isnull().sum()

	0
日付	0
商品	0
売上	0
返品数	1

dtype: int64

# 欠損値がある行
df[df["返品数"].isnull()]

	日付	商品	売上	返品数
1	2026-08-02	ペン	900	NaN

返品数の欠損数は1件で、インデックス1の行にあることが分かりました。

ここで注意したいのは、欠損値を見つけても、すぐに0で埋めたり行を削除したりしないことです。0が「返品なし」を意味するのか、「記録漏れ」を意味するのかで適切な処理は変わります。

今回は、データの作成ルールとして空欄は返品なしを意味すると確認できたものとして、後ほど0で補完します。自分のデータでは、業務上の意味を確認してからfillna()またはdropna()を選んでください。

Dtypeからデータ型の問題を見つける

Dtypeは、各列をPandasがどのデータ型として認識しているかを示します。

今回の結果では、次の3点に注目します。

列名	現在のDtype	期待する型	判断
日付	object	datetime64[ns]	日付計算や月別集計の前に変換候補
商品	object	object	商品名なのでそのままでよい
売上	object	int64	合計や平均を求める前に変換候補
返品数	float64	int64	欠損値のためfloat64になっている

object型は必ず「普通の文字列」とは限らない

object型には、商品名のような文字列だけでなく、文字列として読み込まれた日付や数字も含まれます。そのため、object型を見つけても、すぐに機械的な型変換をせず、値の中身を確認します。

# object型の列と実際の値を確認
print(df.select_dtypes(include="object").columns.tolist())
df[["日付", "商品", "売上"]]

['日付', '商品', '売上']

	日付	商品	売上
0	2026-08-01	ノート	1,200
1	2026-08-02	ペン	900
2	2026-08-03	ノート	1,500
3	2026-08-04	ファイル	800
4	2026-08-05	ペン	1,100

日付は日付形式の文字列、売上はカンマを含む数字の文字列です。一方、商品は名称なのでobject型のままで問題ありません。

売上のような列へ単純にastype(int)を使うと、1,200のカンマを整数として解釈できず、変換エラーになります。カンマを除いてからto_numeric()を使うと、数値に変換できない値の確認もしやすくなります。

float64は必ず小数を記録した列とは限らない

返品数の値は0・1・2という整数ですが、欠損値NaNを含むため、今回の環境ではfloat64として表示されています。Dtypeだけを見て「返品数には小数がある」と判断しないようにしましょう。

問題を修正してからinfo()で再確認する

次の方針で修正します。

日付：to_datetime()で日付型へ変換
売上：カンマを取り除き、to_numeric()で数値型へ変換
返品数：空欄は返品なしというルールに基づき0で補完して整数型へ変換
商品：名称なのでobject型のまま維持

元のDataFrameを残して比較できるように、コピーしたdf_fixedを修正します。

df_fixed = df.copy()

df_fixed["日付"] = pd.to_datetime(df_fixed["日付"])
df_fixed["売上"] = pd.to_numeric(
    df_fixed["売上"].str.replace(",", "", regex=False)
)
df_fixed["返品数"] = df_fixed["返品数"].fillna(0).astype("int64")

df_fixed

	日付	商品	売上	返品数
0	2026-08-01	ノート	1200	0
1	2026-08-02	ペン	900	0
2	2026-08-03	ノート	1500	1
3	2026-08-04	ファイル	800	0
4	2026-08-05	ペン	1100	2

表示上は似ていますが、日付・売上・返品数のデータ型が変わっています。修正できたと決めつけず、もう一度info()を実行して検証します。

df_fixed.info()


RangeIndex: 5 entries, 0 to 4
Data columns (total 4 columns):
 #   Column  Non-Null Count  Dtype         
---  ------  --------------  -----         
 0   日付      5 non-null      datetime64[ns]
 1   商品      5 non-null      object        
 2   売上      5 non-null      int64         
 3   返品数     5 non-null      int64         
dtypes: datetime64[ns](1), int64(2), object(1)
memory usage: 292.0+ bytes

再確認では、次の変化に注目します。

日付：object → datetime64[ns]
売上：object → int64
返品数：4 non-null → 5 non-null、float64 → int64
商品：objectのまま

処理前後を一覧でも確認しましょう。

comparison = pd.DataFrame({
    "修正前_Dtype": df.dtypes.astype(str),
    "修正後_Dtype": df_fixed.dtypes.astype(str),
    "修正前_Non-Null": df.notna().sum(),
    "修正後_Non-Null": df_fixed.notna().sum()
})

comparison

	修正前_Dtype	修正後_Dtype	修正前_Non-Null	修正後_Non-Null
日付	object	datetime64[ns]	5	5
商品	object	object	5	5
売上	object	int64	5	5
返品数	float64	int64	4	5

この比較表によって、型変換と欠損値処理が想定どおり反映されたことを確認できます。

重要なのは、info()が自動的に問題を直したわけではないことです。info()で問題を発見し、別のメソッドで修正し、最後にinfo()で再確認しています。

print(df.info())でNoneが表示される理由

info()は、要約情報を画面へ表示するメソッドです。要約情報をDataFrameや文字列として返すのではなく、戻り値はNoneです。

そのため、print(df.info())と書くと、最初にinfo()の情報が表示され、そのあとに戻り値のNoneが表示されます。

print(df_fixed.info())


RangeIndex: 5 entries, 0 to 4
Data columns (total 4 columns):
 #   Column  Non-Null Count  Dtype         
---  ------  --------------  -----         
 0   日付      5 non-null      datetime64[ns]
 1   商品      5 non-null      object        
 2   売上      5 non-null      int64         
 3   返品数     5 non-null      int64         
dtypes: datetime64[ns](1), int64(2), object(1)
memory usage: 292.0+ bytes
None

最後のNoneはエラーではありません。通常は、次のようにprint()を付けずに実行します。

df_fixed.info()

また、次のコードでもresultに要約表が保存されるわけではありません。

result = df_fixed.info()

この場合、resultの値はNoneです。

info()・shape・dtypes・isnull()・describe()の使い分け

似た確認方法は、何を知りたいかで選びます。

方法	何を求めるか	選ぶ場面	分からないこと・注意点
`info()`	構造・非欠損数・型の全体像	データ読込直後の診断	欠損位置や値の分布は分からない
`shape`	行数と列数	件数を値として取得したい	型や欠損値は分からない
`dtypes`	列ごとのデータ型	型だけを一覧で確認したい	非欠損数は分からない
`isnull().sum()`	列ごとの欠損数	欠損値を詳しく確認したい	型や分布の確認が中心ではない
`describe()`	統計量と値の分布	平均・中央値・ばらつきを見たい	DataFrame全体の構造確認とは目的が違う

迷ったら、最初にinfo()で全体を診断し、見つかった問題に応じて専用の方法へ進みます。

件数だけ必要 → shape
型だけ詳しく確認 → dtypes
欠損数や欠損位置を確認 → isnull()
数値の分布を確認 → describe()

select_dtypes()は、特定の型の列だけを抽出したいときに使います。全体診断ではなく、info()で型を確認した後の処理です。

print("shape:", df_fixed.shape)
print("\ndtypes:")
print(df_fixed.dtypes)
print("\n欠損数:")
print(df_fixed.isnull().sum())

shape: (5, 4)

dtypes:
日付     datetime64[ns]
商品             object
売上              int64
返品数             int64
dtype: object

欠損数:
日付     0
商品     0
売上     0
返品数    0
dtype: int64

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

Non-Null Countを欠損数だと思う

現象： 返品数 4 non-nullを「欠損値が4件ある」と読む。
原因： Non-Nullは「欠損していない」という意味だからです。
確認方法： 全行数からNon-Null Countを引きます。
修正方法： 正確な列別件数はisnull().sum()で確認します。
修正後の確認： 今回は5−4で、欠損値は1件です。

object型をすべて文字列として扱う

現象： 売上の合計や日付による月別集計ができない、または想定外の結果になる。
原因： 数字や日付が文字列として読み込まれています。
確認方法： head()や対象列を表示し、実際の値と記号の混入を確認します。
修正方法： 数値はto_numeric()、日付はto_datetime()を検討します。一般的な型変換にはastype()を使います。
修正後の確認： info()を再実行し、Dtypeが想定した型へ変わったか確認します。

float64を「小数を記録した列」と決めつける

現象： 整数件数の列がfloat64と表示される。
原因： 欠損値を含む整数列が、今回のDataFrameではfloat64として保持されているためです。
確認方法： 実際の値と欠損値の有無を確認します。
修正方法： 欠損値の意味を確認して処理した後、必要なら整数型へ変換します。
修正後の確認： 今回の返品数は、補完後にint64となりました。

memory usageを厳密な全メモリ量だと思う

info()のmemory usageは、データ規模を知るための目安です。object型が参照するオブジェクトのメモリなど、条件によってはすべてを詳細に含む値ではありません。この記事ではメモリ最適化へ深入りせず、「急に大きなデータを読み込んでいないか」を確認する目安として使います。

info()でうまく確認できないときの原因と対処

NameError: name ‘df’ is not defined

現象： df.info()を実行するとNameErrorが出る。
原因： dfを作成・読み込みするセルをまだ実行していないか、変数名が違います。
確認方法： ColabでDataFrame作成セルが実行済みか、変数名がdfか確認します。
修正方法： DataFrameを作成・読み込みするセルから順に実行します。
修正後の確認： type(df)がpandas.core.frame.DataFrameとなり、df.info()が表示されることを確認します。

AttributeErrorが出る

現象： 対象によっては「infoという属性がない」というAttributeErrorが出る。
原因： dfがDataFrameではなく、リストなど別のオブジェクトになっている可能性があります。
確認方法： type(df)で対象の種類を確認します。
修正方法： 正しいDataFrame変数を指定するか、必要に応じてDataFrameへ変換します。
修正後の確認： type(df)とdf.info()の両方を再確認します。

自分のデータでinfo()を使うときの確認ポイント

サンプルを自分のCSVやExcelデータへ置き換えるときは、次を確認してください。

想定した行数と列数になっているか
必要な列名が存在するか
各列のNon-Null Countが全行数と一致するか
数値・日付・文字列のDtypeが想定どおりか
object型の列に、数字・日付・記号などが混在していないか
郵便番号や商品コードなど、先頭の0を残すべき列を数値にしていないか
欠損値を0や平均値で埋めても、データの意味が変わらないか
修正後に再度info()を実行したか

特に、郵便番号や商品コードは計算する数値ではありません。CSV読込時に数値として解釈されると先頭の0が失われることがあるため、読み込み段階で文字列として扱う方法を検討します。

info()の確認結果を次の分析工程へつなげる

info()は、データ分析のゴールではなく入口です。次の順で進めると、問題を見落としにくくなります。

CSVやExcelからデータを読み込む
head()で実際の値を確認する
info()で構造・非欠損数・型を確認する
isnull()で欠損値を詳しく確認する
to_numeric()・to_datetime()・astype()で型を整える
fillna()またはdropna()で欠損値を処理する
describe()で分布や統計量を確認する
必要な抽出・集計・可視化へ進む

構造と型を確認するのがinfo()、値の分布を確認するのがdescribe()です。この役割を分けると、どちらを使うか迷いにくくなります。

まとめ：info()は問題を見つけて次の処理を選ぶために使う

df.info()は、DataFrameの行数・列数・列名・Non-Null Count・Dtype・メモリ使用量をまとめて確認するメソッドです。

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

Non-Null Countは欠損していない値の数
欠損数は「全行数−Non-Null Count」で考える
Dtypeが想定と違う場合は、実際の値を確認してから変換方法を選ぶ
object型には、文字列だけでなく数字や日付の文字列も含まれる
欠損値を含む整数列がfloat64になる場合がある
info()はデータを修正せず、戻り値はNone
修正後はもう一度info()を実行して結果を検証する

最初にinfo()で全体を診断し、欠損値ならisnull()、型の問題ならto_numeric()・to_datetime()・astype()、分布の確認ならdescribe()へ進みましょう。

次に読みたい関連記事

▲ ページトップへ戻る

df.info()では何が分かりますか？

DataFrameの行数・列数・列名・各列のNon-Null Count・Dtype・型ごとの列数・おおよそのメモリ使用量が分かります。データ読込後の全体診断に向いています。

Non-Null Countとは何ですか？

欠損値ではない値の数です。全5行で4 non-nullなら、欠損値は1件あります。

info()で欠損値の場所まで確認できますか？

できません。info()では列ごとの非欠損数から欠損値の存在を判断できます。欠損数はisnull().sum()、欠損している行は条件抽出で確認します。

数字の列がobject型になるのはなぜですか？

カンマ・通貨記号・空文字・数字以外の文字などが混在している可能性があります。実際の値を確認し、不要な記号を処理してからto_numeric()による変換を検討します。

欠損値があると整数列がfloat64になるのはなぜですか？

今回のように通常のNumPy整数型で作成した列へNaNが含まれると、欠損値を保持するためfloat64になることがあります。欠損値の意味を確認して処理したあと、必要なら整数型へ変換します。

info()とdescribe()の違いは何ですか？

info()はDataFrameの構造・非欠損数・データ型を確認します。describe()は平均・中央値・標準偏差など、値の分布と統計量を確認します。

info()とdtypesの違いは何ですか？

info()は行数・列数・非欠損数・型などをまとめて表示します。dtypesは列ごとのデータ型だけを一覧で返します。

print(df.info())でNoneが表示されるのはなぜですか？

info()は要約情報を画面に表示し、戻り値としてNoneを返すためです。エラーではありません。通常はdf.info()だけを実行します。

info()を実行すると元のDataFrameは変わりますか？

変わりません。info()は確認用のメソッドです。型変換や欠損値処理を行うには、別のメソッドを使います。

The post pandas info()の使い方｜Non-Null Count・データ型・欠損値の見方 first appeared on Python Data Lab（Pythonデータラボ）.

pandas shift()の使い方｜前の行・次の行の値を取得して比較する方法

coin_collector — Sat, 29 Aug 2026 05:51:24 +0000

「今日の売上を、前日の売上と比べたい」「前の行の値を別の列に入れたい」と思っても、行をずらす方向や、先頭にNaNが出る理由が分かりにくいことがあります。

前の行の値を取得する基本形はdf['売上'].shift(1)です。 shift(1)で1行前、shift(2)で2行前、shift(-1)で次の行の値を取得できます。

ただし、shift()が参照するのは「前日」ではなく、現在の並び順における前の行です。日付データでは、先に日付型へ変換して昇順に並べることが重要です。

この記事でわかること

shift()で1行前・2行前・次の行の値を取得する方法
periodsの正負と、値が移動する方向
元の売上と前日売上を比較し、差額や増減率を計算する方法
先頭や末尾にNaNが出る理由
shift()・diff()・pct_change()・rolling()の使い分け
コードは動いても結果を誤解しやすい「並び順」の注意点

shift()は、DataFrameの確認・日付変換・並び替えを終えた後に、時系列データの比較元を作る処理です。差額や増減率を求める前の基礎として位置づけられます。

先に結論：目的に応じて4つの機能を使い分ける

比較元となる値を列に残して確認したい場合はshift()を選びます。求めたい結果が最初から決まっている場合は、専用のメソッドを使うと簡潔です。

機能名	何を求めるか	選ぶ場面	注意点
`shift()`	前後の行の値	比較元の値を列に残したい	行の並び順が基準になる
`diff()`	前の行との差額	増減した量だけを求めたい	最初の比較不能行は`NaN`になる
`pct_change()`	前の行からの増減率	前日比・前月比を求めたい	`0.1`は10%を表す
`rolling()`	一定範囲の集計値	移動平均などで変動をならしたい	`window`分の行をまとめて計算する

この記事では、比較元を作るshift()に焦点を絞ります。差額・増減率・移動平均の詳しい使い方は、それぞれの関連記事で確認できます。

日別売上のサンプルデータを準備する

日付と売上を持つDataFrameを作ります。自分のデータへ置き換えるときも、最初に日付の型と並び順を確認してください。

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

実行結果

	日付	売上
0	2026-08-01	100
1	2026-08-02	120
2	2026-08-03	90
3	2026-08-04	135
4	2026-08-05	150

日付は2026年8月1日から5日までの昇順です。8月2日の1行前は8月1日なので、このサンプルでは「前の行の売上」を「前日売上」として扱えます。

ただし、日付が連続していないデータでは、取得できるのは前日ではなく「前の観測日の値」です。 自分のデータでは、並び順だけでなく日付の欠けも確認してください。

日付変換は「pandas to_datetime()の使い方」、並び替えは「pandas 並び替え（sort）入門」で詳しく解説しています。

shift(1)で1行前の値を取得する

Series.shift(1)を使い、売上列の1行前の値を「前日売上」列へ追加します。shift()のperiodsは省略すると1なので、shift()とshift(1)は同じ結果です。

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

処理前後を比べると、売上の値が1行下へずれています。

日付	売上（処理前）	前日売上（`shift(1)`）
2026-08-01	100	NaN
2026-08-02	120	100
2026-08-03	90	120
2026-08-04	135	90
2026-08-05	150	135

注目するのは8月2日以降の「前日売上」列です。8月2日には8月1日の100、8月3日には8月2日の120が入ります。

8月1日の前にはデータがないため、比較元が存在せずNaNになります。元のDataFrameから行が削除されたわけではなく、shift()がずらした結果を新しい列として返しています。

periodsで2行前・次の行の値を取得する

periodsには、ずらす行数を指定します。正の値では過去側の行、負の値では未来側の行を各行から参照できます。

指定	各行に入る値	値の見かけ上の移動	比較元がない場所
`shift(1)`	1行前の値	1行下へ移動	先頭1行
`shift(2)`	2行前の値	2行下へ移動	先頭2行
`shift(-1)`	次の行の値	1行上へ移動	末尾1行

「正なら上、負なら下」と暗記するより、現在の行から見て、どの行の値が入るかで考えると混乱しにくくなります。

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

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

日付	売上	前日売上	2日前売上	翌日売上
2026-08-01	100	NaN	NaN	120
2026-08-02	120	100	NaN	90
2026-08-03	90	120	100	135
2026-08-04	135	90	120	150
2026-08-05	150	135	90	NaN

8月3日の行を見ると、2日前の売上は8月1日の100、翌日の売上は8月4日の135です。shift(-1)では末尾より後の行が存在しないため、最後の「翌日売上」がNaNになります。

shift(1)は1行前、shift(-1)は次の行です。時系列分析では、過去の値を表す列をラグ（lag）、次の値を表す考え方を**リード（lead）**と呼ぶことがあります。

前日売上と比較して差額・増減率を計算する

比較元の「前日売上」列を残しておくと、計算過程を確認しながら差額や増減率を求められます。

差額：当日売上 - 前日売上
増減率：(当日売上 - 前日売上) / 前日売上

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

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

日付	売上	前日売上	前日差	前日比
2026-08-01	100	NaN	NaN	NaN
2026-08-02	120	100	20	0.20
2026-08-03	90	120	-30	-0.25
2026-08-04	135	90	45	0.50
2026-08-05	150	135	15	約0.1111

8月3日は売上90、前日売上120なので、前日差は-30、前日比は-0.25です。つまり、前日より30減り、25%減少したと読めます。

前日比の0.20は0.20%ではなく**20%**です。表示をパーセントに変える場合も、元の値の意味は変わりません。

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

実行結果

	日付	売上	前日売上	前日差	前日比	前日比（表示用）
0	2026-08-01	100	NaN	NaN	NaN	—
1	2026-08-02	120	100.0	20.0	0.200000	20.0%
2	2026-08-03	90	120.0	-30.0	-0.250000	-25.0%
3	2026-08-04	135	90.0	45.0	0.500000	50.0%
4	2026-08-05	150	135.0	15.0	0.111111	11.1%

表示用の列では、0.20が20.0%、-0.25が-25.0%になります。計算に使う列は数値のまま残し、文字列へ変えた表示用の列とは分けておくと安全です。

差額だけが必要なら「pandas diff()の使い方」、増減率だけが必要なら「pandas pct_change()の使い方」を使うと、同じ計算をより簡潔に書けます。shift()を使う利点は、比較元の値を見ながら結果を検算できることです。

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

条件をそろえて、3つの方法の役割を確認します。shift()は前の値、diff()は差額、pct_change()は増減率を返します。

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

実行結果

	日付	売上	shift_前の値	diff_差額	pct_change_増減率
0	2026-08-01	100	NaN	NaN	NaN
1	2026-08-02	120	100.0	20.0	0.200000
2	2026-08-03	90	120.0	-30.0	-0.250000
3	2026-08-04	135	90.0	45.0	0.500000
4	2026-08-05	150	135.0	15.0	0.111111

8月4日の行では、shift()が比較元の90、diff()が差額の45、pct_change()が増減率の0.50を返します。どれが優れているという関係ではなく、何を結果として残したいかで選びます。

複数日の値をまとめて移動平均を求めたい場合は、前後の1行を参照するshift()ではなく「pandas rolling()の使い方」が適しています。

コードは動くが結果を誤解しやすい例：日付が並んでいない

shift()は、日付の大小ではなく現在の行順を基準にします。次のDataFrameは日付が不規則ですが、コード自体はエラーになりません。

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

日付	売上	前の行の売上
2026-08-03	90	NaN
2026-08-01	100	90
2026-08-02	120	100

症状・原因・確認方法・修正方法

確認項目	内容
症状	8月1日の「前の行」に8月3日の売上`90`が入る
原因	`shift()`の実行前に日付順へ並べていない
確認方法	日付列と行順を表示し、昇順になっているか確認する
修正方法	`sort_values('日付')`を実行してから`shift(1)`を使う

この結果の90を「前日売上」と呼ぶのは誤りです。8月1日の1つ前に並んでいる行が8月3日だから入った値であり、暦上の前日を表していません。

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

実行結果

	日付	売上	前日売上
0	2026-08-01	100	NaN
1	2026-08-02	120	100.0
2	2026-08-03	90	120.0

修正後は、8月2日の前日売上に8月1日の100が入ります。日付が欠けている場合は前日ではなく前の観測行になるため、基本例で確認したとおり日付の連続性にも注意してください。

NaNは無条件に0で埋めない

shift(1)の先頭やshift(-1)の末尾に出るNaNは、比較元の行が存在しないことを表します。これは処理の失敗ではありません。

先頭の前日売上を0で埋めると、「前日の売上は0だった」という別の意味に変わります。その事実を確認できない場合は、NaNのまま残すか、比較計算から除外するのが安全です。

fill_valueを使う場合も値の意味を確認する

shift(1, fill_value=0)のように指定すると、移動によって空いた場所を0で埋められます。ただし、これは実際の前日売上を取得したわけではありません。0に分析上の根拠がある場合だけ使い、単にNaNを消す目的では使わないようにしましょう。

欠損値を何で埋めるかは分析目的によって異なります。「pandas fillna()の使い方」で選択基準を確認してください。

「値をずらす」と「日付をずらす」は同じではない

この記事のdf['売上'].shift(1)は、売上の値を1行ずらし、比較元を作る処理です。日付列の値自体は変わりません。

一方、日付インデックスを持つデータでは、freqを指定してインデックスを時間方向へ移動する使い方もあります。これは行の値を前後比較する今回の目的とは挙動が異なります。初心者のうちは、まずfreqを指定しない基本形で「行をずらす」考え方を身につければ十分です。

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

日別データで前日値を比較するときは、次の順番で進めます。

DataFrameを読み込み、列名・値・データ型を確認する
日付列をto_datetime()で日付型へ変換する
sort_values()で日付の昇順へ並べる
shift()で比較元となる前の行の値を作る
目的に応じて差額・増減率を計算する
表やグラフで変化を確認する

DataFrameの基本は「Pandas DataFrame入門」、列を追加する方法全般は「pandasで新しい列を追加する方法」で確認できます。

自分のデータへ置き換えるときは、日付型・並び順・日付の欠け・比較元が存在しない行の4点を確認してください。

まとめ

前の行の値はshift(1)、2行前はshift(2)、次の行はshift(-1)で取得する
shift(1)では値が1行下へずれ、各行に1行前の値が入る
先頭や末尾のNaNは比較元が存在しないことを示すため、根拠なく0で埋めない
shift()は前後の値、diff()は差額、pct_change()は増減率、rolling()は一定範囲の集計値を求める
shift()が参照するのは前日ではなく、現在の並び順における前の行である
日付データでは、日付型への変換と昇順への並び替えを済ませてから実行する

比較元の値を残して計算過程を確かめたいときにshift()を使えば、前の行との比較を安全に組み立てられます。

▲ ページトップへ戻る

shift(1)とshift(-1)の違いは何ですか？

shift(1)は各行に1行前の値を入れ、先頭がNaNになります。shift(-1)は各行に次の行の値を入れ、末尾がNaNになります。

先頭にNaNが出るのはなぜですか？

shift(1)を実行した先頭行には、比較元となる1行前のデータがないためです。エラーではなく、比較不能であることを示す自然な結果です。

shift()とdiff()の違いは何ですか？

shift()は前の行の値そのものを返し、diff()は現在値と前の行との差額を返します。比較元を確認したいならshift()、差額だけが必要ならdiff()を選びます。

shift()は必ず前日の値を取得しますか？

いいえ。取得するのは現在の並び順における前の行です。前日値として扱うには、日付順に並んでいることに加え、必要に応じて日付の欠けも確認します。

shift()で生じたNaNを0で埋めてもよいですか？

前の行の値が実際に0だったと判断できる場合に限ります。fill_value=0でも同じで、比較元が存在しないという意味を消すため、根拠なく指定しないでください。

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

Seriesに使うと1列の値、DataFrameに使うと対象DataFrame全体がずれます。この記事では比較対象を明確にするため、df['売上'].shift()というSeriesの形を使っています。

日付インデックスを1日ずらす処理と同じですか？

同じではありません。この記事ではfreqを指定せず、値を行単位でずらしています。freqを指定する使い方は日付インデックスを時間方向へ移動するため、別の目的として区別してください。

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

pandas pct_change()の使い方｜前日比・増減率の計算方法

coin_collector — Tue, 25 Aug 2026 01:12:55 +0000

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

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

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

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

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

したがって「前日比」と呼べるのは、日付が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点を確認します。

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

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

CSVなどからDataFrameを読み込む
head()やdtypesで内容を確認する
to_datetime()で日付型へ変換する
sort_values()で日付順に並べる
pct_change()で増減率を計算する
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()」と使い分けましょう。そのうえで、結果が前日比・前営業日比・前月比のどれに当たるかを確認することが大切です。

▲ ページトップへ戻る

pct_change()の0.1は何％ですか？

10％です。pct_change()は割合を返すため、パーセントで読むときは100を掛けます。-0.2なら20％減少です。

最初の行がNaNになるのはなぜですか？

比較する前の行が存在しないためです。エラーではなく、計算に必要な比較元がないことを表しています。

前日比と前月比は計算できますか？

計算できます。ただし、pct_change()は日付ではなく前の行と比較します。日次データを日付順に並べれば前日比、月次データを月順に並べれば前月比として使えます。日付が欠けている場合は、前営業日比などになる点に注意してください。

pct_change()とdiff()の違いは何ですか？

pct_change()は増減率、diff()は増減量を求めます。1,000円から1,100円になった場合、pct_change()は0.1（10％）、diff()は100円です。

比較元が0の場合はどうなりますか？

0で割ることになるため、増加時にはinfが返ることがあります。通常の増減率を定義できない状態なので、0が何を意味するか確認し、別扱いを検討します。

欠損値がある場合はどうなりますか？

fill_method=Noneを指定した場合、現在値または比較元が欠損している行はNaNになります。欠損値を埋める場合は、データ上の意味を確認してから処理してください。

結果をパーセント表示できますか？

結果に100を掛ければパーセント値になります。計算に使う場合は、%記号を付けた文字列ではなく数値のまま保存する方が扱いやすくなります。

前日比が合わないのはなぜですか？

日付の並び順、日付の欠け、重複日付、欠損値、比較元が0でないかを確認してください。pct_change()が比較するのは暦上の前日ではなく、現在の並びで1つ前にある行です。

DataFrameの複数列にも使えますか？

使えます。df[["売上", "客数"]].pct_change(fill_method=None)のように指定すると、売上と客数を列ごとに計算します。最初は、この記事のように1列ずつ結果を確認する方が理解しやすいでしょう。

axisやfreqも覚える必要がありますか？

通常の前日比・前月比では、まず初期設定の行方向だけ理解すれば十分です。列方向を比較するaxisや、日時オフセットを使うfreqは発展的な指定なので、必要になった段階で確認しましょう。

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

pandas diff()の使い方｜前の行との差分・前日からの増減を計算する方法

coin_collector — Sat, 22 Aug 2026 13:33:35 +0000

日別売上を見ながら、「前日よりいくら増えたのか」を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()`	前の行との差（増減量）	前日より何円増えたか	`300`
`pct_change()`	前の行からの変化率	前日より何％増えたか	`0.3`（30%）
`shift()`	前の行の値そのもの	前日の値を別の列に置く	`1000`
`rolling()`	直近数行の平均・合計など	日々の変動をならして傾向を見る	3日移動平均
`resample()`	日・週・月などの期間別集計	日別データを月別にまとめる	月間売上

この記事の中心は、増減「量」を求める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

	日付	売上
0	2026-08-01	1000
1	2026-08-03	1300
2	2026-08-02	1200
3	2026-08-04	1300
4	2026-08-05	1300
5	2026-08-06	1100

このまま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

	日付	売上
0	2026-08-01	1000
1	2026-08-02	1200
2	2026-08-03	1300
3	2026-08-04	1300
4	2026-08-05	1300
5	2026-08-06	1100

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

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

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

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

df["売上"].diff()

	売上
0	NaN
1	200.0
2	100.0
3	0.0
4	0.0
5	-200.0

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

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

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

日付	売上	1つ前の売上	引き算	`diff()`の結果
2026-08-01	1,000	なし	計算できない	`NaN`
2026-08-02	1,200	1,000	1,200 − 1,000	200
2026-08-03	1,300	1,200	1,300 − 1,200	100
2026-08-04	1,300	1,300	1,300 − 1,300	0
2026-08-05	1,300	1,300	1,300 − 1,300	0
2026-08-06	1,100	1,300	1,100 − 1,300	-200

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

結果	意味
正の値	前の行より増加
負の値	前の行より減少
0	前の行から変化なし
`NaN`	比較相手がない、または計算に必要な値が欠けている

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

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

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

df

	日付	売上	前日差
0	2026-08-01	1000	NaN
1	2026-08-02	1200	200.0
2	2026-08-03	1300	100.0
3	2026-08-04	1300	0.0
4	2026-08-05	1300	0.0
5	2026-08-06	1100	-200.0

これで元の売上と前日差を横に並べて確認できます。先頭行の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行前との差"]]

	日付	売上	1行前との差	2行前との差
0	2026-08-01	1000	NaN	NaN
1	2026-08-02	1200	200.0	NaN
2	2026-08-03	1300	100.0	300.0
3	2026-08-04	1300	0.0	100.0
4	2026-08-05	1300	0.0	0.0
5	2026-08-06	1100	-200.0	-200.0

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

設定	計算	最初に計算できる行
`periods=1`	現在行 − 1行前	2行目
`periods=2`	現在行 − 2行前	3行目

たとえば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)
)

	日付	売上	次の行との差
0	2026-08-01	1000	-200.0
1	2026-08-02	1200	-100.0
2	2026-08-03	1300	0.0
3	2026-08-04	1300	0.0
4	2026-08-05	1300	200.0
5	2026-08-06	1100	NaN

並び順が違うと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(変更後)

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

	日付	売上	行間差
0	2026-08-01	1000	NaN
1	2026-08-03	1300	300.0
2	2026-08-02	1200	-100.0
3	2026-08-04	1300	100.0

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

	日付	売上	前日差
0	2026-08-01	1000	NaN
1	2026-08-02	1200	200.0
2	2026-08-03	1300	100.0
3	2026-08-04	1300	0.0

変更前では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

	日付	売上	前の行との差
0	2026-08-01	1000	NaN
1	2026-08-03	1300	300.0
2	2026-08-04	1200	-100.0

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

	日付	売上	前日差
0	2026-08-01	1000.0	NaN
1	2026-08-02	1200.0	200.0
2	2026-08-03	NaN	NaN
3	2026-08-04	1500.0	NaN
4	2026-08-05	1600.0	100.0

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

	日付	売上	前の行の値_shift	増減量_diff	増減率_pct_change	3行移動平均_rolling
0	2026-08-01	1000	NaN	NaN	NaN	NaN
1	2026-08-02	1200	1000.0	200.0	0.200000	NaN
2	2026-08-03	1300	1200.0	100.0	0.083333	1166.666667
3	2026-08-04	1300	1300.0	0.0	0.000000	1266.666667
4	2026-08-05	1300	1300.0	0.0	0.000000	1300.000000
5	2026-08-06	1100	1300.0	-200.0	-0.153846	1233.333333

たとえば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)

	4月売上	5月売上
商品A	NaN	200
商品B	NaN	-100

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

商品	4月売上	5月売上	5月 − 4月
商品A	1,000	1,200	200
商品B	1,500	1,400	-100

ただし、時系列データの前日差を求める目的なら、対象の売上列に行方向の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()は、読み込んだデータを確認・整形したあとに、変化を表す列を作る処理として使えます。

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

このように、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.diffも参考になります。

▲ ページトップへ戻る

pandasで前の行との差を求めるにはどうすればよいですか？

対象のSeriesにdiff()を使います。売上列ならdf["売上"].diff()で、現在行から1つ前の行を引いた差分を求められます。

diff()の先頭行がNaNになるのはなぜですか？

先頭行には比較する1つ前の行がないためです。計算エラーではなく、正常な結果です。

diff()で前日差や前日比率を計算できますか？

日付が1日刻みで連続し、日付順に並んでいれば、diff()で前日からの増減量（前日差）を計算できます。割合としての前日比率にはpct_change()を使います。

diff()のperiods=2は何を意味しますか？

現在行と2行前の値との差を意味します。日付が連続している場合は2日前と一致しますが、日付に欠けがあれば2日前とは限りません。

diff()とshift()の違いは何ですか？

diff()は前の行との引き算を行い、増減量を返します。shift()は値を指定行数だけずらし、前の行の値そのものを返します。

日付が連続していなくても前日差になりますか？

なりません。diff()が比較するのは基本的に1つ前の行です。前日の行が存在しなければ、結果は前回観測値との差になります。

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

pandas rolling()の使い方｜移動平均・window・NaNを初心者向けに解説

coin_collector — Wed, 19 Aug 2026 13:21:30 +0000

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

このようなときに使えるのが、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()の違い

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

方法	目的	計算対象	行数の変化	使用場面	代表的な書き方
`rolling()`	直近の値をならす・合計する	現在行を含む直近n行	原則として元と同じ	3日移動平均、直近7件の平均	`s.rolling(3).mean()`
`resample()`	時間単位を変えて再集計する	日・週・月などの期間	通常は変わる	日別データを月別合計にする	`df.resample("MS").sum()`
通常の`mean()`	列全体の平均を1つ求める	列全体	1つの値になる	全期間の平均売上を知る	`s.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

	日付	売上
0	2026-08-01	100
1	2026-08-02	160
2	2026-08-03	120
3	2026-08-04	190
4	2026-08-05	150
5	2026-08-06	220
6	2026-08-07	180
7	2026-08-08	250
8	2026-08-09	210
9	2026-08-10	280
10	2026-08-11	230
11	2026-08-12	310
12	2026-08-13	270
13	2026-08-14	340

自分の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]
売上	int64

日付が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日移動平均"]]

	日付	売上	3日移動平均
0	2026-08-01	100	NaN
1	2026-08-02	160	NaN
2	2026-08-03	120	126.67
3	2026-08-04	190	156.67
4	2026-08-05	150	153.33
5	2026-08-06	220	186.67
6	2026-08-07	180	183.33
7	2026-08-08	250	216.67
8	2026-08-09	210	213.33
9	2026-08-10	280	246.67
10	2026-08-11	230	240.0
11	2026-08-12	310	273.33
12	2026-08-13	270	270.0
13	2026-08-14	340	306.67

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

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

日付	元の売上	平均対象となる値	3日移動平均
2026-08-01	100	3行未満	NaN
2026-08-02	160	3行未満	NaN
2026-08-03	120	100・160・120	126.67
2026-08-04	190	160・120・190	156.67
2026-08-05	150	120・190・150	153.33

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)

	日付	売上	3日移動平均	3日移動平均_min1
0	2026-08-01	100	NaN	100.0
1	2026-08-02	160	NaN	130.0
2	2026-08-03	120	126.67	126.67
3	2026-08-04	190	156.67	156.67
4	2026-08-05	150	153.33	153.33

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

日付	利用できる値の数	初期設定の結果	min_periods=1	比較時の注意点
2026-08-01	1	NaN	100.00	1個だけの平均
2026-08-02	2	NaN	130.00	2個の平均
2026-08-03	3	126.67	126.67	3個の平均

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

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

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

指定	3行の計算結果を置く位置	向いている場面
`center=False`（初期設定）	3行目（末尾）	現在までの値から傾向を確認する
`center=True`	2行目（中央）	前後の値を使って中央時点をならす

同じ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)

	日付	売上	center=False	center=True
0	2026-08-01	100	NaN	NaN
1	2026-08-02	160	NaN	126.67
2	2026-08-03	120	126.67	156.67
3	2026-08-04	190	156.67	153.33
4	2026-08-05	150	153.33	186.67
5	2026-08-06	220	186.67	183.33

たとえば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日移動平均"]]

	日付	売上	3日移動平均	7日移動平均
0	2026-08-01	100	NaN	NaN
1	2026-08-02	160	NaN	NaN
2	2026-08-03	120	126.67	NaN
3	2026-08-04	190	156.67	NaN
4	2026-08-05	150	153.33	NaN
5	2026-08-06	220	186.67	NaN
6	2026-08-07	180	183.33	160.0
7	2026-08-08	250	216.67	181.43
8	2026-08-09	210	213.33	188.57
9	2026-08-10	280	246.67	211.43
10	2026-08-11	230	240.0	217.14
11	2026-08-12	310	273.33	240.0
12	2026-08-13	270	270.0	247.14
13	2026-08-14	340	306.67	270.0

比較項目	window=3	window=7
使うデータ数	直近3行	直近7行
滑らかさ	小さい	大きい
急な変化への反応	比較的速い	比較的遅い
向いている目的	短期的な動きの確認	やや長い傾向の確認
先頭のNaN	2行	6行

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

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

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

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

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

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

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

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

	日付	売上	3日移動平均	直近3日売上合計
0	2026-08-01	100	NaN	NaN
1	2026-08-02	160	NaN	NaN
2	2026-08-03	120	126.67	380.0
3	2026-08-04	190	156.67	470.0
4	2026-08-05	150	153.33	460.0
5	2026-08-06	220	186.67	560.0
6	2026-08-07	180	183.33	550.0

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

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

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

メソッド	求める値	使用例
`mean()`	平均	売上の短期変動をならす
`sum()`	合計	直近3日分の売上合計を求める
`min()`	最小値	直近期間の最低売上を確認する
`max()`	最大値	直近期間の最高売上を確認する
`median()`	中央値	極端な値の影響を抑えて中心を見る
`std()`	標準偏差	直近期間のばらつきを確認する
`count()`	有効値の個数	window内のデータ数を確認する

初心者は、まず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日移動平均の比較

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

	売上	直近3行平均	直近3日平均
2026-08-01	100.0	NaN	100.0
2026-08-02	160.0	NaN	130.0
2026-08-05	120.0	126.67	120.0
2026-08-06	190.0	156.67	155.0

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

書き方	windowの基準	欠損日がある場合
`rolling(3)`	行数	日付が離れていても直近3行を使う
`rolling("3D")`	実際の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へ変えたときに結果がどのように変化するか確認してみてください。

次に読みたい関連記事

▲ ページトップへ戻る

pandasのrolling()は何をするメソッドですか？

現在行を含む直近の複数行を対象に、平均・合計などを繰り返し計算するメソッドです。日別売上の短期的な変動をならし、傾向を見やすくする場面などで使います。

rolling(3)の3は3日という意味ですか？

基本的には3行という意味です。データが1日1行で日付も連続している場合に限り、3日移動平均として読めます。実際の期間を基準にする方法にはrolling("3D")などがありますが、日付インデックスなどの前提が必要です。

rolling()の結果で最初の行がNaNになるのはなぜですか？

windowで指定した数の有効な値がまだそろっていないためです。window=3の初期設定では、最初の2行がNaNになり、3行目から結果が出ます。

min_periods=1を指定すればNaNを消してもよいですか？

目的によります。先頭から値を表示できますが、最初は1個、次は2個、その後は3個の平均となり、計算条件がそろいません。元データに欠損値がある場合も、有効値の数がmin_periods以上かで結果が決まるため、NaNを消す前に利用件数を確認してください。

rolling()とresample()は何が違いますか？

rolling()は直近数行をずらしながら計算し、原則として元の行数を保ちます。resample()は日別を月別にするように時間単位を変えて再集計するため、通常は行数も変わります。1日ごとの行を残すか、期間ごとにまとめるかで判断してください。

center=Trueはどんなときに使いますか？

計算結果をwindowの中央に置きたいときに使います。過去から現在までの傾向を見る通常の移動平均では初期設定のまま、前後の値で中央時点をならしたい場合はcenter=Trueが候補です。

DataFrame全体にrolling()を使えますか？

使えます。複数の数値列を持つDataFrameに適用すると、各数値列へ同じwindowの計算が行われます。ただし、初心者は分析対象の列を選んでから適用すると、結果を理解しやすくなります。

expanding()やewm()とは何が違いますか？

expanding()は開始点から現在行まで計算範囲を広げます。ewm()は一般に新しい値へ大きな重みを付けて計算します。まずは一定数の直近行を扱うrolling()から覚えると分かりやすいでしょう。

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

coin_collector | Python Data Lab（Pythonデータラボ）

pandas drop()の使い方｜行・列を削除するindex・columns・axisを初心者向けに解説

この記事でわかること

先に結論：行はindex、列はcolumnsで削除する

pandas drop()とは

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

drop()で行を削除する

indexラベルを指定して1行削除する

複数行をリストでまとめて削除する

行ラベルと行番号の違い

drop()で列を削除する

columnsで1列削除する

複数列をリストでまとめて削除する

列番号で指定するときはdf.columnsを使う

行と列を同時に削除する

axis=0とaxis=1の違い

条件に合う行を削除する

処理前後表で確認する

drop()が反映されない原因

戻り値を変数へ代入する

inplace=Trueの動作と注意点

KeyErrorが出る原因と対処法

KeyErrorの確認表

errors=”ignore”を使ってよい場面

行削除後のindexを振り直す

drop()・dropna()・drop_duplicates()の違い

よくあるミス

実務例：分析に不要な列と取消データを除く

まとめ

次に読みたい関連記事

公式ドキュメント

カテゴリから探す

pandasのdrop()で行を削除するにはどう書きますか？

pandasのdrop()で列を削除するにはどう書きますか？

axis=0とaxis=1の違いは何ですか？

drop()を実行しても元のDataFrameに反映されないのはなぜですか？

drop()・dropna()・drop_duplicates()はどう使い分けますか？

pandas drop_duplicates()の使い方｜subset・keepで重複行を削除

この記事でわかること

先に結論：判定列と残す行を決めてから削除する

注文データを用意して処理前の状態を確認する

実行目的

削除前にduplicated()で重複候補をすべて確認する

実行目的

引数なしでは全列が同じ行だけを削除する

実行目的

subsetで重複を判定する列を選ぶ

実行目的

複数列の組み合わせで重複を判定する

keepで残す行を選ぶ

実行目的

最新の行を残すなら更新日時で並べてからkeep=’last’を使う

実行目的

削除後は行数・残った値・重複件数を検算する

実行目的

よくある失敗を現象から確認・修正する

重複が消えない

必要な行まで消えた

最新ではない行が残った

元のDataFrameへ反映されない

NaNを含む判定列は削除前に意味を確認する

自分のDataFrameへ置き換える前のチェックリスト

重複を削除したデータを集計へつなげる

実行目的

まとめ

関連記事

カテゴリから探す

drop_duplicates()とduplicated()の違いは何ですか？

複数列が同じ行だけを削除するにはどうしますか？

最新の行だけを残すにはどうしますか？

実行しても元のDataFrameが変わらないのはなぜですか？

NaNを含む行はどう判定されますか？

pandas to_csv()の使い方｜indexなし・文字化け対策・保存先を解説

この記事でわかること

先に結論：保存先→index→文字コード→列→上書きの順に決める

売上DataFrameを用意する

実行目的

基本：indexなしでCSVへ保存する

実行目的

index=Trueとindex=Falseの違い