DataFrame の行・列の基本操作

PySpark は、分散処理フレームワーク Apache Spark の Python 用 API です。PySpark では、DataFrame というデータ構造を使用します。

この記事では PySpark で DataFrame の行や列を操作する方法を紹介します。

行 (Rows) の操作

DataFrame の作成

操作の説明するための DataFrame を以下のように作成します。以降の操作は、この DataFrame をベースにして説明します。

from pyspark.sql import SparkSession
from pyspark.sql.types import StructType, StructField, StringType, IntegerType, FloatType

# SparkSessionの初期化
spark = SparkSession.builder.appName("ColumnsOperation").getOrCreate()

# スキーマを定義
schema = StructType([
    StructField("Firstname", StringType(), True),
    StructField("Lastname", StringType(), True),
    StructField("Gender", StringType(), True),
    StructField("Age", IntegerType(), True),
    StructField("Department", StringType(), True),
    StructField("Salary", IntegerType(), True),    
])
# データを作成
data = [
    ("James", "Smith", "M", 30, "Sales", 3000),
    ("Anna", "Rose", "F", 41, "Engineering", 4000),
    ("Robert", "Williams", "M", 62, "Logistics", 5000),
]
# データフレームの作成
df = spark.createDataFrame(data, schema=schema)
df.printSchema()
df.show()

【実行結果】
root
 |-- Firstname: string (nullable = true)
 |-- Lastname: string (nullable = true)
 |-- Gender: string (nullable = true)
 |-- Age: integer (nullable = true)
 |-- Department: string (nullable = true)
 |-- Salary: integer (nullable = true)

+---------+--------+------+---+-----------+------+
|Firstname|Lastname|Gender|Age| Department|Salary|
+---------+--------+------+---+-----------+------+
|    James|   Smith|     M| 30|      Sales|  3000|
|     Anna|    Rose|     F| 41|Engineering|  4000|
|   Robert|Williams|     M| 62|  Logistics|  5000|
+---------+--------+------+---+-----------+------+

なお、処理完了後には SparkSession を終了しますが説明では省略します。

# SparkSessionを終了
spark.stop()

以降では、上記で作成した DataFrame を使って行の基本操作を説明します。

行の追加 union

DataFrame に行を追加する際は union を使用します。

# ===== 行の追加 union
# 追加する行を作成
new_data = [
    ("Michael", "Brown", "M", 34, "Sales", 3500),
    ("Maria", "Garcia", "F", 20, "Engineering", 2000),
    ("Mary", "Smith", "F", 25, "Accounting", 2500),
]
new_row = spark.createDataFrame(new_data, schema)
# データフレームに追加
df = df.union(new_row)
df.show()

【実行結果】
+---------+--------+------+---+-----------+------+
|Firstname|Lastname|Gender|Age| Department|Salary|
+---------+--------+------+---+-----------+------+
|    James|   Smith|     M| 30|      Sales|  3000|
|     Anna|    Rose|     F| 41|Engineering|  4000|
|   Robert|Williams|     M| 62|  Logistics|  5000|
|  Michael|   Brown|     M| 34|      Sales|  3500|
|    Maria|  Garcia|     F| 20|Engineering|  2000|
|     Mary|   Smith|     F| 25| Accounting|  2500|
+---------+--------+------+---+-----------+------+

例では、まず new_data をもとにして new_row という DataFrame を作成しています。データフレームに行を追加するには union メソッドに作成した DataFrame を渡します。

注意点として union は「結合する 2 つのDataFrameのスキーマが完全に一致していること」が必要です。スキーマが異なる場合は、エラーとなるので注意しましょう。

条件をもとに行を抽出 filter / where

条件をもとに行を抽出する場合には、filter または where を使用します。

# ===== 条件をもとに行を抽出 filter/where
# filterで式で抽出
df_filter = df.filter(df.Age > 30)
df_filter.show()
# filterで文字列条件で抽出
df_filter = df.filter("Age > 30")
df_filter.show()

# --- whereはfilterのエイリアスとなっている
# whereで式で抽出
df_where = df.where(df.Age > 30)
df_where.show()

# whereで文字列条件で抽出
df_where = df.where("Age > 30")
df_where.show()

【実行結果】複数回出力しているがいずれも出力結果は同じ
+---------+--------+------+---+-----------+------+
|Firstname|Lastname|Gender|Age| Department|Salary|
+---------+--------+------+---+-----------+------+
|     Anna|    Rose|     F| 41|Engineering|  4000|
|   Robert|Williams|     M| 62|  Logistics|  5000|
|  Michael|   Brown|     M| 34|      Sales|  3500|
+---------+--------+------+---+-----------+------+

抽出されている実行結果はいずれも同じです。filter と where は同じものになるためどちらを使うかは開発者次第です。実際に、公式ドキュメントにも「where() is an alias for filter().」というように、where は filter の別名（エイリアス）と記載されていますので、いずれを使っても構いません。

条件指定の方法は「df.Age > 30」のように条件式を指定する方法と「"Age > 30"」のように SQL の条件文字列として指定する方法が使用できます。

行の削除 filter

行の削除をしたい場合には、filter で削除対象の行を除いた DataFrame を作ることで実現します。

# ===== 行の削除 filter
# 行を削除
df = df.filter(df.Firstname != "Michael")
df.show()

【実行結果】
+---------+--------+------+---+-----------+------+
|Firstname|Lastname|Gender|Age| Department|Salary|
+---------+--------+------+---+-----------+------+
|    James|   Smith|     M| 30|      Sales|  3000|
|     Anna|    Rose|     F| 41|Engineering|  4000|
|   Robert|Williams|     M| 62|  Logistics|  5000|
|    Maria|  Garcia|     F| 20|Engineering|  2000|
|     Mary|   Smith|     F| 25| Accounting|  2500|
+---------+--------+------+---+-----------+------+

上記例では Firstname が "Micahel" でない行のみを抽出しています。これは、Firstname が "Micahel" である行を削除していることと同じです。

行の並べ替え sort / orderBy　

DataFrame の行を並べ替えたい場合には sort または orderBy を使用します。

# ===== 行の並び替え sort/orderBy
# === sortで並び替え
print("===== sort")
# 昇順
df_sort = df.sort(df.Age)
df_sort.show()

# 降順
df_sort = df.sort(df.Age.desc())
df_sort.show()

# 複数列による並び替え
df_sort = df.sort(df.Age, df.Salary.desc())
df_sort.show()

# === orderByで並び替え
print("===== orderBy")
# 昇順
df_orderby = df.orderBy(df.Age)
df_orderby.show()

# 降順
df_orderby = df.orderBy(df.Age.desc())
df_orderby.show()

# 複数条件を指定
df_orderby = df.orderBy(df.Age, df.Salary.desc())
df_orderby.show()

【実行結果】sortもorderByも出力結果は同じ
+---------+--------+------+---+-----------+------+
|Firstname|Lastname|Gender|Age| Department|Salary|
+---------+--------+------+---+-----------+------+
|    Maria|  Garcia|     F| 20|Engineering|  2000|
|     Mary|   Smith|     F| 30| Accounting|  2500|
|    James|   Smith|     M| 30|      Sales|  3000|
|  Michael|   Brown|     M| 34|      Sales|  3500|
|     Anna|    Rose|     F| 41|Engineering|  4000|
|   Robert|Williams|     M| 62|  Logistics|  5000|
+---------+--------+------+---+-----------+------+

+---------+--------+------+---+-----------+------+
|Firstname|Lastname|Gender|Age| Department|Salary|
+---------+--------+------+---+-----------+------+
|   Robert|Williams|     M| 62|  Logistics|  5000|
|     Anna|    Rose|     F| 41|Engineering|  4000|
|  Michael|   Brown|     M| 34|      Sales|  3500|
|     Mary|   Smith|     F| 30| Accounting|  2500|
|    James|   Smith|     M| 30|      Sales|  3000|
|    Maria|  Garcia|     F| 20|Engineering|  2000|
+---------+--------+------+---+-----------+------+

+---------+--------+------+---+-----------+------+
|Firstname|Lastname|Gender|Age| Department|Salary|
+---------+--------+------+---+-----------+------+
|    Maria|  Garcia|     F| 20|Engineering|  2000|
|    James|   Smith|     M| 30|      Sales|  3000|
|     Mary|   Smith|     F| 30| Accounting|  2500|
|  Michael|   Brown|     M| 34|      Sales|  3500|
|     Anna|    Rose|     F| 41|Engineering|  4000|
|   Robert|Williams|     M| 62|  Logistics|  5000|
+---------+--------+------+---+-----------+------+

sort と orderBy の使い方は同じです。上記例のように sort や orderBy の引数に df.Age といった並び替えのキーとなる列を指定することで並び替えができます。デフォルトは昇順となります。

降順にしたい場合には、指定する際に df.Age.desc() のように降順にする desc メソッドを指定します。また、複数列により並び替えを行う場合には、引数に (df.Age, df.Salary.desc()) のように指定することで実現できます。例では、第 1 キーとして Age 列で昇順に並び替え、第 2 キーとして Salary 列で降順に並び替えます。

なお、以下のように文字列で列名を指定することも可能です。

from pyspark.sql.functions import col

# 昇順
df_sort = df.sort("Age")

# 降順
df_sort = df.sort(col("Age").desc())

# 複数列による並び替え
df_sort = df.sort("Age", col("Salary").desc())

文字列で指定する場合で、降順に指定する際には pyspark.sql.functions から col をインポートして指定することでメソッドを使用することが可能です。

行のグループ化 groupBy

行のグループ化して集約するには、groupBy を使用します。

# ===== 行のグループ化 groupBy
# グループ化して行をカウント
df_groupby_count = df.groupBy("Department").count()
df_groupby_count.show()

# グループ化して最大値を計算
df_groupby_max = df.groupBy("Department").max()
df_groupby_max.show()

【実行結果】
+-----------+-----+
| Department|count|
+-----------+-----+
|      Sales|    2|
|Engineering|    2|
|  Logistics|    1|
| Accounting|    1|
+-----------+-----+

+-----------+--------+-----------+
| Department|max(Age)|max(Salary)|
+-----------+--------+-----------+
|      Sales|      34|       3500|
|Engineering|      41|       4000|
|  Logistics|      62|       5000|
| Accounting|      30|       2500|
+-----------+--------+-----------+

例のように groupBy の引数にグループ化する列名を指定します。その後、count() や max() のような集約関数を適用することで、グループごとの集約が可能です。なお、groupBy() の別名（エイリアス）として groupby() を使うことも可能です。

行の重複削除 dropDuplicates

重複する行を削除したい場合には、dropDuplicates を使用します。

# 行の重複削除 dropDuplicates
# 重複行を追加
new_row = spark.createDataFrame([
    ("Michael", "Brown", "M", 34, "Sales", 3500),
    ("Maria", "Garcia", "F", 20, "Engineering", 2000),
    ("Mary", "Smith", "F", 30, "Accounting", 2500),
], schema)
# データフレームに追加
df_temp = df.union(new_row)
df_temp.show()

# ==== 重複行を削除
print("===== dropDuplicates")
# すべての列が重複するものを削除
df_drop = df_temp.dropDuplicates()
df_drop.show()

# 指定の列で重複する行を削除
df_drop = df_temp.dropDuplicates(["Lastname"])
df_drop.show()

# 複数列で重複する行を削除
df_drop = df_temp.dropDuplicates(["Firstname", "Lastname"])
df_drop.show()

【実行結果】
+---------+--------+------+---+-----------+------+
|Firstname|Lastname|Gender|Age| Department|Salary|
+---------+--------+------+---+-----------+------+
|    James|   Smith|     M| 30|      Sales|  3000|
|     Anna|    Rose|     F| 41|Engineering|  4000|
|   Robert|Williams|     M| 62|  Logistics|  5000|
|  Michael|   Brown|     M| 34|      Sales|  3500|
|    Maria|  Garcia|     F| 20|Engineering|  2000|
|     Mary|   Smith|     F| 30| Accounting|  2500|
|  Michael|   Brown|     M| 34|      Sales|  3500|
|    Maria|  Garcia|     F| 20|Engineering|  2000|
|     Mary|   Smith|     F| 30| Accounting|  2500|
+---------+--------+------+---+-----------+------+

===== dropDuplicates
+---------+--------+------+---+-----------+------+
|Firstname|Lastname|Gender|Age| Department|Salary|
+---------+--------+------+---+-----------+------+
|    James|   Smith|     M| 30|      Sales|  3000|
|     Anna|    Rose|     F| 41|Engineering|  4000|
|   Robert|Williams|     M| 62|  Logistics|  5000|
|  Michael|   Brown|     M| 34|      Sales|  3500|
|    Maria|  Garcia|     F| 20|Engineering|  2000|
|     Mary|   Smith|     F| 30| Accounting|  2500|
+---------+--------+------+---+-----------+------+

+---------+--------+------+---+-----------+------+
|Firstname|Lastname|Gender|Age| Department|Salary|
+---------+--------+------+---+-----------+------+
|  Michael|   Brown|     M| 34|      Sales|  3500|
|    Maria|  Garcia|     F| 20|Engineering|  2000|
|     Anna|    Rose|     F| 41|Engineering|  4000|
|    James|   Smith|     M| 30|      Sales|  3000|
|   Robert|Williams|     M| 62|  Logistics|  5000|
+---------+--------+------+---+-----------+------+

+---------+--------+------+---+-----------+------+
|Firstname|Lastname|Gender|Age| Department|Salary|
+---------+--------+------+---+-----------+------+
|     Anna|    Rose|     F| 41|Engineering|  4000|
|    James|   Smith|     M| 30|      Sales|  3000|
|    Maria|  Garcia|     F| 20|Engineering|  2000|
|     Mary|   Smith|     F| 30| Accounting|  2500|
|  Michael|   Brown|     M| 34|      Sales|  3500|
|   Robert|Williams|     M| 62|  Logistics|  5000|
+---------+--------+------+---+-----------+------+

例では、重複する行を union で追加して、その後 dropDuplicates で重複行を削除しています。引数を指定しないで dropDuplicates を指定する場合、すべての列が重複するような行が削除されます。

特定の列で重複削除したい場合は ["Lastname"] のように列を指定できます。複数列で重複を確認したい場合は ["Firstname", "Lastname"] のように列名を列挙します。

なお、dropDuplicates() の別名（エイリアス）として drop_duplicates() を使うことも可能です。

列 (Columns) の基本操作

DataFrame の作成

列の操作を説明するための DataFrame を以下のように作成します。以降の列操作は、この DataFrame をベースにして説明します。

from pyspark.sql import SparkSession
from pyspark.sql.types import StructType, StructField, StringType, IntegerType, FloatType

# SparkSessionの初期化
spark = SparkSession.builder.appName("ColumnsOperation").getOrCreate()

# スキーマを定義
schema = StructType([
    StructField("Firstname", StringType(), True),
    StructField("Lastname", StringType(), True),
    StructField("Gender", StringType(), True),
    StructField("Age", IntegerType(), True),
    StructField("Department", StringType(), True),
    StructField("Salary", IntegerType(), True),    
])
# データを作成
data = [
    ("James", "Smith", "M", 30, "Sales", 3000),
    ("Anna", "Rose", "F", 41, "Engineering", 4000),
    ("Robert", "Williams", "M", 62, "Logistics", 5000),
]
# データフレームの作成
df = spark.createDataFrame(data, schema=schema)
df.printSchema()
df.show()

【実行結果】
root
 |-- Firstname: string (nullable = true)
 |-- Lastname: string (nullable = true)
 |-- Gender: string (nullable = true)
 |-- Age: integer (nullable = true)
 |-- Department: string (nullable = true)
 |-- Salary: integer (nullable = true)

+---------+--------+------+---+-----------+------+
|Firstname|Lastname|Gender|Age| Department|Salary|
+---------+--------+------+---+-----------+------+
|    James|   Smith|     M| 30|      Sales|  3000|
|     Anna|    Rose|     F| 41|Engineering|  4000|
|   Robert|Williams|     M| 62|  Logistics|  5000|
+---------+--------+------+---+-----------+------+

以降では、上記で作成したデータフレームを使って列の基本操作を説明します。

列の追加 withColumn

列を追加したい場合は、withColumn を使用します。

from pyspark.sql.functions import lit

#===== 列の追加 withColumn
# 定数列を追加
df = df.withColumn("Country", lit("USA"))
df = df.withColumn("Rate", lit(1.1).cast(FloatType()))
df.printSchema()
df.show()

【実行結果】
root
 |-- Firstname: string (nullable = true)
 |-- Lastname: string (nullable = true)
 |-- Gender: string (nullable = true)
 |-- Age: integer (nullable = true)
 |-- Department: string (nullable = true)
 |-- Salary: integer (nullable = true)
 |-- Country: string (nullable = false)
 |-- Rate: float (nullable = false)

+---------+--------+------+---+-----------+------+-------+----+
|Firstname|Lastname|Gender|Age| Department|Salary|Country|Rate|
+---------+--------+------+---+-----------+------+-------+----+
|    James|   Smith|     M| 30|      Sales|  3000|    USA| 1.1|
|     Anna|    Rose|     F| 41|Engineering|  4000|    USA| 1.1|
|   Robert|Williams|     M| 62|  Logistics|  5000|    USA| 1.1|
+---------+--------+------+---+-----------+------+-------+----+

例のように withColumn には、列名と値を渡します。pyspark.sql.functions からインポートできる lit を使うと定数値列を作成できます。lit はリテラルの意味です。

また、指定した型で作成したい場合は cast を使って型指定できます。上記例では 1.1 という数値を FloatType() として作成しています。

列の名称変更 withColumnRenamed

列の名称変更をしたい場合は、withColumnRenamed を使用します。

# ===== 列の名称変更 withColumnRenamed
df = df.withColumnRenamed("Department", "Dept")
df.printSchema()
df.show()

【実行結果】
root
 |-- Firstname: string (nullable = true)
 |-- Lastname: string (nullable = true)
 |-- Gender: string (nullable = true)
 |-- Age: integer (nullable = true)
 |-- Dept: string (nullable = true)
 |-- Salary: integer (nullable = true)
 |-- Country: string (nullable = false)
 |-- Rate: float (nullable = false)

+---------+--------+------+---+-----------+------+-------+----+
|Firstname|Lastname|Gender|Age|       Dept|Salary|Country|Rate|
+---------+--------+------+---+-----------+------+-------+----+
|    James|   Smith|     M| 30|      Sales|  3000|    USA| 1.1|
|     Anna|    Rose|     F| 41|Engineering|  4000|    USA| 1.1|
|   Robert|Williams|     M| 62|  Logistics|  5000|    USA| 1.1|
+---------+--------+------+---+-----------+------+-------+----+

withColumnRenamed の引数として、変更前の列名と変更後の列名を指定することで列名を変更できます。例では、Department 列を Dept という省略形に変更しています。

列の削除 drop

列自体を削除したい場合は、drop を使用します。

# ===== 列の削除 drop
df = df.drop("Country")
df.printSchema()
df.show()

【実行結果】
root
 |-- Firstname: string (nullable = true)
 |-- Lastname: string (nullable = true)
 |-- Gender: string (nullable = true)
 |-- Age: integer (nullable = true)
 |-- Dept: string (nullable = true)
 |-- Salary: integer (nullable = true)
 |-- Rate: float (nullable = false)

+---------+--------+------+---+-----------+------+----+
|Firstname|Lastname|Gender|Age|       Dept|Salary|Rate|
+---------+--------+------+---+-----------+------+----+
|    James|   Smith|     M| 30|      Sales|  3000| 1.1|
|     Anna|    Rose|     F| 41|Engineering|  4000| 1.1|
|   Robert|Williams|     M| 62|  Logistics|  5000| 1.1|
+---------+--------+------+---+-----------+------+----+

drop で対象列を指定することで列情報を削除できます。例では、Country 列を削除しています。

列の選択 select

特定列だけを選択したい場合には、select を使用します。

# ===== 列の選択 select
df_selected = df.select(["Firstname", "Age"])
df_selected.printSchema()
df_selected.show()

【実行結果】
root
 |-- Firstname: string (nullable = true)
 |-- Age: integer (nullable = true)

+---------+---+
|Firstname|Age|
+---------+---+
|    James| 30|
|     Anna| 41|
|   Robert| 62|
+---------+---+

例のように select に抽出したい特定の列を列挙したリストを渡すことで、列選択をすることが可能です。

式の適用 expr

列の操作をする際には、いくつかの列を使って計算をしたくなることがよくあります。このような場合には、expr を使用すると便利です。

from pyspark.sql.functions import expr

# ===== 式の適用 expr
df = df.withColumn("Increased Salary", expr("Salary * Rate"))
df.printSchema()
df.show()

【実行結果】
root
 |-- Firstname: string (nullable = true)
 |-- Lastname: string (nullable = true)
 |-- Gender: string (nullable = true)
 |-- Age: integer (nullable = true)
 |-- Dept: string (nullable = true)
 |-- Salary: integer (nullable = true)
 |-- Rate: float (nullable = false)
 |-- Increased Salary: float (nullable = true)

+---------+--------+------+---+-----------+------+----+----------------+
|Firstname|Lastname|Gender|Age|       Dept|Salary|Rate|Increased Salary|
+---------+--------+------+---+-----------+------+----+----------------+
|    James|   Smith|     M| 30|      Sales|  3000| 1.1|          3300.0|
|     Anna|    Rose|     F| 41|Engineering|  4000| 1.1|          4400.0|
|   Robert|Williams|     M| 62|  Logistics|  5000| 1.1|          5500.0|
+---------+--------+------+---+-----------+------+----+----------------+

expr では、文字列を用いて SQL の式を指定できます。上記で紹介した withColumn と一緒に使うことで、計算式を適用した列を簡単に作成可能です。

まとめ

PySpark において DataFrame の行や列を操作する方法について解説しました。

PySpark では、分散処理環境を使ってデータ分析を効率的に実行することが可能です。DataFrame の行や列の操作は、各種分析などを進めていくにあたっての基本となります。この記事では、行や列に対する基本操作について各種紹介しました。

各種使い方をしっかり覚えて、効率的なデータ分析に活用してもらいたいと思います。

あわせて読みたい

【Python Tech】プログラミングガイド

pivot_tableによるピボットテーブルの作成

表形式のデータを扱う際に良く行われる操作としてピボットテーブルがあります。ピボットテーブルは主にExcel等の表計算やDB管理で使用される視覚化ツールです。データの分類や整理、集約といったことが効率的にできるとともに、視覚的にデータの構造を理解しやすくなります。

pandasのDataFrameではピボットテーブルを作成するためにpivot_tableという便利な関数が用意されています。本記事ではpivot_tableの基本的な使用方法を紹介します。

以降でpivot_tableの使い方を紹介するために、以下の簡単なcsvデータを用います。想定するのは企業での売上一覧データで、各製品がいつ、どこに、いくらで売られたかをまとめているものをイメージしてください。このデータを使って、製品ごと、顧客ごと等で整理したピボットテーブルを作る例を紹介していきます。

基本的なpivot_tableの使い方

上記で説明したサンプルデータ(sample.csv)を読み込み、各製品ごとの各月売上合計となる以下のようなピボットテーブルを作ってみることを考えてみます。

DataFrameのデータに対してpivot_tableを使ってピボットテーブルを作るには以下のようにします。

【sample.csv】

no,product_code,client,date,price
1,A,顧客1,2022/03/01,1000
2,A,顧客2,2022/03/01,1000
3,B,顧客1,2022/03/01,500
4,B,顧客1,2022/03/01,500
5,C,顧客1,2022/03/01,2000
6,A,顧客2,2022/03/15,1000
7,A,顧客2,2022/03/15,1000
8,C,顧客3,2022/03/15,2000
9,B,顧客2,2022/03/31,500
10,B,顧客2,2022/03/31,500
11,B,顧客2,2022/03/31,500
12,A,顧客1,2022/04/01,1000
13,A,顧客1,2022/04/01,1000
14,B,顧客1,2022/04/01,500
15,C,顧客1,2022/04/10,2000
16,C,顧客3,2022/04/10,2000
17,C,顧客3,2022/04/10,2000
18,A,顧客1,2022/04/30,1000
19,A,顧客2,2022/04/30,1000
20,B,顧客1,2022/04/30,500

【pivot_tableの使用方法】

import pandas as pd

# ===== サンプルデータの読み込み
df = pd.read_csv('sample.csv')
# print(df)
# print(df.dtypes)

# ===== データ加工
# 日付列をdatetimeに変更
df['date'] = pd.to_datetime(df['date'])
# 年・月・日の列を作成
df['year'] = df['date'].dt.year
df['month'] = df['date'].dt.month
df['day'] = df['date'].dt.day

# ===== pivot_table
pt = df.pivot_table('price',
                    index='product_code',
                    columns='month',
                    aggfunc='sum')
print(pt)

【実行結果】
month            3     4
product_code            
A             4000  4000
B             2500  1000
C             4000  6000

サンプルデータ読込ではpandasのread_csv関数を使用しています。データの内容を確認したい場合は、コメントアウトしているprintのコメントを外して確認してみてください。

年月日の情報を使用したいため、日付列をto_datetime関数で変換した後に「年("year")」「月("month")」「日("day")」に該当する列情報を事前に作成しています。

ピボットテーブルを作るためにpivot_tableを使用している部分は以下の部分です。

# ===== pivot_table
pt = df.pivot_table('price',
                    index='product_code',
                    columns='month',
                    aggfunc='sum')

まずは集約する価格("price"）を指定します。次にインデックス(index=)で製品コード("product_code")、列(columns=)で月("month")を順に指定しています。これによりピボットテーブルにおける行方向と列方向の種類が決まります。

次に指定している集約関数(aggfunc=)では、集約するときに使用する関数を指定します。今回は合計するための"sum"を指定しています。aggfuncのデフォルト設定は平均("mean")になっていますのでaggfuncを指定しない場合には平均が計算されます。aggfuncには他にも"count"、"min"、"max"などが指定できます。

上記のようにpivot_tableを使用することで簡単にピボットテーブルを作成することが可能です。

多重ピボットテーブル（複数レベルの指定）

上記ではシンプルなピボットテーブルの例を見てきました。今度は、複数レベルを指定して多重のピボットテーブルを作る例を見てみましょう。

具体的には、以下のように行方向は「製品コード("product_code")」「顧客("client")」の順の階層で、列方向は「年("year")」「月("month")」「日("day")」の順の階層で価格の合計を整理してみます。

複数レベルを指定してpivot_tableを使った多重ピボットテーブルを作るには以下のようにします。

import pandas as pd

# ===== サンプルデータの読み込み
df = pd.read_csv('sample.csv')
# print(df)
# print(df.dtypes)

# ===== データ加工
# 日付列をdatetimeに変更
df['date'] = pd.to_datetime(df['date'])
# 年・月・日の列を作成
df['year'] = df['date'].dt.year
df['month'] = df['date'].dt.month
df['day'] = df['date'].dt.day

# ===== pivot_table（複数レベルでの指定）
pt = df.pivot_table('price',
                    index=['product_code', 'client'],
                    columns=['year', 'month', 'day'],
                    aggfunc='sum')
# NaN部分を0で埋めて表示
print(pt.fillna(0))

【実行結果】
year                   2022                                        
month                     3                       4                
day                      1       15      31      1       10      30
product_code client                                                
A            顧客1     1000.0     0.0     0.0  2000.0     0.0  1000.0
             顧客2     1000.0  2000.0     0.0     0.0     0.0  1000.0
B            顧客1     1000.0     0.0     0.0   500.0     0.0   500.0
             顧客2        0.0     0.0  1500.0     0.0     0.0     0.0
C            顧客1     2000.0     0.0     0.0     0.0  2000.0     0.0
             顧客3        0.0  2000.0     0.0     0.0  4000.0     0.0

データ加工で年・月・日等の列を事前に用意しているところは、先ほど紹介の例と同様です。ピボットテーブルを作るためにpivot_tableを使用している部分は以下の部分になります。

# ===== pivot_table（複数レベルでの指定）
pt = df.pivot_table('price',
                    index=['product_code', 'client'],
                    columns=['year', 'month', 'day'],
                    aggfunc='sum')

基本的な使い方は先ほどの例と同様ですが、異なるのはindex=とcolumns=で各階層になる列名をリストで順に指定している部分です。

このようにpivot_tableの引数の指定方法を少し変えるだけで、複数レベルの階層で集約したピボットテーブルも簡単に作ることが可能です。

[参考] groupbyでピボットテーブルを作成する方法

pivot_tableの使用方法について紹介しました。ピボットテーブルは集約の考え方を使っているためgroupbyを使用してピボットテーブルを実現することももちろん可能です。

groupbyの基本的な使い方については「DataFrameをgroupbyでグループ化して集約する方法」でまとめていますので参考にしてください。

ピボットテーブルは、groupbyでの集計の多次元集計版ともいえる方法なのでgroupbyで実現できます。これまでにpivot_tableにて実現した処理と同じ動作をするgroupbyでの実装例は以下のようになります。

import pandas as pd

# ===== サンプルデータの読み込み
df = pd.read_csv('sample.csv')
# print(df)
# print(df.dtypes)

# ===== データ加工
# 日付列をdatetimeに変更
df['date'] = pd.to_datetime(df['date'])
# 年・月・日の列を作成
df['year'] = df['date'].dt.year
df['month'] = df['date'].dt.month
df['day'] = df['date'].dt.day

# マニュアルでpivot_tableを作成
print(df.groupby(['product_code', 'month'])['price'].sum().unstack())

【実行結果】
month            3     4
product_code            
A             4000  4000
B             2500  1000
C             4000  6000

ピボットテーブルを作るためにgroupbyを使った加工をしているのは以下の部分になります。

# マニュアルでpivot_tableを作成
print(df.groupby(['product_code', 'month'])['price'].sum().unstack())

この部分では、groupbyでまず製品コード("product_code")と月("month")を指定してグループを作成し、グループの中から価格("price")列に対してsum()による合計を出しています。sum()までのコードでは以下のDataFrameが出来上がっています。

product_code  month
A             3        4000
              4        4000
B             3        2500
              4        1000
C             3        4000
              4        6000

このDataFrameに対してunstack()によりmonth列の部分を列方向に展開することでピボットテーブルの結果と同じような結果を取得しています。1行で書いてしまうと途中の処理が分からないという方は途中まででprint表示しつつ確認してみると分かりやすいでしょう。

このようにgroupbyを使ってもピボットテーブルは作成可能です。ただし、コードは少し読みにくく、直感的には何をしているか分かりにくいと感じられるかなと思います。pivot_tableを使用する方が簡潔に処理を記載できるのでpivot_tableの使い方は是非覚えていただけるとよいかと思います。

まとめ

pandasのDataFrameでpivot_tableを使ってピボットテーブルを扱う方法について解説しました。

表形式のデータを扱う際に良く行われる操作としてピボットテーブルを使うとで他の分類や集約した状況を視覚的に確認することができます。pandasでは、pivot_tableで簡単に作成できますので、例を使って紹介しました。

また、groupbyを使ってもピボットテーブルを作成できるものの、pivot_tableの方がより簡単にピボットテーブルが作成できることを見ていただきました。

ピボットテーブルはデータの状況を確認、分析する際によく使用するツールです。pandasでも簡単に作成できますので、是非使い方を覚えてもらえればと思います。

あわせて読みたい

【Python Tech】プログラミングガイド

groupbyによる集約

pandasのDataFrameでデータ分析をする際には、合計や平均等の集約処理をすることがよくあります。データの集約の際には、単純にDataFrame全体に対して集約処理をするだけでなく、ある意味を持ったグループ単位で集約処理をすることでデータに対する有益な情報を得ることができます。

SQLを少し学んだことがある人であれば「groupby」がすぐに頭に浮かぶと思いますが、pandasのDataFrameでも同様にgroupbyによる集約処理が可能です。本記事では、pandasのDataFrameをgroupbyでグループ化して集約する方法について基本的な方法を紹介します。

以降では、以下の簡単なデータを用いてpandasのDataFrameでどのようにgroupbyによる集約ができるのかを説明していきます。

上記データのイメージは、製造業で各シリアルナンバーごとに蓄積されている品質データです。データとしては、各シリアル(serial_no)に対して、品質項目１(quality_val1)と品質項目２(quality_val2)の値を持っているような表です。

品目(item_code)は各製品の種類を表すような区分になりますが、今回はこの品目(item_code)をキーにしてグループ化し、各品質データを集約をするということを考えてみようと思います。

groupbyの集約の考え方
「分割(split) – 適用(apply) – 結合(combine)」

groupbyによる集約では「分割(split) – 適用(apply) – 結合(combine)」に分けて処理がされているということを理解してほしいと思います。以下の図を見てみてください。

この例は今回のサンプルデータに対してitem_codeをキーとしてgroupbyする際の処理の適用イメージです。

groupbyでの処理は大きく以下のような手順で実行されています。

上記のような図をイメージしてもらいつつ、以降の具体例を見ていくと、データ処理をイメージしやすいかと思います。では、pandasのgroupbyを使って集約処理を具体的にどのようにコーディングするか、例を使って見ていきましょう。

groupbyによるDataFrameの集約

groupbyによるDataFrameの集約の基本的な使い方

groupbyによるDataFrameの集約の基本的な使い方は以下のようになります。

import pandas as pd

quality_result = pd.DataFrame(
    {'serial_no': ['S001', 'S002', 'S003', 'S004', 'S005',
                   'S006', 'S007', 'S008', 'S009', 'S010'],
     'item_code': ['A', 'A', 'B', 'B', 'C', 'A', 'A', 'B', 'C', 'C'],
     'quality_val1': [100, 150, 20, 10, 50, 120, 80, 5, 55, 40],
     'quality_val2': [1, 2, 100, 120, 20, 5, 7, 90, 10, 10]}
)
print(quality_result, '\n')

# item_codeでグループ化
gr = quality_result.groupby('item_code')
print(gr, '\n')

# グループごとに集約を計算
# print(quality_result.groupby('item_code').sum())
print(gr.sum())

【実行結果】
  serial_no item_code  quality_val1  quality_val2
0      S001         A           100             1
1      S002         A           150             2
2      S003         B            20           100
3      S004         B            10           120
4      S005         C            50            20
5      S006         A           120             5
6      S007         A            80             7
7      S008         B             5            90
8      S009         C            55            10
9      S010         C            40            10 

<pandas.core.groupby.generic.DataFrameGroupBy object at 0x000001A31B0E3EE0> 

           quality_val1  quality_val2
item_code                            
A                   450            15
B                    35           310
C                   145            40

対象となるDataFrameのgroupbyメソッドにキーとなる列名を与えることで、DataFrameGroupByオブジェクト(pandas.core.groupby.generic.DataFrameGroupBy)が生成されます。今回の例では、item_codeを集約のキーとして与えています。

このDataFrameGroupByオブジェクトは分割(split)の処理までがされているものになっているので、当該DataFrameGroupByオブジェクトに対して集約メソッドを実行することで後続の適用(apply)、結合(coｍbine)が処理され、グループ単位の集約処理が実行できます。

上記例では一度分割までされている情報をgrという変数に入れ、合計のsumを呼び出しています。もちろん、quality_result.groupby('item_code').sum()というように一行で書いても問題ありませんが、DataFrameGroupByをオブジェクト化して用意しておけば、sum()以外にもmax()等のような他の集約関数を必要に応じて呼び出すことが可能です。

列名を指定して集約する方法

上記例では、対象となるDataFrame全体に対して処理をしたため、集約メソッドが適用できる列が複数ある場合にはすべての列に対して処理が行われます。今回の例でいうと「quality_val1」「quality_val2」の両方にsumが適用されました。

しかし、実際にはquality_val1の結果のみ必要な場合もあると思います。そのような時にgroupbyオブジェクトは、列インデックスの要領で対象を絞り込んで集約することができます。以下の例で見てみましょう。

import pandas as pd

quality_result = pd.DataFrame(
    {'serial_no': ['S001', 'S002', 'S003', 'S004', 'S005',
                   'S006', 'S007', 'S008', 'S009', 'S010'],
     'item_code': ['A', 'A', 'B', 'B', 'C', 'A', 'A', 'B', 'C', 'C'],
     'quality_val1': [100, 150, 20, 10, 50, 120, 80, 5, 55, 40],
     'quality_val2': [1, 2, 100, 120, 20, 5, 7, 90, 10, 10]}
)
print(quality_result, '\n')

# 列を指定して集約する
print(quality_result.groupby('item_code')['quality_val1'].sum())

【実行結果】
  serial_no item_code  quality_val1  quality_val2
0      S001         A           100             1
1      S002         A           150             2
2      S003         B            20           100
3      S004         B            10           120
4      S005         C            50            20
5      S006         A           120             5
6      S007         A            80             7
7      S008         B             5            90
8      S009         C            55            10
9      S010         C            40            10 

item_code
A    450
B     35
C    145
Name: quality_val1, dtype: int64

上記のように[]で対象となる列名を指定することで対象列を絞って集約メソッドの実行ができます。上記例では、quarlity_val1を指定することで結果としてはquality_val1のみのsum()による集約結果が得られています。

上記結果では、1列だけ取得してきているのでpandasのSeriesオブジェクトになっています。

グループごとに繰り返し処理をする方法

DataFrameGroupByオブジェクトはグループに対する反復をサポートしているため、以下のようにfor文でグループごとに繰り返し処理をすることができます。

import pandas as pd

quality_result = pd.DataFrame(
    {'serial_no': ['S001', 'S002', 'S003', 'S004', 'S005',
                   'S006', 'S007', 'S008', 'S009', 'S010'],
     'item_code': ['A', 'A', 'B', 'B', 'C', 'A', 'A', 'B', 'C', 'C'],
     'quality_val1': [100, 150, 20, 10, 50, 120, 80, 5, 55, 40],
     'quality_val2': [1, 2, 100, 120, 20, 5, 7, 90, 10, 10]}
)
print(quality_result, '\n')

# グループごとに取り出して処理をする
for (item_code, group) in quality_result.groupby('item_code'):
    print(f'item_code: {item_code}')
    print(f'group_data:\n{group}')
    print(f"group['quality_val1'].sum() = {group['quality_val1'].sum()}", '\n')

【実行結果】
  serial_no item_code  quality_val1  quality_val2
0      S001         A           100             1
1      S002         A           150             2
2      S003         B            20           100
3      S004         B            10           120
4      S005         C            50            20
5      S006         A           120             5
6      S007         A            80             7
7      S008         B             5            90
8      S009         C            55            10
9      S010         C            40            10 

item_code: A
group_data:
  serial_no item_code  quality_val1  quality_val2
0      S001         A           100             1
1      S002         A           150             2
5      S006         A           120             5
6      S007         A            80             7
group['quality_val1'].sum() = 450 

item_code: B
group_data:
  serial_no item_code  quality_val1  quality_val2
2      S003         B            20           100
3      S004         B            10           120
7      S008         B             5            90
group['quality_val1'].sum() = 35 

item_code: C
group_data:
  serial_no item_code  quality_val1  quality_val2
4      S005         C            50            20
8      S009         C            55            10
9      S010         C            40            10
group['quality_val1'].sum() = 145 

for文のinにDataFrameGroupByオブジェクトを渡すと「キー」と「グループに該当するDataFrame」が返却されます。for文内当該繰り返しのグループに対するキーがitem_codeに、グループのDataFrameがgroupに入ります。

上記の例では、返却されてきたグループのDataFrameに対して、集約関数のsum()を適用することで合計をとっています。このようにグループごとに処理をしたい場合にもgroupbyは便利に扱うことができます。

集約メソッド

いろいろな集約メソッド

上記の例では、集約処理のメソッドとしてsum()を使った例でgroupbyの使い方を紹介してきました。pandasでは、多くの便利な集約メソッドが用意されています。集約メソッドの中には以下のようなものがあります。必要に応じて選択して使用してください。

便利な集約メソッド describe

いろいろな集約メソッドということで表で紹介しましたが、その中でも便利な集約メソッドとしてdescribeメソッドを実際の例で紹介します。describeメソッドは他の集約メソッドと使い方は同様で以下のように使用することができます。

import pandas as pd

quality_result = pd.DataFrame(
    {'serial_no': ['S001', 'S002', 'S003', 'S004', 'S005',
                   'S006', 'S007', 'S008', 'S009', 'S010'],
     'item_code': ['A', 'A', 'B', 'B', 'C', 'A', 'A', 'B', 'C', 'C'],
     'quality_val1': [100, 150, 20, 10, 50, 120, 80, 5, 55, 40],
     'quality_val2': [1, 2, 100, 120, 20, 5, 7, 90, 10, 10]}
)
print(quality_result, '\n')

# describeメソッド
print(quality_result.groupby('item_code')['quality_val1'].describe())

【実行結果】
  serial_no item_code  quality_val1  quality_val2
0      S001         A           100             1
1      S002         A           150             2
2      S003         B            20           100
3      S004         B            10           120
4      S005         C            50            20
5      S006         A           120             5
6      S007         A            80             7
7      S008         B             5            90
8      S009         C            55            10
9      S010         C            40            10 

           count        mean        std   min   25%    50%    75%    max
item_code                                                               
A            4.0  112.500000  29.860788  80.0  95.0  110.0  127.5  150.0
B            3.0   11.666667   7.637626   5.0   7.5   10.0   15.0   20.0
C            3.0   48.333333   7.637626  40.0  45.0   50.0   52.5   55.0

上記例で見ると分かるように、describeメソッドはcount, mean, std, min, 25%, 50%, 75%, maxというようにデータの特徴を見る際によく確認する項目をまとめて集計してくれます。

まずは、describeを対象データに対して使ってみるだけで、手軽にデータの特徴を確認することができます。

ピボットテーブルの作成

データをグループ化した使う方法としては、ピボットテーブルもあります。ピボットテーブルは、groupbyを用いることで作成可能ですが、pandasでは、pivot_tableメソッドが用意されていて簡単に作成できます。

ピボットテーブルについては「DataFrameのpivot_tableでピボットテーブルを扱う」でまとめていますので参考にしてください。

まとめ

pandasのDataFrameでgroupbyを使うことでグループ化して集約する方法について解説しました。

集約処理（合計、平均等）の際には、ある区分ごとのグループ単位で集約処理をしたくなりますが、groupbyを使うことで簡単に実現が可能です。本記事では、まず集約処理の考え方を説明して、基本的なgroupbyの使い方を紹介しました。

集約処理は、データ分析で非常に重要な処理の一つです。是非groupbyをうまく使いこなしてほしいと思います。

あわせて読みたい

【Python Tech】プログラミングガイド

DataFrameのデータ選択方法

pandasを利用する際にとても重要になってくるのがDataFrameの扱いです。本記事ではDataFrameから必要なデータを選択する方法の基本について説明します。

DataFrameのデータ選択方法として是非覚えておいて欲しいのは後述するloc, iloc, at, iatといったデータ選択方法です。しかし、それらメソッドを使用しないデータアクセス方法も色々とあります。

本記事では、まずはDataFrameとしてのデータ選択方法を概観します。その後にloc, iloc, at, iatといった重要なメソッドを使ったDataFrameのデータ選択方法を紹介していきます。loc, iloc, at, iatの使い方を確認したい場合は、その他の方法は読み飛ばしていただいても構いません。

列名を指定して特定の列を取得する方法

基本的な使用方法

DataFrameで、列名を指定して特定の列を取得する場合には以下のように使用します。

import pandas as pd

attr1 = pd.Series([10, 20, 30, 40, 50], index=["A", "B", "C", "D", "E"])
attr2 = pd.Series([60, 70, 80, 90, 100], index=["A", "B", "C", "D", "E"])
df = pd.DataFrame({"attr1": attr1, "attr2": attr2})
print(df, "\n")

# 列名を指定して特定の列情報を取得する（辞書のようにアクセス）
print(df["attr1"], "\n")
# 列名を変数のようにして読み込むことも可能
print(df.attr1)

【実行結果】
   attr1  attr2
A     10     60
B     20     70
C     30     80
D     40     90
E     50    100 

A    10
B    20
C    30
D    40
E    50
Name: attr1, dtype: int64 

A    10
B    20
C    30
D    40
E    50
Name: attr1, dtype: int64

使い方は、Python辞書のキーを指定してアクセスする方法と同様でdf['列名']とすることで特定列を取得できます。また、列名を変数名のように「df.列名」としてアクセスすることも可能です。

注意事項：列名とメソッド名が同じ場合に注意

列名を変数名のように「df.列名」としてアクセスする場合には注意事項があります。DataFrameのメソッド名と同じ列名を使ってしまうと取得できるデータは想定のものになりません。メソッド名と列名が同じになっているような列がないか注意しましょう。

import pandas as pd

attr1 = pd.Series([10, 20, 30, 40, 50], index=["A", "B", "C", "D", "E"])
attr2 = pd.Series([60, 70, 80, 90, 100], index=["A", "B", "C", "D", "E"])
df = pd.DataFrame({"attr1": attr1, "pop": attr2})
print(df, "\n")

# メソッド名と重なる場合、辞書形式の取得と属性名での取得は一致しない
print(f"df.pop: \n{df.pop}\n")
print(f"df['pop']: \n{df['pop']}\n")
print(df.pop is df["pop"])

【実行結果】
   attr1  pop
A     10   60
B     20   70
C     30   80
D     40   90
E     50  100 

df.pop: 
<bound method DataFrame.pop of    attr1  pop
A     10   60
B     20   70
C     30   80
D     40   90
E     50  100>

df['pop']: 
A     60
B     70
C     80
D     90
E    100
Name: pop, dtype: int64

False

上記例では、データが「pop」という列を持っています。しかし、DataFrameのメソッドにpopメソッドがあるため、df.popとして取得できるものはdf['pop']として取得できるものとは異なります。isを使って確認を取っていますがFalseで一致しません。

このように、DataFrameのメソッドと列名が同じ場合だと想定外の結果となることもあるので注意して使用するようにしてください。

特定の列情報を任意順序に並べたデータを取得する方法

DataFrameの列の順序を任意に並べ替えたい場合には、以下のように列名を並べて取得します。

import pandas as pd

attr1 = pd.Series([10, 20, 30, 40, 50], index=["A", "B", "C", "D", "E"])
attr2 = pd.Series([60, 70, 80, 90, 100], index=["A", "B", "C", "D", "E"])
df = pd.DataFrame({"attr1": attr1, "attr2": attr2})
print(df, "\n")

# 特定の列名を指定し、任意順序で並べ替えてデータを取得する（同じ列の複製も可能）
print(df[["attr2", "attr1", "attr1", "attr2"]])

【実行結果】
   attr1  attr2
A     10     60
B     20     70
C     30     80
D     40     90
E     50    100 

   attr2  attr1  attr1  attr2
A     60     10     10     60
B     70     20     20     70
C     80     30     30     80
D     90     40     40     90
E    100     50     50    100

上記例では、列の順序を表すようなリストを[]の中に渡すことで、指定した列順序で並び替えています。また、attr1, attr2を複数回指定していますが、列が複製されていることが分かるかと思います。このように、同一の列名を複数回リストに指定すれば、列データを複製するようなことが可能になります。

既存の列を用いて計算した結果列を作成する方法

DataFrameの既存の列を用いて計算した結果で新しい列を作成したくなる場合がよくあります。以下例のように、既存の列を用いて計算したうえで新しく結果列を作ることができます。

import pandas as pd

attr1 = pd.Series([10, 20, 30, 40, 50], index=["A", "B", "C", "D", "E"])
attr2 = pd.Series([60, 70, 80, 90, 100], index=["A", "B", "C", "D", "E"])
df = pd.DataFrame({"attr1": attr1, "attr2": attr2})
print(df, "\n")

# 既存の列から計算して新しい列を作成する
df["sum"] = df["attr1"] + df["attr2"]
print(df)

【実行結果】
   attr1  attr2
A     10     60
B     20     70
C     30     80
D     40     90
E     50    100 

   attr1  attr2  sum
A     10     60   70
B     20     70   90
C     30     80  110
D     40     90  130
E     50    100  150

df['sum']は元々のデータには存在していないですが、上記例のように足し算の計算式を指定することで新しい'sum'という列を作成することができます。上記例は、足し算「+」ですが、その他の演算や関数等を使って新しい列を作ることももちろん可能です。

スライスで特定のキーを持つ行を選択する方法

DataFrameの特定のキーを持つ行を選択する場合にはスライスが使用できます。

import pandas as pd

attr1 = pd.Series([10, 20, 30, 40, 50], index=["A", "B", "C", "D", "E"])
attr2 = pd.Series([60, 70, 80, 90, 100], index=["A", "B", "C", "D", "E"])
df = pd.DataFrame({"attr1": attr1, "attr2": attr2})
print(df, "\n")

# ===== スライスで特定のキーを持つ行を選択する
# 明示的なインデックスを使用する場合
print(df["B":"D"], "\n")
# 暗黙的なインデックスを使用する場合
print(df[1:3])

【実行結果】
   attr1  attr2
A     10     60
B     20     70
C     30     80
D     40     90
E     50    100 

   attr1  attr2
B     20     70
C     30     80
D     40     90 

   attr1  attr2
B     20     70
C     30     80

[]の中にキーとなるインデックスをスライスで指定すると該当する行を選択できます。pandasのDataFrameやSeriesでは、インデックスには明示的なインデックスと暗黙的なインデックスがあります。

明示的なインデックスは「index=」で指定しているインデックスです。一方、暗黙的なインデックスは表面上は見えていませんが0～の数値で振られているインデックスです。例えば上記の例でいえば、明示的なインデックス「'A'」に相当する暗黙的なインデックスは「0」となります。

注意が必要なのは、明示的なインデックスのスライスでは終わりを含みますが、暗黙的なインデックスのスライスでは終わりを含まないことです。上記例でいうと、['B':'D']という指定であれば'D'に該当する行を含みますが、[1:3]とすると3に該当する行は含まれません。

特定条件に一致する行を選択する方法

マスキングによるデータ選択

DataFrameの中から特定条件に一致する行を選択するには、以下の例のようにマスキングすることができます。

import pandas as pd

attr1 = pd.Series([10, 20, 30, 40, 50], index=["A", "B", "C", "D", "E"])
attr2 = pd.Series([60, 70, 80, 90, 100], index=["A", "B", "C", "D", "E"])
df = pd.DataFrame({"attr1": attr1, "attr2": attr2})
print(df, "\n")

# 特定の条件に一致する行を選択する
print(df[(df["attr1"] > 10) & (df["attr2"] < 100)])

【実行結果】
   attr1  attr2
A     10     60
B     20     70
C     30     80
D     40     90
E     50    100 

   attr1  attr2
B     20     70
C     30     80
D     40     90

上記例では「attr1列の値が10より大きい」かつ「attr2列の値が100より小さい」に該当する行が選択されます。df['attr1'] > 10といった部分は該当する行がTrueとなるようなbool型になります。df['attr2'] < 100についても同様の考え方です。

選択対象とする行がTrueとなるbool値をDataFrameの[]内に指定することで該当する行だけマスキングすることができます。

queryを用いた条件指定によるデータ選択

特定条件に一致する行を選択する方法として、queryメソッドを使用した方法もあります。queryは、以下の例のように使用します。

import pandas as pd

attr1 = pd.Series([10, 20, 30, 40, 50], index=["A", "B", "C", "D", "E"])
attr2 = pd.Series([60, 70, 80, 90, 100], index=["A", "B", "C", "D", "E"])
df = pd.DataFrame({"attr1": attr1, "attr2": attr2})
print(df, "\n")

# queryを用いて条件に一致する行を選択する
# ※ 内部的に文字列評価を行うためパフォーマンスに影響ある場合があることに注意
print(df.query("attr1 > 10 and attr2 < 100"), "\n")

# 変数を使ったクエリの記載も可能
threshold1 = 20
threshold2 = 90
print(df.query("attr1 >= @threshold1 and attr2 < @threshold2"))

【実行結果】
   attr1  attr2
A     10     60
B     20     70
C     30     80
D     40     90
E     50    100 

   attr1  attr2
B     20     70
C     30     80
D     40     90 

   attr1  attr2
B     20     70
C     30     80

queryを使用する場合には、上記例のようにデータを取得するための条件となるクエリ文字列で指定します。また、threshold1やthreshold2のようにプログラム中で作成した変数をクエリに含めたい場合には、@を文字列内で使用することで該当箇所に埋め込んでデータ選択をすることも可能です。

queryは、条件式を文字列で直接記載するので複雑な条件を直感的に読みやすいというメリットがあります。ただし、queryでは内部的に文字列を評価して処理を実行するため、巨大なデータフレームを扱う場合などではパフォーマンス上で影響があるかもしれないので注意が必要です。

また、すべての状況でqueryが使用できるとは限りませんので実行したいクエリを実行できるかはよく確認してもらえればと思います。

任意の行、列の値を選択する方法 ~loc, iloc, at, iat~

DataFrameで任意の行や列の値を選択する方法は、loc, iloc, at, iatを使用することができます。これらのメソッドの使い方は是非覚えてください。

pandasのDataFrameやSeriesでは、インデックスには明示的なインデックスと暗黙的なインデックスがあります。明示的なインデックスは「index=」等で指定しているインデックスで、一方の暗黙的なインデックスは表面上は見えていませんが0～の数値で振られているインデックスです。

以降で説明するloc, iloc, at, iatに関して「i」がついているものは暗黙的なインデックスを対象に、「i」がついていないものは明示的なインデックスを対象にしてデータ選択するメソッドです。また、ilocは「integer-location」、iatは「integer-position」を意味します。

特定位置の情報を選択する方法

DataFrameにおける特定位置の値（例えば「2行1列の値」等）を選択する場合は、loc, iloc, at, iatを使用して以下の例のようにデータを選択ができます。

import pandas as pd

attr1 = pd.Series([10, 20, 30, 40, 50], index=["A", "B", "C", "D", "E"])
attr2 = pd.Series([60, 70, 80, 90, 100], index=["A", "B", "C", "D", "E"])
attr3 = pd.Series([110, 120, 130, 140, 150], index=["A", "B", "C", "D", "E"])
df = pd.DataFrame({"attr1": attr1, "attr2": attr2, "attr3": attr3})
print(df, "\n")

# 特定の位置を選択する
# 明示的なインデックスを使用する場合
print(df.loc["C", "attr2"], "\n")
# atを使っても同様のことができる
print(df.at["C", "attr2"], "\n")

# 暗黙的なインデックスを使用する場合
print(df.iloc[2, 1], "\n")
# iatを使っても同様のことができる
print(df.iat[2, 1])

【実行結果】
   attr1  attr2  attr3
A     10     60    110
B     20     70    120
C     30     80    130
D     40     90    140
E     50    100    150 

80 

80 

80 

80

上記例のように[]内に、[行のインデックス, 列のインデックス]という形で指定することで該当する特定位置の値を取得することができます。

locやatは明示的なインデックスを対象にし、ilocやiatは暗黙的なインデックスを対象にします。特定位置の値を選択する場合には、locとat、ilocとiatについては結果は同じです。locやilocは以降で説明するようなスライスでのデータ選択にも対応しているという点でatやiatとは異なります。

スライスで任意の行、列を選択する方法

DataFrameにおける任意の行、列をスライスで選択する場合は、loc, ilocを使用して以下例のようにデータ選択ができます。

import pandas as pd

attr1 = pd.Series([10, 20, 30, 40, 50], index=["A", "B", "C", "D", "E"])
attr2 = pd.Series([60, 70, 80, 90, 100], index=["A", "B", "C", "D", "E"])
attr3 = pd.Series([110, 120, 130, 140, 150], index=["A", "B", "C", "D", "E"])
df = pd.DataFrame({"attr1": attr1, "attr2": attr2, "attr3": attr3})
print(df, "\n")

# 任意の行、列を選択する（スライスを使用する例）
# 明示的なインデックスを使用する場合
print(df.loc["B":"D", "attr2":"attr3"], "\n")
# 暗黙的なインデックスを使用する場合
print(df.iloc[1:3, 1:2])

【実行結果】
   attr1  attr2  attr3
A     10     60    110
B     20     70    120
C     30     80    130
D     40     90    140
E     50    100    150 

   attr2  attr3
B     70    120
C     80    130
D     90    140 

   attr2
B     70
C     80

上記例のように[]内に、[行のスライス, 列のスライス]という形で指定することで、指定した行の範囲、列の範囲に該当するデータを選択することができます。

ここで注意が必要なのは、明示的なインデックスでは終わりを含みますが、暗黙的なインデックスでは終わりを含まないことです。上記例の行スライスでいうと、例えば「'B':'D'」という指定であれば「'D'」は含みますが、「1:3」とすると3は含まれません。列スライスについても同様です。

データ集約やピボットテーブル

上記までは、対象DataFrameから対象の行を抽出する例を中心に様々な方法を紹介してきました。データ分析を行う際には、データをグループ化して集約処理したり、ピボットテーブルを作成したくなることがよくあります。

集約処理は、あるグループに対して合計や平均などを計算する処理で、単純にDataFrame全体を集約をすればよいわけではなく、ある区分ごとのグループ単位で集約処理を実施することでデータ分析に非常に有益な情報が得られます。pandasではgroupbyメソッドが用意されていて簡単に処理が可能です。groupbyについては「DataFrameをgroupbyでグループ化して集約する方法」でまとめていますので参考にしてください。

また、ピボットテーブルもグループごとの情報を確認するためによく使われるものです。ピボットテーブルはgroupbyを用いても実現できますが、pandasではpivot_tableメソッドが用意されていて簡単に対処できます。pivot_tableについては「DataFrameのpivot_tableでピボットテーブルを扱う」でまとめていますので参考にしてください。

まずは本記事で紹介したような基本的なデータ選択方法を理解してもらい、groupbyやpivot_tableといった少し高度なデータ処理ができるようになると良いかと思います。

まとめ

pandasのDataFrameのデータ選択方法について解説しました。

DataFrameのデータ選択方法として是非覚えておいて欲しいのはloc, iloc, at, iatといったデータ選択方法です。しかし、それらメソッドを使用しないデータアクセス方法も色々とあります。列名を指定しての取得やスライス、マスキング等の方法を紹介しています。

pandasを利用する際にとても重要になってくるのがDataFrameの扱いになってきます。是非、各種方法について扱えるようにしてほしいと思います。

あわせて読みたい

【Python Tech】プログラミングガイド