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

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

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

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

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

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

この記事でわかること

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

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

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

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

crosstab()が役立つ場面

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

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

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

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

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

import pandas as pd

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

df

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

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

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

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

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

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

df["地域"].value_counts()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

年代×満足度を集計する

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

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

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

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

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

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

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

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

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

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

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

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

件数を割合で表示する

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

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

全体に対する割合を見る

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

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

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

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

行ごとの割合を見る

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

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

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

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

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

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

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

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

列ごとの割合を見る

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

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

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

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

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

小数を見やすく丸める

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

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

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

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

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

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

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

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

df.isnull().sum()

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

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

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

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

len(df)

10

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

まとめ

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

ポイントを整理します。

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

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

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

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

次に読みたい関連記事

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

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

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

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

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

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

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

▲ ページトップへ戻る

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

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

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

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

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

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

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

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

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

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

この記事でわかること

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

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

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

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

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

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

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

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

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

import pandas as pd

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

df = pd.DataFrame(data)
df

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

query()で書く場合

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

!pip install japanize-matplotlib > /dev/null

import matplotlib.pyplot as plt
import japanize_matplotlib

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ポイントを整理します。

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

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

次に読みたい関連記事

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

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

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

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

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

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

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

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

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

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

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

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

▲ ページトップへ戻る

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

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

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

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

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

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

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

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

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

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

df.select_dtypes(include="number")

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

この記事でわかること

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

select_dtypes()とは？

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

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

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

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

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

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

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

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

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

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

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

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

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

raw_df

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

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

raw_df.dtypes

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

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

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

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

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

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

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

raw_df.select_dtypes(include="number")

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

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

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

売上を数値型に変換する

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

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

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

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

df = raw_df.copy()

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

df

売上 の "不明" は、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>

CSVやExcelを読み込んだあと、画面上では「1000」「2500」のように数字に見えるのに、sum()やmean()でうまく計算できないことがあります。

その原因の1つが、数字に見える列が、pandas上では文字列（object型）として扱われていることです。

このようなときに役立つのが、pd.to_numeric()です。

pd.to_numeric()は、数字に見える文字列を、計算できる数値型に変換するための関数です。特に、列の中に「不明」「-」「空欄」など、数値に変換できない値が混ざっている場合は、errors="coerce"を使うと安全に確認しながら前処理できます。

この記事では、to_numeric()の基本から、astype()との違い、errors="coerce"でNaNになる理由、変換後に集計や可視化へつなげる流れまで、初心者向けに順番に解説します。

この記事でわかること

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

• pd.to_numeric()で文字列の数字を数値に変換する方法
• 数字に見える列がobject型になってしまう理由
• errors="coerce"で変換できない値をNaNにする考え方
• to_numeric()とastype()の違い
• カンマ入り数値や「円」付きの金額を数値化する基本
• 変換後にfillna()、dropna()、groupby()、グラフ化へつなげる流れ

この記事のゴールは、数字に見えるのに計算できない列を、to_numeric()で安全に数値化し、欠損確認・集計・可視化へ進める前処理の流れを理解することです。

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

to_numeric()は、Pandasの前処理の中では「型を整える」場面で使います。

データ分析では、次のような流れで作業することが多いです。

1. CSVやExcelを読み込む
2. head()やinfo()でデータの状態を確認する
3. 文字列になっている数値列を数値型に変換する
4. 欠損値や変換できなかった値を処理する
5. 集計やグラフ化に進む

to_numeric()は、特に3番目の「文字列になっている数値列を数値型に変換する」場面で役立ちます。

Pandasの基本的な流れを先に確認したい場合は、以下の記事も参考になります。

• Pandas DataFrame入門
• Pandas info()とdescribe()の違い
• Google Colab CSV 読み込み＆保存入門
• pandas read_excel()の使い方

まず結論：to_numeric()は「計算できる数値」に変換するために使う

pd.to_numeric()は、文字列として入っている数字を、計算できる数値型に変換するために使います。

たとえば、次のような列があるとします。

このような列を扱うときは、まずinfo()やdtypesで型を確認し、必要に応じてpd.to_numeric()で数値化します。

import pandas as pd

# サンプルデータ：売上が文字列として入っている例
df = pd.DataFrame({
    "商品": ["A", "B", "C", "D"],
    "売上": ["1000", "2500", "1800", "3200"],
    "数量": ["2", "5", "3", "4"]
})

display(df)
print(df.dtypes)

商品    object
売上    object
数量    object
dtype: object

上の例では、売上列も数量列も見た目は数字ですが、dtypesを見るとobject型になっています。

object型は、文字列などが入っているときによく見られる型です。つまり、この状態では「数字のように見える文字列」として扱われています。

数字に見えるのに計算できない例

文字列のまま集計しようとすると、思った結果にならないことがあります。

たとえば、文字列の列に対してsum()を使うと、数値の合計ではなく、文字列がつながってしまう場合があります。

# 文字列のままsum()すると、数値の合計ではなく文字列の連結になることがあります
print(df["売上"].sum())

# 平均は計算できないため、エラーになります
try:
    print(df["売上"].mean())
except Exception as e:
    print(type(e).__name__)
    print(e)

1000250018003200
TypeError
Could not convert string '1000250018003200' to numeric

このように、見た目が数字でも、pandas上で文字列として扱われていると、集計や平均計算で困ることがあります。

そのため、CSVやExcelを読み込んだあとに計算がうまくいかない場合は、まず次の順番で確認します。

1. info()またはdtypesで型を見る
2. 数値として使いたい列がobject型になっていないか確認する
3. 必要ならpd.to_numeric()で数値型に変換する

次に、実際にto_numeric()で変換してみます。

to_numeric()の基本的な使い方

pd.to_numeric()の基本形は、次のように書きます。

df["列名"] = pd.to_numeric(df["列名"])

ここでは、売上列と数量列を数値に変換します。

df_basic = df.copy()

df_basic["売上"] = pd.to_numeric(df_basic["売上"])
df_basic["数量"] = pd.to_numeric(df_basic["数量"])

display(df_basic)
print(df_basic.dtypes)

商品    object
売上     int64
数量     int64
dtype: object

変換後は、売上列と数量列が数値型になりました。

この状態になれば、合計や平均を自然に計算できます。

print("売上合計:", df_basic["売上"].sum())
print("売上平均:", df_basic["売上"].mean())
print("数量合計:", df_basic["数量"].sum())

売上合計: 8500
売上平均: 2125.0
数量合計: 14

複数列をまとめて数値に変換したい場合

慣れてきたら、複数の列をまとめてto_numeric()で変換することもできます。

ただし、初心者のうちは、まず1列ずつ変換して、どの列でNaNが出たか確認する方が安全です。ここでは、売上列と数量列をまとめて変換する最小例だけ確認します。

df_multi = df.copy()

cols = ["売上", "数量"]
df_multi[cols] = df_multi[cols].apply(pd.to_numeric, errors="coerce")

display(df_multi)
print(df_multi.dtypes)

商品    object
売上     int64
数量     int64
dtype: object

複数列をまとめて変換するとコードは短くなります。

一方で、どの列に変換できない値があったのか見落としやすくなることもあります。そのため、最初は1列ずつ確認し、慣れてきたら複数列の一括変換を使うのがおすすめです。

処理前後で見る：文字列の数字が数値になる

to_numeric()の役割を、処理前後で整理すると次のようになります。

ポイントは、表示されている見た目ではなく、pandas上の型を確認することです。

「数字に見えるから大丈夫」と判断せず、info()やdtypesで確認する習慣をつけると、前処理で迷いにくくなります。

変換できない値が混ざるとエラーになる

実際のCSVやExcelでは、数値列の中に「不明」「-」「空欄」「error」などが混ざっていることがあります。

たとえば、次のような売上データを考えます。

df_dirty = pd.DataFrame({
    "商品": ["A", "B", "C", "D", "E"],
    "カテゴリ": ["食品", "食品", "日用品", "日用品", "食品"],
    "売上": ["1000", "2500", "不明", "3000", "-"],
    "数量": ["2", "5", "3", "error", "1"]
})

display(df_dirty)
print(df_dirty.dtypes)

商品      object
カテゴリ    object
売上      object
数量      object
dtype: object

売上列には「不明」や「-」が含まれています。
数量列には「error」が含まれています。

このような列をそのままpd.to_numeric()で変換しようとすると、数値に変換できない値があるためエラーになります。

try:
    pd.to_numeric(df_dirty["売上"])
except Exception as e:
    print(type(e).__name__)
    print(e)

ValueError
Unable to parse string "不明" at position 2

エラーが出ること自体は悪いことではありません。
むしろ、「この列には数値に変換できない値が混ざっている」と気づくきっかけになります。

ただし、実務では、変換できない値をいったんNaNにして確認したいことがよくあります。そこで使うのが、errors="coerce"です。

errors=”coerce”で変換できない値をNaNにする

errors="coerce"を指定すると、数値に変換できない値をNaNにできます。

pd.to_numeric(df["列名"], errors="coerce")

coerceは「無理に変換する」という意味に近い指定です。
ただし、ここで大切なのは、エラーを隠すためではなく、変換できなかった値をNaNとして見つけるために使うという考え方です。

df_coerce = df_dirty.copy()

df_coerce["売上_数値"] = pd.to_numeric(df_coerce["売上"], errors="coerce")
df_coerce["数量_数値"] = pd.to_numeric(df_coerce["数量"], errors="coerce")

display(df_coerce)
print(df_coerce.dtypes)

商品        object
カテゴリ      object
売上        object
数量        object
売上_数値    float64
数量_数値    float64
dtype: object

処理前後を表で見ると、次のようなイメージです。

to_numeric()後にNaNが出た場合、それは元データに数値化できない値が混ざっていたサインです。

NaNになった行を確認する

errors="coerce"を使ったあとに大切なのは、NaNになった行を確認することです。

NaNになった値は、単なる欠損値ではなく、数値に変換できなかった値である可能性があります。

# 売上_数値がNaNになった行を確認
display(df_coerce[df_coerce["売上_数値"].isna()])

# 数量_数値がNaNになった行を確認
display(df_coerce[df_coerce["数量_数値"].isna()])

この確認を入れることで、次に何をすべきか判断しやすくなります。

たとえば、

• 「不明」は本当に欠損として扱ってよいのか
• 「-」は未入力を意味するのか
• 「error」は入力ミスなのか
• 行を除外するのか、0で埋めるのか、別途確認するのか

といった判断ができます。

to_numeric()は、数値化するだけでなく、データの汚れを見つける入口としても役立ちます。

errorsの違いを軽く整理する

pd.to_numeric()のerrorsでは、初心者のうちは次の2つを押さえれば十分です。

まずは、変換できない値があるとエラーになるerrors="raise"で、データに問題があることを確認できます。

実務では、変換できない値をNaNにしてあとから確認したい場面が多いため、この記事では主にerrors="coerce"を使って説明します。

なお、古い記事や古いpandas環境ではerrors="ignore"を見かけることがあります。
ただし、初心者向けの記事では通常の選択肢として覚える必要はありません。変換できない値を曖昧に残すより、errors="coerce"でNaNにして確認する方が、前処理の流れを理解しやすくなります。

to_numeric()とastype()の違い

数値変換では、astype()もよく使われます。

どちらも型変換に関係しますが、使いどころが少し違います。

ざっくり言うと、きれいな値ならastype()、汚れた数値列を安全に扱うならto_numeric()と考えると分かりやすいです。

# astype()は、きれいな値なら分かりやすく変換できます
df_astype_ok = pd.DataFrame({
    "売上": ["1000", "2500", "1800"]
})

df_astype_ok["売上"] = df_astype_ok["売上"].astype(int)
display(df_astype_ok)
print(df_astype_ok.dtypes)

売上    int64
dtype: object

# ただし、不明などが混ざるとastype()ではエラーになります
df_astype_ng = pd.DataFrame({
    "売上": ["1000", "2500", "不明", "3000"]
})

try:
    df_astype_ng["売上"].astype(int)
except Exception as e:
    print(type(e).__name__)
    print(e)

ValueError
invalid literal for int() with base 10: '不明'

このように、astype()は値がきれいなときには便利です。

一方で、実際のCSVやExcelでは「不明」「-」「空欄」などが混ざることがあります。
そのような場合は、pd.to_numeric(..., errors="coerce")で変換できない値をNaNにして確認する方が、前処理の流れを作りやすくなります。

astype()全体の使い方は、別記事のpandas astype()の使い方で詳しく扱っています。

カンマ入り数値や「円」付きの金額を数値化する

CSVやExcelでは、次のような値が入っていることがあります。

ここでは、複雑な正規表現には深入りせず、基本的な置換だけで考えます。

df_money = pd.DataFrame({
    "商品": ["A", "B", "C", "D"],
    "売上": ["1,000", "2,500円", "3000円", "不明"]
})

display(df_money)

df_money_clean = df_money.copy()

# カンマと「円」を取り除く
df_money_clean["売上_整形後"] = (
    df_money_clean["売上"]
    .str.replace(",", "", regex=False)
    .str.replace("円", "", regex=False)
)

# 数値に変換する
df_money_clean["売上_数値"] = pd.to_numeric(df_money_clean["売上_整形後"], errors="coerce")

display(df_money_clean)
print(df_money_clean.dtypes)

商品         object
売上         object
売上_整形後     object
売上_数値     float64
dtype: object

処理の流れを整理すると、次のようになります。

ここでのポイントは、replace()やstr.replace()で文字を整えたあと、最後にto_numeric()で数値型にすることです。

置換処理そのものを詳しく学びたい場合は、pandas replace()の使い方も参考になります。

変換後のNaNをどう扱うか

to_numeric(errors="coerce")でNaNになった値は、次のどちらかで処理することが多いです。

ただし、どちらが正しいかはデータの意味によって変わります。

たとえば、売上の「不明」を0円とみなしてよいとは限りません。
0で埋める前に、NaNになった理由を確認することが大切です。

df_after = df_coerce.copy()

# 例1：売上_数値のNaNを0で埋める
df_fill = df_after.copy()
df_fill["売上_数値"] = df_fill["売上_数値"].fillna(0)

print("NaNを0で埋めた例")
display(df_fill)

# 例2：売上_数値がNaNの行を除外する
df_drop = df_after.dropna(subset=["売上_数値"])

print("売上_数値がNaNの行を除外した例")
display(df_drop)

NaNを0で埋めた例

売上_数値がNaNの行を除外した例

fillna()とdropna()は、どちらもよく使う欠損処理です。

• 欠損値を埋める処理を詳しく学びたい場合：
  pandas fillna()の使い方

• 欠損行を削除する処理を詳しく学びたい場合：
  pandas dropna()・drop_duplicates()・drop()の使い方

今回の記事では、to_numeric()で数値化したあとに、必要に応じて欠損処理へ進む流れだけ押さえれば十分です。

数値化できると集計や可視化に進みやすくなる

to_numeric()で数値化できると、合計・平均・グループ別集計・グラフ化に進みやすくなります。

ここでは、カテゴリ別に売上合計を出す例を見てみます。

# 集計用のデータを作る
# グラフの文字化けを避けるため、カテゴリ名は英語にしています
df_sales = pd.DataFrame({
    "商品": ["A", "B", "C", "D", "E", "F"],
    "カテゴリ": ["Food", "Food", "Daily goods", "Daily goods", "Food", "Daily goods"],
    "売上": ["1000", "2500", "不明", "3000", "1200", "1800"]
})

# 売上を数値化
df_sales["売上_数値"] = pd.to_numeric(df_sales["売上"], errors="coerce")

display(df_sales)

# NaNを除いてカテゴリ別に売上を集計
category_sales = (
    df_sales
    .dropna(subset=["売上_数値"])
    .groupby("カテゴリ")["売上_数値"]
    .sum()
    .reset_index()
)

display(category_sales)

このように、文字列だった売上列を数値化すると、groupby()でカテゴリ別に集計できるようになります。

groupby()を詳しく学びたい場合は、Pandas groupby×aggの使い方も参考になります。

import matplotlib.pyplot as plt

# 数値化した結果を棒グラフで確認
category_sales.plot(kind="bar", x="カテゴリ", y="売上_数値", legend=False)
plt.title("Sales by Category")
plt.xlabel("Category")
plt.ylabel("Sales")
plt.show()

Google Colabでは、日本語フォントの設定をしていないとグラフ内の日本語が文字化けすることがあります。

この記事ではto_numeric()で数値化したあとにグラフ化へ進める流れを確認することが目的なので、グラフ用のカテゴリ名とラベルは英語にしています。

グラフ化そのものはこの記事の主題ではありませんが、数値列が正しく数値型になっていると、Matplotlibで可視化しやすくなります。

棒グラフの作り方を詳しく学びたい場合は、Matplotlib 棒グラフ入門へ進むと理解がつながります。

補足：グラフを日本語表示したい場合

Google Colabでグラフ内の日本語を表示したい場合は、japanize-matplotlibを使う方法もあります。

!pip install japanize-matplotlib > /dev/null
import japanize_matplotlib

ただし、この記事の主題はto_numeric()で数値化する前処理です。
そのため、本文ではグラフの日本語表示設定には深入りせず、数値化後に集計・可視化へ進める流れの確認にとどめます。

Matplotlibの見やすいグラフ設定を詳しく学びたい場合は、関連記事のMatplotlib入門記事へ進んでください。

すべてのobject型を数値化すればよいわけではない

ここまで、object型の数値列をto_numeric()で変換する方法を見てきました。

ただし、すべてのobject型を数値化すればよいわけではありません。

たとえば、次のような列は、数字のように見えても文字列のまま扱った方がよいことがあります。

to_numeric()を使う前に、その列を計算に使うのかを確認することが大切です。

売上、数量、点数、金額のように合計や平均を出したい列なら数値化します。
一方で、IDやコードのように識別のための列は、文字列のまま扱うこともあります。

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

to_numeric()で初心者がつまずきやすいポイントを整理します。

日付変換については、pandas to_datetime()の使い方で詳しく解説しています。

まとめ

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

ポイントを整理します。

• pd.to_numeric()は、数字に見える文字列を計算できる数値型に変換する関数
• CSVやExcelを読み込んだあと、数値列がobject型になることがある
• 変換前後はinfo()やdtypesで確認する
• 変換できない値が混ざる場合は、errors="coerce"でNaNにできる
• NaNになった値は、変換できなかった値として確認する
• きれいな値ならastype()、汚れた数値列を安全に扱うならto_numeric()が使いやすい
• カンマや「円」付きの値は、文字を整えてから数値化する
• まずは1列ずつ確認し、慣れてきたら複数列の一括変換も使える
• 数値化できると、sum()、mean()、groupby()、Matplotlibによる可視化へ進みやすくなる

to_numeric()は、派手な機能ではありませんが、データ分析の前処理ではとても重要です。

「数字に見えるのに計算できない」と感じたら、まずdtypesで型を確認し、必要に応じてpd.to_numeric()で数値化してみましょう。

次に読みたい関連記事

今回の記事とあわせて読むと、Pandasの前処理から集計・可視化までの流れがつながりやすくなります。

• Pandas DataFrame入門｜作り方・基本操作をわかりやすく解説
• Pandas info()とdescribe()の違い｜欠損値・型・統計量の見方を例で解説
• pandas astype()の使い方｜文字列・数値への型変換とエラー対処を初心者向けに解説
• pandas to_datetime()の使い方｜文字列の日付変換と format・NaT 対処を初心者向けに解説
• pandas replace()の使い方｜値の置換・表記ゆれ・欠損値変換を解説
• pandas fillna()の使い方｜欠損値を0・平均値・中央値・最頻値で埋める方法を初心者向けに解説
• pandas dropna()・drop_duplicates()・drop()の使い方
• Google Colab CSV 読み込み＆保存入門
• pandas read_excel()の使い方｜Excelファイル読み込み・sheet_name・usecolsを解説
• Pandas groupby×aggの使い方｜基本の集計とaggの書き方を例で解説
• Matplotlib 棒グラフ入門
• Pandas初心者向け学習ロードマップ

▲ ページトップへ戻る

<p>The post pandas to_numeric()の使い方｜文字列の数字を数値に変換する方法 first appeared on Python Data Lab（Pythonデータラボ）.</p>

pd.read_excel("ファイル名.xlsx")

from google.colab import files

uploaded = files.upload()

import pandas as pd

df = pd.read_excel("sales_sample.xlsx")
df.head()

import pandas as pd

# 練習用の売上データ
sales_df = pd.DataFrame({
    "売上日": ["2025-04-01", "2025-04-02", "2025-04-03"],
    "店舗": ["東京店", "大阪店", "東京店"],
    "商品": ["ノートPC", "マウス", "キーボード"],
    "売上金額": [120000, 3000, 8000],
    "数量": [1, 2, 1]
})

# 複数シートの例に使う商品マスタ
master_df = pd.DataFrame({
    "商品": ["ノートPC", "マウス", "キーボード"],
    "カテゴリ": ["PC", "周辺機器", "周辺機器"]
})

file_path = "sales_sample.xlsx"

# 練習用のExcelファイルを作成
with pd.ExcelWriter(file_path, engine="openpyxl") as writer:
    sales_df.to_excel(writer, sheet_name="売上データ", index=False)
    master_df.to_excel(writer, sheet_name="商品マスタ", index=False)

    # 説明行が上にあるExcelを再現するため、3行目から表を書き込む
    sales_df.to_excel(writer, sheet_name="説明行あり", index=False, startrow=2)
    ws = writer.sheets["説明行あり"]
    ws["A1"] = "2025年4月 売上レポート"
    ws["A2"] = "※この行は説明行です。"

file_path

'sales_sample.xlsx'

df = pd.read_excel("sales_sample.xlsx")
df

df.head()

df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 3 entries, 0 to 2
Data columns (total 5 columns):
 #   Column  Non-Null Count  Dtype 
---  ------  --------------  ----- 
 0   売上日     3 non-null      object
 1   店舗      3 non-null      object
 2   商品      3 non-null      object
 3   売上金額    3 non-null      int64 
 4   数量      3 non-null      int64 
dtypes: int64(2), object(3)
memory usage: 252.0+ bytes

df.describe()

sales = pd.read_excel("sales_sample.xlsx", sheet_name="売上データ")
sales

master = pd.read_excel("sales_sample.xlsx", sheet_name="商品マスタ")
master

pd.read_excel("sales_sample.xlsx", sheet_name=0)

sales_selected = pd.read_excel(
    "sales_sample.xlsx",
    sheet_name="売上データ",
    usecols=["売上日", "店舗", "売上金額"]
)

sales_selected

raw = pd.read_excel("sales_sample.xlsx", sheet_name="説明行あり", header=None)
raw.head(7)

df_header = pd.read_excel(
    "sales_sample.xlsx",
    sheet_name="説明行あり",
    header=2
)

df_header

df_skiprows = pd.read_excel(
    "sales_sample.xlsx",
    sheet_name="説明行あり",
    skiprows=2
)

df_skiprows

sales_index = pd.read_excel(
    "sales_sample.xlsx",
    sheet_name="売上データ",
    index_col="売上日"
)

sales_index

sales_index.reset_index()

df = pd.read_excel("sales_sample.xlsx", sheet_name="売上データ")

# 分析しやすい形になったDataFrameをCSVとして保存する
df.to_csv("sales_sample.csv", index=False)

df_csv = pd.read_csv("sales_sample.csv")
df_csv.head()

pd.read_csv("sales_sample.xlsx")

# openpyxlが必要というエラーが出る場合のみ実行します
# Google Colabでは、すでに使える場合もあります

# !pip install openpyxl

sales_clean = pd.read_excel("sales_sample.xlsx", sheet_name="売上データ")

# 列名を扱いやすくする
sales_clean = sales_clean.rename(columns={
    "売上金額": "金額"
})

# 売上日を日付型に変換する
sales_clean["売上日"] = pd.to_datetime(sales_clean["売上日"])

sales_clean.head()

sales_clean.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 3 entries, 0 to 2
Data columns (total 5 columns):
 #   Column  Non-Null Count  Dtype         
---  ------  --------------  -----         
 0   売上日     3 non-null      datetime64[ns]
 1   店舗      3 non-null      object        
 2   商品      3 non-null      object        
 3   金額      3 non-null      int64         
 4   数量      3 non-null      int64         
dtypes: datetime64[ns](1), int64(2), object(2)
memory usage: 252.0+ bytes

<p>The post pandas read_excel()の使い方｜Excelファイル読み込み・sheet_name・usecolsを解説 first appeared on Python Data Lab（Pythonデータラボ）.</p>