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

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

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

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

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

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

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

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

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

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

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

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

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)

temporary_result = df.drop(index=101)

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

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

df = df.drop(index=101)

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

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

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

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

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

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

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

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

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

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 確定

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

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)

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

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())

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

exact_clean = orders.drop_duplicates()

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

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

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

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だけで判定した結果

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

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)

print("更新日時のdtype:", orders["更新日時"].dtype)
print("更新日時の欠損数:", orders["更新日時"].isna().sum())

orders_sorted = orders.sort_values(["注文ID", "更新日時"])
latest_orders = orders_sorted.drop_duplicates(
    subset="注文ID",
    keep="last",
    ignore_index=True
)

display(latest_orders)

更新日時のdtype: datetime64[ns]
更新日時の欠損数: 0

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)

行数の式が一致: True

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

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

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())

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

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

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)

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

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)

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

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

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']])

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

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

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

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

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

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

この記事でわかること

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

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

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

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

今回の目的は「セル内の複数回答を、回答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

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

explode()を実行する

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

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

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

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

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

ignore_index=Trueで連番にする

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

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

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

すでに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

行数は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

修正後は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

結果は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", "テーマ数", "習熟度数"]]

回答者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

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

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

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

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

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

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

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

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

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

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

theme_counts

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

まとめ

• セル内のリストを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 棒グラフ入門：集計した件数をグラフで比較したい場合

▲ ページトップへ戻る

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

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

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

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

目次

1. この記事でわかること
2. Pandas DataFrame入門シリーズでの位置づけ
3. 見えない空白が抽出・集計を狂わせる
4. str.strip()で文字列の前後空白を削除する
5. str.strip()・str.lstrip()・str.rstrip()の違い
   1. strip(chars)は指定した語句を丸ごと削除する機能ではない
   2. 補足：文字以外の値が混ざる列に注意する
6. 列名の前後空白はdf.columns.str.strip()で削除する
7. strip・replace・renameは目的で使い分ける
8. よくあるミスと注意点
   1. 1. 結果を代入せず、元の列も変わったと思う
   2. 2. 文字列の途中にある空白まで消えると思う
   3. 3. NaNと空文字列を同じものとして扱う
   4. 4. 混在列を安易にastype(str)へ変換する
   5. 5. 全角スペースを見落とす
9. 前処理の流れでstr.strip()を使うタイミング
10. まとめ
11. 次に読みたい関連記事
    1. カテゴリから探す
    2. str.strip()は半角スペースと全角スペースの両方を削除できますか？
    3. str.strip()とstr.replace()はどう使い分けますか？
    4. 文字列の途中にある空白も削除できますか？
    5. 列名の前後空白をまとめて削除できますか？
    6. str.strip()を使ったのに元のDataFrameが変わらないのはなぜですか？
    7. 空白を削除したら別々だったカテゴリは同じ値として集計されますか？

この記事でわかること

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

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

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

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

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

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

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

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

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

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

import pandas as pd
import numpy as np

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

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

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

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

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

空白除去前の件数:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

空白除去後の件数:

	count
東京	4
大阪	1
nan	1

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 Python

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

よくあるミスと注意点

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

まとめ

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

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

次に読みたい関連記事

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

カテゴリから探す

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

▲ ページトップへ戻る

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

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

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

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

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

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

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

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

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

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

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

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

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

]]> https://pythondatalab.com/pandas-str-strip/feed/ 0 https://pythondatalab.com/pandas-read-excel/ https://pythondatalab.com/pandas-read-excel/#respond Sat, 09 May 2026 15:41:55 +0000 https://pythondatalab.com/?p=2201 Excelファイルをpandasで読み込めても、タイトル行が列名になったり、違うシートや不要な列まで入ったりすると、その後の集計で迷います。 この記事では、Excelの構造を確認してから sheet_name・heade […]

<p>The post pandas read_excel()の使い方｜Excel読み込み・sheet_name・header・usecolsを初心者向けに解説 first appeared on Python Data Lab（Pythonデータラボ）.</p>

]]>

Excelファイルをpandasで読み込めても、タイトル行が列名になったり、違うシートや不要な列まで入ったりすると、その後の集計で迷います。

この記事では、Excelの構造を確認してから sheet_name・header・usecols を選び、読み込み後にDataFrameを検算する流れを解説します。Google Colabで上から順に実行できます。

目次

1. この記事でわかること
2. 先に結論：Excelを見てから3つの指定を選ぶ
3. 実行前：タイトル行と注記を含むExcelを用意する
4. 基本：まずは1シートを読み込む
5. sheet_name・skiprows・usecolsを指定して正しく読む
6. headerとskiprowsはどう選ぶ？
7. 複数シートを読むと戻り値が変わる
8. よくある失敗：現象から直す場所を決める
   1. FileNotFoundErrorを確認する
   2. 型が想定と違うときは、読み込み後に必要な列だけ整える
9. 読み込み後は前処理・集計へ進む
10. まとめ
11. 関連記事
    1. カテゴリから探す
    2. read_excel()で特定シートを読むには？
    3. 複数シートを読むとDataFrameではないのはなぜですか？
    4. タイトル行を飛ばすには？
    5. 数値が文字列として読み込まれたらどうしますか？
    6. Google ColabでFileNotFoundErrorになるのはなぜですか？

この記事でわかること

• pd.read_excel()でExcelをDataFrameへ読み込む基本
• 読みたいシート、見出し行、必要な列の選び方
• columns・head()・info()で正しく読めたか確認する方法
• ファイルが見つからない、列名が想定と違う、型が合わないときの確認方法

この処理は、データ分析の「入力・確認」の工程です。読み込み後は、欠損値や型を整えてから集計・可視化へ進みます。

先に結論：Excelを見てから3つの指定を選ぶ

Excelで確認すること	指定するもの	選ぶ場面	最初に確認する結果
読みたい表はどのシートか	sheet_name	1枚目以外のシートを読む	選んだシートの列名
見出しは何行目か	header または skiprows	タイトル・注記が表の上にある	列名と先頭データ
どの列を分析するか	usecols	不要列を読まない	必要な列だけか

まずは指定を増やしすぎずに読み込み、df.columns、df.head()、df.info()で検算します。読み込みが成功しただけでは、分析に使える状態とは限りません。

import os 
import pandas as pd

実行前：タイトル行と注記を含むExcelを用意する

ここでは再現用に、2つのシートを持つExcelを作ります。売上シートにはタイトル行、注記行、空行の後に見出し行があります。

実際のExcelでも、最初にこのような構造を確認してください。タイトルや注記をそのまま読んでしまうと、列名・型・集計結果がずれます。

source_sales = pd.DataFrame({
    "日付": ["2026-04-01", "2026-04-01", "2026-04-02", "2026-04-02"],
    "商品": ["ノート", "ペン", "ノート", "ペン"],
    "売上": [1200, 300, 1500, 450],
    "担当者": ["青木", "井上", "青木", "井上"],
    "社内メモ": ["通常", "通常", "確認済み", "通常"]
})

file_path = "sales_report.xlsx"
with pd.ExcelWriter(file_path, engine="openpyxl") as writer:
    source_sales.to_excel(writer, sheet_name="売上", index=False, startrow=3)
    pd.DataFrame({"月": ["4月"], "目標売上": [5000]}).to_excel(
        writer, sheet_name="集計用", index=False
    )

from openpyxl import load_workbook
book = load_workbook(file_path)
sheet = book["売上"]
sheet["A1"] = "2026年4月 売上レポート"
sheet["A2"] = "注記：金額は税込み"
book.save(file_path)

print(os.listdir())

['.config', 'sales_report.xlsx', 'sample_data']

処理前の 売上 シートは、1行目がタイトル、2行目が注記、4行目が列名です。したがって、タイトルと注記を飛ばして4行目を列名として読む必要があります。

基本：まずは1シートを読み込む

pd.read_excel()の最小形は、Excelファイルのパスを渡すだけです。複数シートがある場合、指定しなければ先頭のシートを読み込みます。

ただし今回は先頭シートでもタイトル行があるため、このままでは列名が正しくなりません。次のセルであえて確認します。

df_without_options = pd.read_excel(file_path)
display(df_without_options.head())
print("列名:", df_without_options.columns.tolist())

	2026年4月 売上レポート	Unnamed: 1	Unnamed: 2	Unnamed: 3	Unnamed: 4
0	注記：金額は税込み	NaN	NaN	NaN	NaN
1	NaN	NaN	NaN	NaN	NaN
2	日付	商品	売上	担当者	社内メモ
3	2026-04-01	ノート	1200	青木	通常
4	2026-04-01	ペン	300	井上	通常

列名: ['2026年4月 売上レポート', 'Unnamed: 1', 'Unnamed: 2', 'Unnamed: 3', 'Unnamed: 4']

この結果ではタイトルが列名になり、正しい表ではありません。コードは動いていても、出力を見なければ誤りに気付けません。

sheet_name・skiprows・usecolsを指定して正しく読む

• sheet_name="売上"：分析したいシートを名前で選びます。
• skiprows=3：タイトル・注記・空行を飛ばし、次の行を列名として使います。
• usecols="A:D"：分析に必要な4列だけを読みます。社内メモはこの分析では使いません。

df = pd.read_excel(
    file_path,
    sheet_name="売上",
    skiprows=3,
    usecols="A:D"
)

display(df)
print("列名:", df.columns.tolist())
print("行数:", len(df))
df.info()

	日付	商品	売上	担当者
0	2026-04-01	ノート	1200	青木
1	2026-04-01	ペン	300	井上
2	2026-04-02	ノート	1500	青木
3	2026-04-02	ペン	450	井上

列名: ['日付', '商品', '売上', '担当者']
行数: 4
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 4 entries, 0 to 3
Data columns (total 4 columns):
 #   Column  Non-Null Count  Dtype 
---  ------  --------------  ----- 
 0   日付      4 non-null      object
 1   商品      4 non-null      object
 2   売上      4 non-null      int64 
 3   担当者     4 non-null      object
dtypes: int64(1), object(3)
memory usage: 260.0+ bytes

出力では、列名が 日付・商品・売上・担当者 になり、4行の売上データだけが読めています。売上が整数型、日付が文字列型であることも info() で確認します。

日付を月別に集計する前には、日付をdatetime型へ変換する必要があります。読み込み直後に型を確認する理由は、見た目が日付や数値でもDataFrame内の型が違う場合があるためです。

headerとskiprowsはどう選ぶ？

見出し行より前を丸ごと飛ばすなら skiprows が分かりやすい選択です。Excelの0始まりの行番号で見出し行を直接指定するなら header を使えます。今回の見出しはExcelの4行目なので、header=3 でも同じ結果になります。

Excelの状態	選択	注意点
見出しより上にタイトル・注記がある	skiprows	飛ばした直後の行が列名になるか確認する
見出しが何行目か明確	header	行番号は0始まり
Excelに見出しがない	header=None と names	列名は自分で与える

df_with_header = pd.read_excel(
    file_path, sheet_name="売上", header=3, usecols="A:D"
)

print("skiprowsで読んだ列名:", df.columns.tolist())
print("headerで読んだ列名:  ", df_with_header.columns.tolist())
print("同じ内容か:         ", df.equals(df_with_header))

skiprowsで読んだ列名: ['日付', '商品', '売上', '担当者']
headerで読んだ列名:   ['日付', '商品', '売上', '担当者']
同じ内容か:          True

header と skiprows を同時に何となく増やすと、見出し行まで飛ばしてしまうことがあります。列名が Unnamed: 0 になったり、商品名が列名になったりしたら、まず header=None で数行を表示し、見出しの実際の位置を確認してから指定を直してください。

複数シートを読むと戻り値が変わる

sheet_name にリストまたは None を渡すと、戻り値はDataFrameではなく「シート名をキー、DataFrameを値にする辞書」です。1つの表として head() を呼べると思い込まないことが大切です。

sheets = pd.read_excel(file_path, sheet_name=["売上", "集計用"])
print(type(sheets))
print("読み込んだシート:", list(sheets.keys()))
display(sheets["集計用"])

<class 'dict'>
読み込んだシート: ['売上', '集計用']

	月	目標売上
0	4月	5000

複数シートを毎回処理する必要がないなら、初心者はまず必要な1シートだけを指定する方が、確認する対象を絞れて安全です。

よくある失敗：現象から直す場所を決める

現象	主な原因	確認方法	修正方針
FileNotFoundError	パス・名前・拡張子が違う	os.listdir()でファイル名を見る	アップロード先と file_path を一致させる
列名が想定と違う	タイトル行や注記行を読んだ	header=None で先頭行を見る	skiprows または header を調整する
必要な列がない	usecols がExcelの列と合わない	df.columns.tolist()を確認する	実際の列名・列記号に合わせる
数値や日付が文字列	Excelのセル形式・値が混在	df.info()でdtypeを見る	必要な列だけ型を整える

FileNotFoundErrorを確認する

Colabへ自分のExcelをアップロードした場合、保存されたファイル名を確認してから file_path に設定します。次のセルを実行し、一覧にある名前をそのまま使ってください。

# 自分のExcelをColabへアップロードする場合だけ、先頭の # を外して実行します。
# from google.colab import files
# uploaded = files.upload()

print("現在のExcelファイル:")
print([name for name in os.listdir() if name.lower().endswith((".xlsx", ".xls"))])

現在のExcelファイル:
['sales_report.xlsx']

型が想定と違うときは、読み込み後に必要な列だけ整える

今回の 日付 は文字列として読み込まれています。読み込み設定の誤りではなく、次の前処理で扱う問題です。列全体を無条件に変換せず、変換後に欠損が増えていないか確認します。

df_checked = df.copy()
df_checked["日付"] = pd.to_datetime(df_checked["日付"], errors="coerce")

display(df_checked)
print("日付の欠損数:", df_checked["日付"].isna().sum())
print("日付列の型:", df_checked["日付"].dtype)

	日付	商品	売上	担当者
0	2026-04-01	ノート	1200	青木
1	2026-04-01	ペン	300	井上
2	2026-04-02	ノート	1500	青木
3	2026-04-02	ペン	450	井上

日付の欠損数: 0
日付列の型: datetime64[ns]

変換後の 日付 列が datetime64[ns] になり、欠損数が0なら、月別集計や時系列グラフの準備ができています。errors="coerce" を使うと変換できない値は NaT になるため、必ず欠損数を確認してください。

読み込み後は前処理・集計へ進む

Excelを正しく読み込んだ後は、次の順番で進むと安全です。

1. info()で列・型・欠損値を確認する
2. 列名や文字列の前後空白を整える
3. 数値・日付を必要な型に変換する
4. groupby()で商品別や担当者別に集計する

たとえば今回なら、日付を変換した後に商品別の売上を集計できます。未確認の列や型のまま集計へ進まないことが大切です。

sales_by_product = (
    df_checked.groupby("商品", as_index=False)["売上"]
    .sum()
    .sort_values("売上", ascending=False)
)
display(sales_by_product)

	商品	売上
0	ノート	2700
1	ペン	750

まとめ

• read_excel()の前に、対象シート・見出し行・必要列をExcelで確認する
• 特定シートは sheet_name、表の上のタイトルや注記は skiprows または header、必要列だけなら usecols を使う
• 読み込み後は columns・head()・info()で、列名・データ・型を必ず検算する
• 読み込み成功と分析可能は別であり、型や欠損を確認してから前処理・集計へ進む

関連記事

• Google ColabでCSVを読み込む方法：Colabで自分のファイルを読み込む手順
• pandas info()の使い方：読み込み後に列・型・欠損値を確認する
• pandas str.strip()の使い方：列名や文字列の前後空白を削除する
• pandas to_numeric()の使い方：文字列の数字を数値へ変換する
• Pandasデータ前処理の基本：読み込み後に確認する順番と処理の選び方

カテゴリから探す

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

▲ ページトップへ戻る

read_excel()で特定シートを読むには？

sheet_name="売上" のようにシート名を指定します。番号で指定する場合は0始まりです。

複数シートを読むとDataFrameではないのはなぜですか？

sheet_nameにリストやNoneを指定すると、シートごとのDataFrameをまとめた辞書が返ります。sheets["売上"]のように取り出します。

タイトル行を飛ばすには？

見出しの前にある行数をskiprowsに指定します。先にheader=Noneで先頭数行を確認すると、飛ばす行数を判断しやすくなります。

数値が文字列として読み込まれたらどうしますか？

まずinfo()で対象列の型を確認します。その後、必要な列だけpd.to_numeric(..., errors="coerce")で変換し、変換できなかった値が欠損になっていないか確認します。

Google ColabでFileNotFoundErrorになるのはなぜですか？

Colabにアップロードしたファイル名とfile_pathが一致していないことが多い原因です。os.listdir()で実際のファイル名を確認してください。

<p>The post pandas read_excel()の使い方｜Excel読み込み・sheet_name・header・usecolsを初心者向けに解説 first appeared on Python Data Lab（Pythonデータラボ）.</p>

]]> https://pythondatalab.com/pandas-read-excel/feed/ 0 https://pythondatalab.com/pandas-between/ https://pythondatalab.com/pandas-between/#respond Sat, 09 May 2026 15:40:35 +0000 https://pythondatalab.com/?p=2068 pandasのbetween()で数値や日付を範囲抽出する方法を初心者向けに解説。判定から行抽出までの流れ、inclusive、欠損値、query()やcut()との違いも整理します。

パーマリンク案

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

]]>

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

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

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

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

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

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

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

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

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

目次

1. この記事でわかること
2. やりたいこと別：between()を使う場面
3. サンプルデータを用意する
4. 数値を範囲で抽出する方法
   1. まずbetween()で範囲内かどうかを判定する
   2. 判定結果を使って行を抽出する
5. 日付を範囲で抽出する方法
6. inclusiveで数値や日付の範囲の境界値を含める・含めない設定
7. 範囲抽出で欠損値があるときの注意点
8. between()と>=・<=・query()・cut()の違い
   1. query()で書く場合
   2. cut()は抽出ではなく分類に使う
   3. between()を使わない場面も確認しておく
9. 抽出したデータを集計して確認する
   1. 必要に応じてグラフで確認する
10. よくあるミスと確認ポイント
11. between()は前処理・抽出で使う
12. まとめ：between()は数値・日付の範囲抽出を読みやすくする方法
13. 次に読みたい関連記事
    1. カテゴリから探す
    2. pandasのbetween()は何をするメソッドですか？
    3. between()は境界値を含みますか？
    4. between()で日付の範囲抽出はできますか？
    5. between()と>=・<=は何が違いますか？
    6. between()とquery()はどちらを使えばよいですか？
    7. between()とcut()は何が違いますか？
    8. 範囲抽出で欠損値があるとき、between()はどうなりますか？
    9. 文字列の数字にbetween()を使ってもよいですか？

この記事でわかること

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

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

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

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

やりたいこと	使う方法	例
数値を範囲で抽出したい	between()	売上1000円〜5000円
日付を範囲で抽出したい	between()	2026年1月の注文
同じ範囲抽出を別の書き方で書きたい	比較演算子・query()	>=・<= や query()
範囲で抽出ではなく、区間に分けたい	cut()	売上を低価格・中価格・高価格に分類

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

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

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

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

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

import pandas as pd

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

df = pd.DataFrame(data)
df

	注文日	商品	カテゴリ	売上
0	2026-01-03	ノートPC	PC	120000.0
1	2026-01-08	マウス	周辺機器	1000.0
2	2026-01-15	キーボード	周辺機器	4800.0
3	2026-01-28	USBメモリ	周辺機器	980.0
4	2026-02-04	モニター	PC	5000.0
5	2026-02-12	Webカメラ	周辺機器	NaN
6	日付不明	ケーブル	周辺機器	3200.0

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

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

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

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

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

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

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

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

	売上
0	False
1	True
2	True
3	False
4	True
5	False
6	True

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

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

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

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

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

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

	注文日	商品	カテゴリ	売上
1	2026-01-08	マウス	周辺機器	1000.0
2	2026-01-15	キーボード	周辺機器	4800.0
4	2026-02-04	モニター	PC	5000.0
6	日付不明	ケーブル	周辺機器	3200.0

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

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

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

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

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

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

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

	注文日	商品	カテゴリ	売上
0	2026-01-03	ノートPC	PC	120000.0
1	2026-01-08	マウス	周辺機器	1000.0
2	2026-01-15	キーボード	周辺機器	4800.0
3	2026-01-28	USBメモリ	周辺機器	980.0
4	2026-02-04	モニター	PC	5000.0
5	2026-02-12	Webカメラ	周辺機器	NaN
6	NaT	ケーブル	周辺機器	3200.0

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

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

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

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

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

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

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

	注文日	商品	カテゴリ	売上
0	2026-01-03	ノートPC	PC	120000.0
1	2026-01-08	マウス	周辺機器	1000.0
2	2026-01-15	キーボード	周辺機器	4800.0
3	2026-01-28	USBメモリ	周辺機器	980.0

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

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

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

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

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

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

	注文日	商品	売上
0	2026-01-03	ノートPC	120000.0
1	2026-01-08	マウス	1000.0
2	2026-01-15	キーボード	4800.0
3	2026-01-28	USBメモリ	980.0

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

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

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

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

書き方	意味	境界値1000	境界値5000
inclusive="both"	両端を含む	含む	含む
inclusive="left"	左だけ含む	含む	含まない
inclusive="right"	右だけ含む	含まない	含む
inclusive="neither"	両端を含まない	含まない	含まない

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

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

	注文日	商品	カテゴリ	売上
1	2026-01-08	マウス	周辺機器	1000.0
2	2026-01-15	キーボード	周辺機器	4800.0
4	2026-02-04	モニター	PC	5000.0
6	NaT	ケーブル	周辺機器	3200.0

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

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

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

	注文日	商品	カテゴリ	売上
2	2026-01-15	キーボード	周辺機器	4800.0
6	NaT	ケーブル	周辺機器	3200.0

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

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

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

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

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

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

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

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

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

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

	商品	売上	範囲内
0	ノートPC	120000.0	False
1	マウス	1000.0	True
2	キーボード	4800.0	True
3	USBメモリ	980.0	False
4	モニター	5000.0	True
5	Webカメラ	NaN	False
6	ケーブル	3200.0	True

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

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

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

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

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

比較対象	使う場面	between()との違い
>=・<=	同じ範囲抽出を比較演算子で書きたい	between()のほうが範囲抽出の意図が読みやすい
query()	同じ範囲抽出を文字列の条件式で書きたい	条件を文章に近い形で書けるが、列名や文字列条件の書き方に慣れが必要
cut()	数値を区間カテゴリに分けたい	between()は範囲に入る行を抽出、cut()は値を区間に分類

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

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

	注文日	商品	カテゴリ	売上
1	2026-01-08	マウス	周辺機器	1000.0
2	2026-01-15	キーボード	周辺機器	4800.0
4	2026-02-04	モニター	PC	5000.0
6	NaT	ケーブル	周辺機器	3200.0

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

	注文日	商品	カテゴリ	売上
1	2026-01-08	マウス	周辺機器	1000.0
2	2026-01-15	キーボード	周辺機器	4800.0
4	2026-02-04	モニター	PC	5000.0
6	NaT	ケーブル	周辺機器	3200.0

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

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

query()で書く場合

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

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

	注文日	商品	カテゴリ	売上
1	2026-01-08	マウス	周辺機器	1000.0
2	2026-01-15	キーボード	周辺機器	4800.0
4	2026-02-04	モニター	PC	5000.0
6	NaT	ケーブル	周辺機器	3200.0

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

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

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

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

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

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

	注文日	商品	カテゴリ	売上
1	2026-01-08	マウス	周辺機器	1000.0
2	2026-01-15	キーボード	周辺機器	4800.0
4	2026-02-04	モニター	PC	5000.0
6	NaT	ケーブル	周辺機器	3200.0

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

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

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

	商品	売上	売上帯
0	ノートPC	120000.0	高め
1	マウス	1000.0	低め
2	キーボード	4800.0	中くらい
3	USBメモリ	980.0	低め
4	モニター	5000.0	中くらい
5	Webカメラ	NaN	NaN
6	ケーブル	3200.0	中くらい

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

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

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

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

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

やりたいこと	使う方法
候補リストに含まれる値を抽出したい	isin()
文字列を含む行を抽出したい	str.contains()

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

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

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

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

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

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

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

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

	count
周辺機器	3
PC	1

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

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

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

	売上
PC	5000.0
周辺機器	9000.0

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

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

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

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

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

!pip install japanize-matplotlib > /dev/null

import matplotlib.pyplot as plt
import japanize_matplotlib

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

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

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

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

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

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

よくあるミス	原因	対策
文字列の数字にそのまま使う	数値として比較できていない	pd.to_numeric() で数値型に変換する
日付文字列にそのまま使う	日付型ではなく文字列のまま	pd.to_datetime() で日付型に変換する
境界値が思った通りに含まれない	inclusive の指定を確認していない	以上・以下なのか、より大きい・未満なのかを先に決める
欠損値が抽出されない	NaN や NaT は範囲内にならない	欠損値処理を先に検討する
複数条件をすべてbetween()で書こうとする	1つの列の範囲抽出向きのメソッドだから	複数条件では AND/OR や query() も使う

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

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

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

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

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

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

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

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

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

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

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

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

ポイントを整理します。

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

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

次に読みたい関連記事

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

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

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

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

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

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

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

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

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

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

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

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

カテゴリから探す

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

▲ ページトップへ戻る

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

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

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

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

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

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

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

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

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

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

df.select_dtypes(include="number")

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

この記事でわかること

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

select_dtypes()とは？

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

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

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

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

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

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

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

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

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

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

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

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

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

raw_df

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

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

raw_df.dtypes

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

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

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

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

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

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

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

raw_df.select_dtypes(include="number")

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

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

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

売上を数値型に変換する

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

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

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

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

df = raw_df.copy()

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

df

売上 の "不明" は、errors="coerce" によって NaN になりました。
これは「数値に変換できない値を欠損値として扱う」という意味です。

今回は学習用の例として "不明" を NaN に変換しています。
実務では、"不明" が本当に欠損値として扱ってよい値なのかを確認してから処理しましょう。

次に、型がどう変わったか確認します。

df.dtypes

これで、売上 は数値型として扱えるようになりました。

もう一度、select_dtypes(include="number") で数値列だけを選んでみましょう。

変換後に数値列だけを選ぶ：include=”number”

売上 を数値型に変換したあとであれば、include="number" で数値列として選ばれるようになります。

numeric_df = df.select_dtypes(include="number")
numeric_df

この結果では、注文ID、売上、数量、割引率 のような数値型の列だけが残ります。

一方で、商品名、地域、注文日、メモ などは数値型ではないため、この結果には含まれません。
また、キャンペーン対象 のような True / False の列はbool型として扱われるため、ここでは数値列とは分けて考えるとわかりやすいです。

ただし、注文ID のようなID列も数値型なので、include="number" で選ばれます。
ここは初心者が特に注意したいポイントです。

数値型の列として選ばれること と、平均・合計などの分析対象として意味があること は同じではありません。
たとえば、注文ID は数値型ですが、平均値や合計を出しても分析上の意味は薄いです。

そのため、include="number" で数値列をまとめて選んだあとでも、ID列のように分析対象にしない列は、目的に応じて除外しましょう。

numeric_df.describe()

describe() を使うと、数値列の件数、平均、最小値、最大値などを確認できます。

より詳しく describe() の見方を確認したい場合は、以下の記事も参考になります。

• Pandas info()とdescribe()の違い｜欠損値・型・統計量の見方を例で解説

文字列が入っている列だけを選ぶ：include=[“object”, “string”]

文字列が入っている列だけを選びたい場合は、include=["object", "string"] のように指定します。

Pandasでは、文字列が object 型として扱われることもあれば、string 型として扱われることもあります。
初心者のうちは、厳密な違いまで深入りしすぎず、まずは 文字列っぽい列を選ぶときは object と string を意識する と覚えておくとよいです。

なお、pandasのバージョンによって、文字列が入っている列のデータ型の表示や選び方が少し変わる場合があります。
うまく選べないときは、まず df.dtypes で実際のデータ型を確認してください。

text_df = df.select_dtypes(include=["object", "string"])
text_df

この例では、商品名、地域、注文日、メモ などが選ばれます。

ここで 注文日 も選ばれるのは、まだ to_datetime() で日付型に変換していないためです。
見た目が日付でも、Pandas上で文字列として扱われていれば、文字列系の列として選ばれます。

文字列が入っている列だけを取り出すと、value_counts() で種類ごとの件数を確認しやすくなります。

object型を選ぶときの注意

文字列が入っている列を選びたいときは、次のように書けます。

df.select_dtypes(include=["object", "string"])

ただし、object 型は「文字列専用の型」ではありません。

CSVやExcelを読み込んだデータでは、商品名・地域名・メモのような文字列列が object 型になることが多いです。
しかし、object 型には、文字列だけでなく、リストや辞書などのPythonオブジェクトが入ることもあります。

そのため、文字列列だけを正確に扱いたい場合は、まず df.dtypes で型を確認し、必要に応じて astype("string") で文字列型に整えてから使うと安心です。

df["商品名"] = df["商品名"].astype("string")

select_dtypes() は便利ですが、最初に df.dtypes で列ごとの型を確認してから使うのが基本です。

df["メモ"].value_counts()

value_counts() は、カテゴリ名や文字列の出現回数を数えるときに便利です。

たとえば、地域別、商品名別、メモの種類別などを確認したいときに使えます。

詳しくは、以下の記事で解説しています。

• pandas value_counts()の使い方｜件数集計・割合表示・欠損値の数え方を解説

日付列だけを選ぶ：include=”datetime”

日付列だけを選びたい場合は、include="datetime" を指定します。

ただし、見た目が日付の文字列でも、Pandas上で日付型になっていなければ選ばれません。
今回の 注文日 も、ここまでは文字列のままです。

そのため、日付列として選ぶ前に、to_datetime() で日付型に変換します。
to_datetime() の詳しい使い方は、以下の記事で解説しています。

• pandas to_datetime()の使い方｜文字列の日付変換と format・NaT 対処を初心者向けに解説

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

date_df = df.select_dtypes(include="datetime")
date_df

日付列を選べるようになると、月別集計や曜日別集計などに進みやすくなります。

なお、日付列から年・月・曜日を取り出す方法は、以下の記事で詳しく解説しています。

• pandas dtの使い方｜日付から年・月・曜日を取り出す方法を初心者向けに解説

補足：category列やbool列も選べる

select_dtypes() では、数値列・文字列が入っている列・日付列だけでなく、カテゴリ型や真偽値型の列も選べます。

たとえば、カテゴリ型の列を選ぶ場合は include="category"、True / False のような真偽値列を選ぶ場合は include="bool" を使います。

ただし、初心者のうちは、まず include="number"、include=["object", "string"]、include="datetime" の3つを優先して覚えれば十分です。
category や bool は、必要になったときに補足として使うくらいで問題ありません。

category 型への変換は astype("category") で行えますが、詳しい型変換は以下の記事で解説しています。

• pandas astype()の使い方｜文字列・数値への型変換とエラー対処を初心者向けに解説

excludeで特定の型を除外する

include は「この型を選ぶ」という指定です。
一方で、exclude は「この型を除外する」という指定です。

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

non_numeric_df = df.select_dtypes(exclude="number")
non_numeric_df

exclude="number" を指定すると、数値型の列が除外されます。

ただし、初心者のうちは、まず include を中心に使うのがおすすめです。
exclude は、慣れてきてから「数値列以外をまとめて確認したい」ときに使うとよいでしょう。

select_dtypes()で次の処理に進みやすくする

select_dtypes() で列をデータ型ごとに分けておくと、その後の処理に進みやすくなります。

たとえば、数値列は統計量の確認、文字列やカテゴリ列は件数集計、日付列は日付を使った分析に向いています。
この記事では詳しい集計や可視化には深入りせず、「分析に使う列をデータ型ごとに整理する」ところまでを押さえます。

• pandas value_counts()の使い方｜件数集計・割合表示・欠損値の数え方を解説
• Pandas groupby×aggの使い方｜基本の集計とaggの書き方を例で解説
• Matplotlib ヒストグラム＆箱ひげ図 入門｜bins設定と外れ値の可視化・分析

まとめ

この記事では、pandas select_dtypes の使い方を解説しました。

select_dtypes() は、DataFrameの中から データ型を基準に列を選ぶ メソッドです。

基本は、次のように覚えると十分です。

category 型の列を選びたい場合は、include="category" も使えます。
ただし、初心者のうちは、まず数値列・文字列が入っている列・日付列を選べれば十分です。

注意したいのは、select_dtypes() は 型を変換するメソッドではない という点です。
数字に見える列や日付に見える列でも、Pandas上のデータ型が違えば選ばれないことがあります。

うまく選べないときは、まず df.dtypes や df.info() で型を確認しましょう。

必要に応じて、数値なら to_numeric()、日付なら to_datetime()、文字列型やカテゴリ型への変換なら astype() で型を整えてから、select_dtypes() を使います。

データ型を確認し、必要に応じて型を整えたうえで select_dtypes() を使うと、列の種類に合った次の処理へ進みやすくなります。

▲ ページトップへ戻る

<p>The post pandas select_dtypes()の使い方｜データ型で列を選ぶ方法を初心者向けに解説 first appeared on Python Data Lab（Pythonデータラボ）.</p>

Pandasで前処理をしていると、次のような場面で迷うことがあります。

• 60点以上の点数だけ残し、60点未満は欠損値として扱いたい
• 売上がマイナスになっている不自然な値だけ、0やNaNにしたい
• 年齢が120歳を超えるような確認が必要な値だけ、欠損値にしたい
• replace()、loc、where()、mask()のどれを使えばよいかわからない

最初に結論を言うと、where()は「条件を満たす値を残す」ために使い、mask()は「条件を満たす値を置き換える」ために使います。

言い換えると、次のように考えると分かりやすいです。

この記事では、Google Colabでそのまま試せる小さなDataFrameを使いながら、where()とmask()の違い、使いどころ、よくあるミスを初心者向けに整理します。

この記事でわかること

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

• where()の基本的な使い方
• mask()の基本的な使い方
• where()とmask()の違い
• 条件に合わない値をNaNにする方法
• NaNにしたときに整数列が小数表示になる理由
• 条件に応じて別の値に置き換える方法
• loc、replace()、fillna()、np.where()との使い分け
• 初心者が間違えやすい条件式の向き

Pandas前処理の中での位置づけ

where()とmask()は、DataFrameを確認したあとに、条件に応じて値を整える前処理で役立ちます。

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

1. info()やdescribe()でデータの型・欠損値・統計量を確認する
2. unique()やvalue_counts()で値の中身を確認する
3. replace()で表記ゆれを直す
4. where()やmask()で条件に合わない値・確認が必要な値を整理する
5. fillna()で欠損値を補う
6. groupby()やグラフで集計・可視化する

つまり、where()とmask()は、集計や可視化の前に、条件に応じて値を整えるための道具です。

where()とmask()の判断基準

まず、where()とmask()の違いを先に押さえます。

特に初心者が混乱しやすいのは、条件に合う値をどうしたいのかです。

• 条件に合う値を残したい → where()
• 条件に合う値を消したい・置き換えたい → mask()

この記事では、まず同じサンプルデータを使って、where()とmask()の動きを確認していきます。

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

ここでは、テスト点数、売上、年齢を持つ小さなDataFrameを使います。

売上の-500は、今回の例では「本来はマイナスにならないはずの入力ミス」として扱います。
年齢の135も、今回の例では「確認が必要な値」として扱います。

import pandas as pd

df = pd.DataFrame({
    "名前": ["田中", "佐藤", "鈴木", "高橋", "伊藤", "山本"],
    "点数": [82, 55, 91, 47, 60, 73],
    "売上": [12000, -500, 18500, 0, 9200, 15000],
    "年齢": [24, 31, 135, 28, 42, 19]
})

df

このDataFrameでは、次のような前処理を考えます。

実務でも、CSVやExcelを読み込んだあとに、このような「条件に応じた値の整理」が必要になることがあります。

where()の基本：条件を満たす値を残す

where()は、条件を満たす値を残し、条件を満たさない値を置き換えるメソッドです。

基本形は次のように考えます。

Series.where(条件, other=置き換える値)

otherを指定しない場合、条件を満たさない値はNaNになります。

Series.where(条件)

ここでは、点数が60点以上の値だけを残し、60点未満をNaNにしてみます。

df["点数_where"] = df["点数"].where(df["点数"] >= 60)

df[["名前", "点数", "点数_where"]]

上のコードでは、df["点数"] >= 60という条件を満たす値だけが残ります。

ここで大切なのは、where()は「条件に合う値を置き換える」のではなく、条件に合う値を残すという点です。

補足：NaNが入ると小数表示になることがある

where()やmask()でNaNを作ると、整数だった列が82.0のように小数で表示されることがあります。

これは、NaNが欠損値を表すため、整数だけの列にNaNが混ざると、Pandasが列全体を小数型として扱うことがあるためです。

そのため、結果が82.0のように表示されても、処理が間違っているとは限りません。まずは、どの値が残り、どの値がNaNになったかを確認しましょう。

where()で条件に合わない値を別の値に置き換える

where()では、otherを指定すると、条件を満たさない値を別の値に置き換えられます。

Series.where(残したい条件, other=条件に合わないときの値)

ここでは、売上が0以上ならそのまま残し、0未満の売上を0に置き換えます。

df["売上_where_0"] = df["売上"].where(df["売上"] >= 0, other=0)

df[["名前", "売上", "売上_where_0"]]

この例では、売上が0以上の値はそのまま残り、-500だけが0に置き換わりました。

0は今回のデータでは「売上がなかった」という意味のある値として残しています。
一方、-500は「本来はマイナスにならない想定の売上」として、確認・修正対象にしています。

mask()の基本：条件を満たす値を置き換える

mask()は、where()とは逆に、条件を満たす値を置き換えるメソッドです。

基本形は次のように考えます。

Series.mask(条件, other=置き換える値)

otherを指定しない場合、条件を満たす値はNaNになります。

Series.mask(条件)

ここでは、年齢が120歳を超える値を確認対象として、NaNにします。

df["年齢_mask"] = df["年齢"].mask(df["年齢"] > 120)

df[["名前", "年齢", "年齢_mask"]]

この例では、年齢 > 120という条件を満たす135だけがNaNになりました。

mask()は、条件に合う値を隠す・置き換えるイメージで使うと理解しやすいです。

where()とmask()の違いを同じデータで比較する

where()とmask()は、条件の向きを逆にすると同じ結果を作れることがあります。

たとえば、次の2つはどちらも「60点未満をNaNにする」処理です。

• where(df["点数"] >= 60)：60点以上を残す
• mask(df["点数"] < 60)：60点未満を置き換える

同じデータで比較してみましょう。

compare = pd.DataFrame({
    "名前": df["名前"],
    "元の点数": df["点数"],
    "where_60点以上を残す": df["点数"].where(df["点数"] >= 60),
    "mask_60点未満をNaN": df["点数"].mask(df["点数"] < 60)
})

compare

結果を見ると、where()とmask()で同じような結果になっています。

ただし、考え方は逆です。

迷ったときは、次のように判断してください。

• 残したい条件を書きたい → where()
• 置き換えたい条件を書きたい → mask()

複数条件でwhere()を使う場合

where()やmask()では、複数条件も指定できます。

複数条件を書くときは、次の点に注意します。

• それぞれの条件を()で囲む
• AND条件は&でつなぐ
• OR条件は|でつなぐ

ここでは、点数が60点以上かつ90点以下の値だけを残してみます。

df["点数_60から90"] = df["点数"].where((df["点数"] >= 60) & (df["点数"] <= 90))

df[["名前", "点数", "点数_60から90"]]

この例では、60点以上かつ90点以下の値だけが残ります。
55や47は60点未満なのでNaNになり、91は90点を超えているためNaNになります。

複数条件は便利ですが、初心者のうちは条件式が長くなりやすいです。
まずは単一条件でwhere()とmask()の考え方を理解し、そのあと複数条件に進むと分かりやすくなります。

補足：DataFrame全体にもwhere()・mask()は使える

ここまでの例では、df["点数"]のように1つの列に対してwhere()やmask()を使いました。

実は、DataFrame全体に対しても使えます。 ただし、初心者のうちは、まず1つの列ごとに処理するほうが結果を確認しやすいです。

ここでは、数値列だけを取り出して、0以上の値を残し、0未満の値をNaNにしてみます。

numeric_df = df[["点数", "売上", "年齢"]]

numeric_df.where(numeric_df >= 0)

このように、DataFrame.where()を使うと、DataFrame内の各値に対して条件を確認できます。

同じ考え方で、DataFrame.mask()もDataFrame全体に使えます。ただし、初心者のうちは、まず1列ずつ処理して結果を確認するほうが安全です。

ただし、実際の記事や学習では、最初からDataFrame全体に使うよりも、

df["列名"].where(条件)

のように、対象の列を決めてから使うほうがミスに気づきやすいです。

where()・mask()・replace()・fillna()・locの使い分け

where()やmask()で迷う理由は、似たような処理をするメソッドが多いからです。

ここでは、初心者が特に迷いやすいメソッドを整理します。

この記事では、中心をwhere()とmask()に絞ります。
replace()は値そのものの置換、fillna()は欠損値を埋める処理、locは行・列を指定する処理として分けて考えると整理しやすくなります。

locでの条件代入との違い

locを使っても、条件に合う行だけ値を変更できます。

たとえば、売上が0未満の値を0にするなら、次のように書けます。

df_loc = df.copy()

df_loc.loc[df_loc["売上"] < 0, "売上"] = 0

df_loc[["名前", "売上"]]

locは、条件に合う行と列を指定して、そこへ直接代入するイメージです。

一方、where()は「条件を満たす値を残し、それ以外を置き換えた結果を作る」イメージです。

df_where = df.copy()

df_where["売上"] = df_where["売上"].where(df_where["売上"] >= 0, other=0)

df_where[["名前", "売上"]]

どちらも同じ結果にできますが、初心者のうちは次のように考えるとよいです。

この記事の主役はwhere()とmask()なので、locの詳細は別記事で学ぶのがおすすめです。

新しい列として結果を残すと確認しやすい

初心者のうちは、いきなり元の列を上書きするより、新しい列として結果を残すほうが確認しやすいです。

たとえば、売上の元データを残したまま、確認用の列を作ると、処理前後を並べて比較できます。

df_check = df.copy()

df_check["売上_修正案"] = df_check["売上"].where(df_check["売上"] >= 0, other=0)
df_check["年齢_確認用"] = df_check["年齢"].mask(df_check["年齢"] > 120)

df_check[["名前", "売上", "売上_修正案", "年齢", "年齢_確認用"]]

このように、元の列と処理後の列を並べると、どの値が変わったのかを確認しやすくなります。

特に、公開データや実務データでは、いきなり上書きすると元の状態が分からなくなることがあります。
最初は新しい列に結果を保存し、問題なければ上書きする流れがおすすめです。

よくあるミス1：代入しないと元のDataFrameは変わらない

where()やmask()は、実行しただけでは元のDataFrameを自動で書き換えません。

次のコードでは、where()の結果を表示しているだけなので、元のdf["売上"]は変わりません。

df["売上"].where(df["売上"] >= 0, other=0)

df[["名前", "売上"]]

元のDataFrameを変更したい場合は、次のように代入します。

df_update = df.copy()

df_update["売上"] = df_update["売上"].where(df_update["売上"] >= 0, other=0)

df_update[["名前", "売上"]]

where()やmask()で処理した結果を残したい場合は、新しい列に入れるか、元の列に代入する必要があります。

よくあるミス2：条件式の向きが逆になる

where()とmask()で一番多いミスは、条件式の向きを逆にしてしまうことです。

たとえば、「60点以上だけ残したい」のに、次のように書くと意図と逆になります。

wrong = pd.DataFrame({
    "名前": df["名前"],
    "点数": df["点数"],
    "意図と逆になりやすい例": df["点数"].where(df["点数"] < 60)
})

wrong

上の例では、df["点数"] < 60という条件を書いているため、60点未満の値が残っています。

「60点以上だけ残したい」なら、条件は次のように書きます。

correct = pd.DataFrame({
    "名前": df["名前"],
    "点数": df["点数"],
    "60点以上だけ残す": df["点数"].where(df["点数"] >= 60)
})

correct

where()では、残したい条件を書くと覚えると、条件式の向きを間違えにくくなります。

逆に、mask()では、置き換えたい条件を書くと考えると分かりやすいです。

条件に合わない値をNaNにしたあとの流れ

where()やmask()で値をNaNにしたあと、そのまま終わりではありません。

NaNにしたあとは、目的に応じて次の処理につながります。

ここでは、年齢が120歳を超える値をNaNにしたあと、欠損値の数を確認してみます。

age_checked = df["年齢"].mask(df["年齢"] > 120)

age_checked.isnull().sum()

np.int64(1)

このように、where()やmask()は「欠損値を作る」ことがあります。
そのため、後続のfillna()やdropna()、集計・可視化とセットで考えると、データ分析の流れがつかみやすくなります。

np.where()には軽く触れる程度でよい

条件に応じて値を変える方法として、np.where()もよく見かけます。

ただし、初心者が最初に学ぶ場合は、まずpandasのwhere()とmask()で、残す条件・置き換える条件の考え方を理解するのがおすすめです。

np.where()は、たとえば「合格」「不合格」のような新しい列を作るときに便利です。

import numpy as np

df_np = df.copy()
df_np["判定"] = np.where(df_np["点数"] >= 60, "合格", "再確認")

df_np[["名前", "点数", "判定"]]

ここでは、np.where()の詳細には深入りしません。

この記事では、次のように整理しておけば十分です。

新しい列の作り方を詳しく学びたい場合は、条件付き列追加の記事と合わせて学ぶと理解しやすくなります。

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

where()とmask()は、単独で覚えるよりも、データ分析の流れの中で考えると使いどころが見えやすくなります。

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

1. CSVやExcelを読み込む
2. head()で先頭を確認する
3. info()やdescribe()で型・欠損値・統計量を確認する
4. unique()やvalue_counts()で不自然な値を見つける
5. replace()で表記ゆれを直す
6. where()やmask()で条件に合わない値を整理する
7. fillna()で欠損値を補う
8. groupby()やグラフで集計・可視化する

つまり、where()とmask()は、値を確認したあと、集計や可視化に進む前の前処理として使うと自然です。

特に、外れ値や不自然な値をそのまま集計すると、平均値やグラフが読みにくくなることがあります。
その前に、どの値を残し、どの値を確認対象にするかを整理するのが大切です。

まとめ

この記事では、pandasのwhere()とmask()の使い方を解説しました。

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

where()とmask()は、条件に応じて値を残す・置き換えるための前処理で役立ちます。

最初は難しく感じるかもしれませんが、次の2つだけ覚えておけば大丈夫です。

• 残したい条件を書くならwhere()
• 置き換えたい条件を書くならmask()

この考え方を押さえると、条件に応じた値の整理がかなり分かりやすくなります。

次に読みたい関連記事

今回の記事とあわせて読むと、Pandasの前処理の流れがつかみやすくなります。

• Pandas info()とdescribe()の違い｜欠損値・型・統計量の見方を例で解説
• pandas replace()の使い方｜値の置換・表記ゆれ・欠損値変換を解説
• pandas fillna()の使い方｜欠損値を0・平均値・中央値・最頻値で埋める方法を初心者向けに解説
• pandas 条件抽出（filtering）入門｜AND/OR・query関数・複数条件の指定方法
• 【初心者向け】Pandasのlocで行や列をラベルで抽出する基本操作をやさしく解説【図解あり】
• pandas value_counts()の使い方｜件数集計・割合表示・欠損値の数え方を解説

▲ ページトップへ戻る

<p>The post pandas where()・mask()の使い方｜条件に応じて値を残す・置き換える方法 first appeared on Python Data Lab（Pythonデータラボ）.</p>