データを日付フォルダに分割して保存

PySpark で DataFrame の入出力を行う際は write やread メソッドを使用します。PySpark での DataFrame の基本的な入出力方法については「DataFrameの入出力 read, write」を参考にしてください。

データレイク（例：Amazon S3、Azure ADLS等）において、特に大量のデータを管理している際、日付フォルダにデータを分割して保存することは、クエリのパフォーマンス向上などの観点で重要な方法です。

この記事では、PySpark において日付フォルダでデータを効率的に分割して入出力する方法を紹介します。

データのフォルダ分割と保存：メリットと注意点

データをフォルダ分割して保存して扱うメリットや注意するべき点を紹介します。考え方を十分理解されている方は読み飛ばしていただいて構いません。

メリット

データレイクでデータを扱う場合、効率的に管理できるようフォルダ構成をよく検討することが重要です。扱うデータの特徴により適切な構成は異なりますが、例えば、時系列データ保存では、日付ごとフォルダを分ける方法はベストプラクティスの 1 つです。

日付ごとフォルダを分けてデータ管理することは、以下のようなメリットがあります。

注意するべき点

分割単位について十分な検討が必要

フォルダ分割単位は 年、月、日、時間などいくつか検討できます。どういった単位で分割するかは、その後のデータ活用方法に応じて十分検討するべきです。いくつかの一般的なケースと階層分けの考え方を紹介します。

1. 年単位（year=YYYY/）：年単位でデータ集計したい場合に適しています。
2. 月単位（year=YYYY/month=MM/）：月単位でデータ集計したい場合に適しています。BI では、各種データを月集計するケースが多いため、このような時に向いています。
3. 日単位（year=YYYY/month=MM/day=DD/）：日単位でデータ集計したい場合に適しています。

最適な分割方法を選択する

日付フォルダ分割は、一般的に時系列データに適していますが、すべてのデータに最適とは限りません。日付分割ではなく、他の目的に沿った意味のフォルダで整理した方がよい場合もあります。

また、どの階層まで分割するかも検討が必要です。例えば、データ量が多い時に分割単位を細かくしすぎると小さなファイルが多数生成される可能性があり、ファイルシステムに負荷をかける可能性があります。逆に、分割単位が大きい場合、読み込むファイルサイズが大きくなり、パフォーマンスに影響が起こる可能性もあります。

取り扱うデータの特性や分析の目的に応じて、パフォーマンスと効率のバランスを十分に検討することが重要です。

PySpark で日付フォルダに分割してデータを入出力する方法

PySpark を使用して日付に基づいてデータを効率的に分割し、管理するための実践的な手法を順を追って説明します。

使用するデータの用意

使用するサンプルデータを以下のコードにより生成します。このデータは、2023/10/1 ~ 2024/3/31 までで 1 時間毎に収集されるデータとして、sin 波にノイズを加えた時系列データを想定しています。例えば、ある設備の計測器からのデータと考えると分かりやすいでしょう。

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# サンプル時系列データの生成 (1時間毎データ)
h_range = pd.date_range(start="2023-10-01", end="2024-03-31 23:00:00", freq="H")
hours = np.arange(len(h_range))

# サンプルデータを生成 (週周期で時間単位のsin波)
sin_wave = np.sin(hours / (7 * 24))
# ランダムノイズを生成
noise = np.random.normal(0, 0.3, len(h_range))
# 波形にランダムノイズを付与
measurement_values = sin_wave + noise

# 描画
plt.figure(figsize=(12, 6))
plt.plot(h_range, measurement_values, label='Measurement with Noise')
plt.title('Hourly Measurement Values Over Time')
plt.xlabel('Date and Time')
plt.ylabel('Measurement Value')
plt.legend()
plt.grid(True)
plt.show()

描画結果

結果として生成されるデータは上記のようになります。以降の例では、このデータを日付をベースに分割してデータを入出力する例を説明していきます。

日付フォルダでデータを分割して出力する

データを日付フォルダに分割して保存する場合は以下のように write.partitionBy を使用します。なお、write の基本的な使い方が分からない方は「DataFrameの入出力 read, write」を参照してください。

from pyspark.sql import SparkSession
from pyspark.sql.functions import dayofmonth, month, year

# Sparkセッションの初期化
spark = SparkSession.builder.appName("partition_example").getOrCreate()

# pandasのDataFrameを作成
pandas_df = pd.DataFrame({
    "datetime": h_range,
    "measurement": measurement_values
}    
)
# Spark DataFrameに変換
df = spark.createDataFrame(pandas_df)
# 年・月・日の列を作成しておく
df = df.withColumn("year", year("datetime"))
df = df.withColumn("month", month("datetime"))
df = df.withColumn("day", dayofmonth("datetime"))
df.show()

# 年単位でパーティション分割して保存
df.write.mode("overwrite").partitionBy("year").parquet("./yearly")

# 月単位でパーティション分割して保存
df.write.mode("overwrite").partitionBy("year", "month").parquet("./monthly")

# 日単位でパーティション分割して保存
df.write.mode("overwrite").partitionBy("year", "month", "day").parquet("./daily")

上記プログラムでは、まず pandas の DataFrame を作成し、それを Spark の DataFrame に変換しています。その後に datetime 列から year, month, day の情報を抽出して列を追加し、これらを基にデータを分割して保存します。

ファイルを書き込む write.partitionBy で基準とする列名を指定します。年月日で階層構造を作って作成したい場合は「, (カンマ)」で区切って階層順に列を指定します。

結果としては年は「year=YYYY」、月は「month=MM」、日は「day=DD」という形式のフォルダが作成され、各フォルダに parquet ファイルが出力されます。出力ファイル数は Spark ノードに依存するため複数ファイル出力される場合があります。

年単位フォルダでの保存

月単位フォルダでの保存

日単位フォルダでの保存

データを読み込む方法

日付フォルダで分割したファイルを読み込む際には read メソッドを使用します。いくつかのパターンでの読み込み例を紹介します。

特定のフォルダを指定して読み込む場合

特定の年月のフォルダを指定して読み込む場合は、以下のように対象フォルダを read.parquet に指定します。

# 特定フォルダを指定して読み込む場合
df_read = spark.read.parquet("./monthly/year=2023/month=10")

# ソートしてから表示
df_read = df_read.sort(df_read.datetime)
df_read.show(5)
df_read.orderBy(df_read.datetime, ascending=False).show(5)

【実行結果】
+-------------------+--------------------+---+
|           datetime|         measurement|day|
+-------------------+--------------------+---+
|2023-10-01 00:00:00| 0.14901424590336979|  1|
|2023-10-01 01:00:00|-0.03552694454855405|  1|
|2023-10-01 02:00:00| 0.20621104213982733|  1|
|2023-10-01 03:00:00|  0.4747651507543513|  1|
|2023-10-01 04:00:00|-0.04643873812079383|  1|
+-------------------+--------------------+---+
only showing top 5 rows

+-------------------+-------------------+---+
|           datetime|        measurement|day|
+-------------------+-------------------+---+
|2023-10-31 23:00:00|-0.9504823233260842| 31|
|2023-10-31 22:00:00|-1.1440374606662784| 31|
|2023-10-31 21:00:00|-1.3387133335934447| 31|
|2023-10-31 20:00:00|-1.5053170384963321| 31|
|2023-10-31 19:00:00|  -0.64692450768512| 31|
+-------------------+-------------------+---+
only showing top 5 rows

上記では、読み込んだ先頭と末尾の 5 行を出力していますが、指定した月のファイルが読み込めていることが分かるかと思います。月の例で紹介していますが、年や日の分割をした場合についても同様です。

フォルダ配下をまとめて読み込む場合

例えば、年・月で階層化したフォルダ構成にしていた場合に、年のフォルダ配下にあるすべての月フォルダをまとめて読み込みたい場合があります。このような場合には、以下のように年フォルダを指定します。

# フォルダ配下をまとめて読み込む場合 (以下どちらでも同じ)
df_read = spark.read.parquet("./monthly/year=2023")
# df_read = spark.read.parquet("./monthly/year=2023/*")

# ソートしてから表示
df_read = df_read.sort(df_read.datetime)
df_read.show(5)
df_read.orderBy(df_read.datetime, ascending=False).show(5)

【実行結果】
+-------------------+--------------------+---+-----+
|           datetime|         measurement|day|month|
+-------------------+--------------------+---+-----+
|2023-10-01 00:00:00| 0.14901424590336979|  1|   10|
|2023-10-01 01:00:00|-0.03552694454855405|  1|   10|
|2023-10-01 02:00:00| 0.20621104213982733|  1|   10|
|2023-10-01 03:00:00|  0.4747651507543513|  1|   10|
|2023-10-01 04:00:00|-0.04643873812079383|  1|   10|
+-------------------+--------------------+---+-----+
only showing top 5 rows

+-------------------+-------------------+---+-----+
|           datetime|        measurement|day|month|
+-------------------+-------------------+---+-----+
|2023-12-31 23:00:00| 0.6467656757056162| 31|   12|
|2023-12-31 22:00:00| 0.9802973425873306| 31|   12|
|2023-12-31 21:00:00| 0.6717463226887521| 31|   12|
|2023-12-31 20:00:00|0.23803665242220395| 31|   12|
|2023-12-31 19:00:00| 0.1319102042628495| 31|   12|
+-------------------+-------------------+---+-----+
only showing top 5 rows

年フォルダ配下をまとめて指定する場合は、上記のように "./monthly/year=2023" といった形で年フォルダを指定します。また、ワイルドカードでの読み込みもできるので "./monthly/year=2023/*" としても同様です。

他のサブディレクトリやファイルがある場合

フォルダ配下をまとめて指定する場合で、他のサブディレクトリやファイルがある場合には、ワイルドカードを使用できます。例えば、任意の月フォルダを month=* のようにワイルドカード指定するとフォルダ配下の全ての月のデータを取得できます。

# フォルダ配下をまとめて読み込む場合 (他のサブディレクトリやファイルがある場合)
df_read = spark.read.parquet("./monthly/year=2023/month=*")

# ソートしてから表示
df_read = df_read.sort(df_read.datetime)
df_read.show(5)
df_read.orderBy(df_read.datetime, ascending=False).show(5)

【実行結果】
+-------------------+--------------------+---+
|           datetime|         measurement|day|
+-------------------+--------------------+---+
|2023-10-01 00:00:00| 0.14901424590336979|  1|
|2023-10-01 01:00:00|-0.03552694454855405|  1|
|2023-10-01 02:00:00| 0.20621104213982733|  1|
|2023-10-01 03:00:00|  0.4747651507543513|  1|
|2023-10-01 04:00:00|-0.04643873812079383|  1|
+-------------------+--------------------+---+
only showing top 5 rows

+-------------------+-------------------+---+
|           datetime|        measurement|day|
+-------------------+-------------------+---+
|2023-12-31 23:00:00| 0.6467656757056162| 31|
|2023-12-31 22:00:00| 0.9802973425873306| 31|
|2023-12-31 21:00:00| 0.6717463226887521| 31|
|2023-12-31 20:00:00|0.23803665242220395| 31|
|2023-12-31 19:00:00| 0.1319102042628495| 31|
+-------------------+-------------------+---+
only showing top 5 rows

いくつかの特定フォルダを複数読み込む場合

フォルダ配下のいくつかのフォルダを複数読み込む場合は、以下のようにそれぞれのフォルダを読み込み union で結合することができます。

# いくつかの特定フォルダを複数読み込む場合
df1 = spark.read.parquet("./monthly/year=2023/month=11")
df2 = spark.read.parquet("./monthly/year=2023/month=12")
df_read = df1.union(df2)

# ソートしてから表示
df_read = df_read.sort(df_read.datetime)
df_read.show(5)
df_read.orderBy(df_read.datetime, ascending=False).show(5)

【実行結果】
+-------------------+-------------------+---+
|           datetime|        measurement|day|
+-------------------+-------------------+---+
|2023-11-01 00:00:00|-0.8046957296660957|  1|
|2023-11-01 01:00:00|-1.1793663638979297|  1|
|2023-11-01 02:00:00|-0.9072289030283197|  1|
|2023-11-01 03:00:00| -1.191455395525611|  1|
|2023-11-01 04:00:00| -1.149843255157325|  1|
+-------------------+-------------------+---+
only showing top 5 rows

+-------------------+-------------------+---+
|           datetime|        measurement|day|
+-------------------+-------------------+---+
|2023-12-31 23:00:00| 0.6467656757056162| 31|
|2023-12-31 22:00:00| 0.9802973425873306| 31|
|2023-12-31 21:00:00| 0.6717463226887521| 31|
|2023-12-31 20:00:00|0.23803665242220395| 31|
|2023-12-31 19:00:00| 0.1319102042628495| 31|
+-------------------+-------------------+---+
only showing top 5 rows

Delta Lake を使用する場合

Delta Lake を使う場合も基本的には同じ考え方で使用することができます。Delta Lake は、データレイク上で ACID 特性を提供し、スケーラブルで安全なデータ処理、管理を提供するための機能レイヤーでレイクハウス実装で活用できる技術です。

日付フォルダでデータを分割して出力する

Delta Lake 版に書き換えたプログラムは以下になります。これまで紹介してきたプログラムとの変化点は 2 点です。DataFrame の操作に関わる部分に変更はありません。

1. Spark セッション初期化の際に Delta Lake のための config を設定
2. 保存の際に format("delta")を指定し、parquet を save に変更

from pyspark.sql import SparkSession
from delta import configure_spark_with_delta_pip
from pyspark.sql.functions import dayofmonth, month, year

# Sparkセッションの初期化
builder = (
    SparkSession.builder.appName("partition_example")
    .config("spark.sql.extensions", "io.delta.sql.DeltaSparkSessionExtension")
    .config("spark.sql.catalog.spark_catalog", "org.apache.spark.sql.delta.catalog.DeltaCatalog")
)
# Delta Lakeで動作するように設定
spark = configure_spark_with_delta_pip(builder).getOrCreate()

# pandasのDataFrameを作成
pandas_df = pd.DataFrame({
    "datetime": h_range,
    "measurement": measurement_values
}    
)
# Spark DataFrameに変換
df = spark.createDataFrame(pandas_df)
# 年・月・日の列を作成しておく
df = df.withColumn("year", year("datetime"))
df = df.withColumn("month", month("datetime"))
df = df.withColumn("day", dayofmonth("datetime"))
df.show()

# 年単位でパーティション分割して保存
df.write.format("delta").mode("overwrite").partitionBy("year").save("./yearly-delta")

# 月単位でパーティション分割して保存
df.write.format("delta").mode("overwrite").partitionBy("year", "month").save("./monthly-delta")

# 日単位でパーティション分割して保存
df.write.format("delta").mode("overwrite").partitionBy("year", "month", "day").save("./daily-delta")

実行すると Delta Lake としてファイルが保存されます。parquet でデータが保存されるとともに _delta_log というフォルダが生成されます。

データを読み込む方法

Delta Lake 版でデータを読み込む場合の変化としては、読み込みの際に format("delta") を指定し、parquet を load に変更します。上記で見てきた読み込みのパターンで見てみましょう。実行結果は変わらないため省略します。

なお、Delta Lake はワイルドカード指定をサポートしていない点に注意が必要です。（※Delta Lake のバージョンにより異なる可能性があります）

特定のフォルダを指定して読み込む場合

# 特定フォルダを指定して読み込む場合
df_read = spark.read.format("delta").load("./monthly-delta/year=2023/month=10")

フォルダ配下をまとめて読み込む場合

# フォルダ配下をまとめて読み込む場合
df_read = spark.read.format("delta").load("./monthly-delta/year=2023")

他のサブディレクトリやファイルがある場合

他のサブディレクトリがある場合、Delta Lake ではワイルドカード指定できないため、month=* のような指定ができません。そのため、以降で紹介するように複数フォルダをそれぞれ読み込んで union する必要があります。

# いくつかのフォルダを複数読み込む場合
df1 = spark.read.format("delta").load("./monthly-delta/year=2023/month=11")
df2 = spark.read.format("delta").load("./monthly-delta/year=2023/month=12")
df_read = df1.union(df2)

レイクハウス構築の際には、Delta Lake の技術を採用する場合もあると思うので、使い方を覚えておくと良いかと思います。

まとめ

PySpark でデータを保存する際に、日付フォルダで分割してデータを保存する方法を解説しました。

データレイク（例：Amazon S3、Azure ADLS等）において、特に大量のデータを管理している際、日付フォルダにデータを分割して保存することは重要な方法です。これにより、クエリのパフォーマンス向上など多くの利点があります。

この記事では、簡単なサンプルデータを用意して、日付フォルダで分割して保存、読み込みを行う方法を実装例を用いて紹介しました。

日付フォルダ分割は、すべてのデータに適しているとは限りませんが、時系列データを扱う場合などには適しています。日付フォルダでの分割をうまく活用してデータ活用をしてもらえたらと思います。

あわせて読みたい

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

DataFrameの入出力

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

この記事では、PySpark で DataFrame を入出力する方法を紹介します。データフォーマットとしては分析でよく使用される CSV、Parquet、ORC、JSON といった形式を扱います。

ファイル形式

今回の入出力で扱うファイル形式 (CSV、Parquet、ORC、JSON) について説明してます。各ファイルに関して詳しい人は読み飛ばしていただいて結構です。

CSV ファイル

CSV (Comma-Separated Values) ファイルは、データをテキストとして表現するシンプルなフォーマットの 1 つです。名前の通り、CSV ファイルのデータは「, (コンマ)」で区切られた値で構成されます。このフォーマットは、データベースやスプレッドシートからのデータのエクスポートやインポートに非常によく使われます。

Parquet ファイル

Parquet ファイルは、データ分析でよく使用される列指向のストレージフォーマットです。大量のデータの効率的な読み取り、書き込み、および圧縮をサポートするため、大規模なデータ分析に適しています。

Parquet ファイルは、バイナリフォーマットのため直接参照できませんが、データ加工の処理フローでは Parquet で効率よく処理し、データの利用ユーザーに公開する際に CSV ファイルにして提供するといったことも行われます。

ORCファイル

ORC (Optimized Row Columnar) ファイルは、主に Hadoop エコシステムで使用される列指向のストレージフォーマットの 1 つです。ORC は特に Hive のために設計されており、大量データの効率的な読み取り、書き込み、圧縮をサポートします。

ORC は、特に Hive クエリのパフォーマンスを向上させることを目的として設計されているため、Hive を使用する場合は Hadoop エコシステムを中心にデータ処理する場合に適しているが多いです。また、他の SQL ベースのデータベースシステムやデータ処理フレームワークでも ORC フォーマットが利用されることがあります。

Parquet と ORC のどちらを選択するかは、使用するツールやエコシステムの要件によって検討するのが適切です。

JSON ファイル

JSON (JavaScript Object Notation) ファイルは、JavaScript の一部として生まれたファイルフォーマットですが、現在は多くのプログラミング言語でサポートされています。また、WebAPI（特に RESTful API）で、クライアントとサーバー間でデータをやり取りする際の標準的な手段として広く利用されています。

ファイルの書き込み write

PySpark の DataFrame の書き込みは、write メソッドで実行します。write は、DataFrameWriter クラスのメソッドとして実装されています。

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

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

# スキーマを定義
schema = StructType([
    StructField("name", StringType(), True),
    StructField("age", IntegerType(), True),
])

# データを作成
data = [("Taro", 25), ("Hanako", 30), ("Yuki", 20)]

# スキーマを指定してデータフレームを生成
df = spark.createDataFrame(data, schema=schema)

# CSVファイルへの書き込み
(df.write
    .option("header", "true")
    .mode("overwrite")
    .csv("./output_csv"))

# Parquetファイルへの書き込み
(df.write
    .mode("overwrite")
    .parquet("./output_parquet"))

# ORCファイルへの書き込み
(df.write
    .mode("overwrite")
    .orc("./output_orc"))

# JSONファイルへの書き込み
(df.write
    .mode("overwrite")
    .json("./output_json"))

# SparkSessionを終了
spark.stop()

出力結果例 (CSV ファイルの場合、他のフォーマットも同様)

例では、Spark のセッションを「SparkSession.builder.appName("DataFrameInputOutput").getOrCreate()」で初期化しています。"DataFrameExample" の部分は Spark アプリケーションの名前です。なお、SparkSession を終了する際は stop() を使用します。

書き込みのための write は、書き込み対象の DataFrame を使って df.write.csv("output_path") のように使用します。"output_path" の部分にはファイルを出力するフォルダ名を指定します。なお、フォルダがない場合は作成されます。

Parquet ファイルは parquet メソッド、ORC ファイルは orc メソッド、JSON ファイルは json メソッドというように各ファイルフォーマット名のメソッドが用意されています。また、以降で説明する option や mode といったメソッドと併用することで出力をコントロールできます。

option メソッド

write メソッドでは、option メソッドでオプション指定することができます。

# CSVファイルへの書き込み
(df.write
    .option("header", "true")
    .mode("overwrite")
    .csv("./output_csv"))

例では、option メソッドで "header" を "true" に設定し、ヘッダー行を出力するようにしています。

Apache Spark の DataFrame の option メソッドは、様々な読み取りや書き込みオペレーションの設定を変更するためのキーと値のペアを指定する際に使用します。このメソッドは、主にファイルを読み込む read やファイルに書き込む write と組み合わせて使用されます。

Parquet や ORC は、スキーマ情報を含むファイルフォーマットのため header の指定は必要ありません。なお、例では DataFrame を作成する際に StructType やStructField を使ってスキーマを明確に指定しています。

PySpark では必ずしもスキーマを指定しなくても使えますが、スキーマ情報を指定しておくことでデータを適切に扱うことができるため、スキーマ情報を指定することをおすすめします。

"header" 以外にも option には指定できるものがあるため調べてみてください。例えば、CSV ファイル書き込みでは "delimiter" 等のオプションを指定できます。

PySparkでは option や後述する mode といったメソッドを例のようにチェーンでつなげる書き方が一般的に使用されます。改行する際には例のように () で囲っておくと可読性高く記載可能です。

mode メソッド

write メソッドでは mode メソッドでモード指定ができます。

# CSVファイルへの書き込み
(df.write
    .option("header", "true")
    .mode("overwrite")
    .csv("./output_csv"))

例では "overwrite" を指定してファイルを上書きしています。

mode で指定できる代表的なモードは以下の通りです。

複数ファイルに出力される理由

PySpark による出力すると出力結果例で見たように「part-xxxxx.csv」といった複数ファイルが出力されます。これは、Spark では分散環境で処理をしており、それぞれの処理ノードの各タスクで各パーティションを処理して書き込みを行っているからです。

これらの理由を正確に理解するには Spark の Job やパーティション等の処理の概念を理解しておくことをおすすめします。「Sparkアプリケーションの概念を理解する」で Spark アプリケーションの構成やデータ構造、処理概念についてまとめていますので参考にしてください。

ファイルの読み込み read

PySpark の DataFrame のデータ読み込みは read メソッドで実行します。read は、DataFrameReader クラスのメソッドとして実装されています。

以下例は、上記の write で出力したファイルを読み込んで表示しています。

from pyspark.sql import SparkSession

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

# CSVファイルの読み込み
df_csv = (spark.read
                .option("header", "true")
                .option("inferSchema", "true")
                .csv("./output_csv"))
df_csv.printSchema()
df_csv.show()

# Parquetファイルへの書き込み
df_parquet = (spark.read
                    .parquet("./output_parquet"))
df_parquet.printSchema()
df_parquet.show()

# ORCファイルへの書き込み
df_orc = (spark.read
                .orc("./output_orc"))
df_orc.printSchema()
df_orc.show()

# JSONファイルへの書き込み
df_json = (spark.read
                .json("./output_json"))
df_json.printSchema()
df_json.show()

# SparkSessionを終了
spark.stop()

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

+------+---+
|  name|age|
+------+---+
|Hanako| 30|
|  Taro| 25|
|  Yuki| 20|
+------+---+

root
 |-- name: string (nullable = true)
 |-- age: integer (nullable = true)

+------+---+
|  name|age|
+------+---+
|Hanako| 30|
|  Taro| 25|
|  Yuki| 20|
+------+---+

root
 |-- name: string (nullable = true)
 |-- age: integer (nullable = true)

+------+---+
|  name|age|
+------+---+
|Hanako| 30|
|  Taro| 25|
|  Yuki| 20|
+------+---+

root
 |-- age: long (nullable = true)
 |-- name: string (nullable = true)

+---+------+
|age|  name|
+---+------+
| 30|Hanako|
| 25|  Taro|
| 20|  Yuki|
+---+------+

SparkSession の部分の説明は、上記で説明しているため割愛します。read は、SparkSession を介して spark.read.csv("file_path") のように使用します。

また、option メソッドと併用することで読み込みをコントロールできます。

option メソッド

read メソッドでは、option メソッドでオプション指定することができます。

# CSVファイルの読み込み
df_csv = (spark.read
                .option("header", "true")
                .option("inferSchema", "true")
                .csv("./output_csv"))
df_csv.printSchema()
df_csv.show()

例では option メソッドで "header" を "true" にすることで、ヘッダー行を読み込んでいます。また、CSV ファイルはスキーマ情報を持っていないため "inferSchema" を option で指定することでスキーマ情報を推定しながら読み込むことができます。 スキーマ情報は printSchema で確認できます。

Parquet 等のファイルフォーマットはスキーマ情報を含むため "header" や "inferSchema" を指定する必要はありません。

schema メソッドによるスキーマ指定

StructType と StructField でスキーマを定義し schema メソッドで指定することで、スキーマに従った形でデータを読み込むことができます。

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

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

# スキーマを定義
schema = StructType([
    StructField("name", StringType(), True),
    StructField("age", IntegerType(), True),
])

# CSVファイルの読み込み
df_csv = (spark.read
                .option("header", "true")
                .schema(schema)
                .csv("./output_csv"))
df_csv.printSchema()
df_csv.show()

# Parquetファイルへの書き込み
df_parquet = (spark.read
                    .schema(schema)
                    .parquet("./output_parquet"))
df_parquet.printSchema()
df_parquet.show()

# ORCファイルへの書き込み
df_orc = (spark.read
                .schema(schema)
                .orc("./output_orc"))
df_orc.printSchema()
df_orc.show()

# JSONファイルへの書き込み
df_json = (spark.read
                .schema(schema)
                .json("./output_json"))
df_json.printSchema()
df_json.show()

# SparkSessionを終了
spark.stop()

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

+------+---+
|  name|age|
+------+---+
|Hanako| 30|
|  Taro| 25|
|  Yuki| 20|
+------+---+

root
 |-- name: string (nullable = true)
 |-- age: integer (nullable = true)

+------+---+
|  name|age|
+------+---+
|Hanako| 30|
|  Taro| 25|
|  Yuki| 20|
+------+---+

root
 |-- name: string (nullable = true)
 |-- age: integer (nullable = true)

+------+---+
|  name|age|
+------+---+
|Hanako| 30|
|  Taro| 25|
|  Yuki| 20|
+------+---+

root
 |-- name: string (nullable = true)
 |-- age: integer (nullable = true)

+------+---+
|  name|age|
+------+---+
|Hanako| 30|
|  Taro| 25|
|  Yuki| 20|
+------+---+

スキーマを指定すると、データを読み込む際に PySpark が各フィールドのデータ型を推測する必要がなくなり、大きなデータセットを扱う際には読み込み時間の短縮が期待できます。

また、データの正確性の保証や、エラーの早期発見ができますし、コード内にスキーマを明示することにより、他の開発者がコードを読む際の可読性が高まります。

出力ファイルを 1 つに統合する方法 coalesce、repartition

上記例では、出力ファイルが複数になりましたが、それは Spark が分散処理をしているためでした。また、ファイルの読み込み時は、複数ファイルになっていても問題なく読み込みが可能でした。

しかし、利用者に提供する時など、場合によってはファイルをまとめた方が都合がよい場合があります。ファイルを 1 つに統合する方法についても見ておきましょう。

なお、1 つにまとめる操作は、処理ノード間のデータ移動が発生することがあるため、加工処理の途中で実行すると全体の処理時間が長くなってしまいます。そのため、処理途中では分割されたファイルのまま扱い、利用者に提供するレベルまでデータが整理された後にまとめる処理を実行するとよいでしょう。

coalesce による統合

coalesce メソッドは、パーティション数を減少させて、単一パーティションに統合することができます。これにより、ファイル出力数をコントロールできます。

以下のようにすることで、複数ファイルを 1 つのファイルに統合することができます。

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

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

# スキーマを定義
schema = StructType([
    StructField("name", StringType(), True),
    StructField("age", IntegerType(), True),
])

# データを作成
data = [("Taro", 25), ("Hanako", 30), ("Yuki", 20)]

# スキーマを指定してデータフレームを生成
df = spark.createDataFrame(data, schema=schema)


# CSVファイルへの書き込み
(df.coalesce(1).write
    .option("header", "true")
    .mode("overwrite")
    .csv("./output_csv_onefile"))

# Parquetファイルへの書き込み
(df.coalesce(1).write
    .mode("overwrite")
    .parquet("./output_parquet_onefile"))

# ORCファイルへの書き込み
(df.coalesce(1).write
    .mode("overwrite")
    .orc("./output_orc_onefile"))

# JSONファイルへの書き込み
(df.coalesce(1).write
    .mode("overwrite")
    .json("./output_json_onefile"))

# SparkSessionを終了
spark.stop()

出力結果例 (CSV ファイルの場合、他のフォーマットも同様)

coalesce を使用して出力する際には df.coalesce(1).write というようにします。これにより 1 つの CSV ファイルとして出力可能です。

repartition による統合

coalesce と同じようなメソッドとして repartition があります。以下のようにすることで複数ファイルに 1 つのファイルに統合できます。

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

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

# スキーマを定義
schema = StructType([
    StructField("name", StringType(), True),
    StructField("age", IntegerType(), True),
])

# データを作成
data = [("Taro", 25), ("Hanako", 30), ("Yuki", 20)]

# スキーマを指定してデータフレームを生成
df = spark.createDataFrame(data, schema=schema)


# CSVファイルへの書き込み
(df.repartition(1).write
    .option("header", "true")
    .mode("overwrite")
    .csv("./output_csv_onefile"))

# Parquetファイルへの書き込み
(df.repartition(1).write
    .mode("overwrite")
    .parquet("./output_parquet_onefile"))

# ORCファイルへの書き込み
(df.repartition(1).write
    .mode("overwrite")
    .orc("./output_orc_onefile"))

# JSONファイルへの書き込み
(df.repartition(1).write
    .mode("overwrite")
    .json("./output_json_onefile"))

# SparkSessionを終了
spark.stop()

出力結果例 (CSV ファイルの場合、他のフォーマットも同様)

repartition を使用して出力する際には df.repartition(1).write というようにします。上記のように repartition でも同様にファイルをまとめることが可能です。

coalesce と repartition の使い分け基準

上記の通り coalesce と repartition という類似するメソッドを紹介しました。どちらをいつ使うかという考え方について説明します。もともと、coalesce と repartition は、動作と使用目的が異なっています。

coalesce は、パーティション数を減少させるために使用します。また、coalesce はシャッフルという処理ノード間のデータ移動が発生する負荷の高い処理を回避するように複数パーティションを単一パーティションに統合します。そのため、大量の小さなパーティションを統合して効率的なサイズのパーティションを作成する際に適します。

なお、coalesce で処理ノード間の移動が全く発生しないということではないので注意してください。例えば、処理ノード 1 と処理ノード 2 があり、それぞれに 2 つのパーティションが存在する場合、coalesce(1) を使用すると、全てのパーティションを 1 つにまとめる必要があります。このような場合は、データをノード間で移動する必要があります。この場合、coalesceは、既存パーティションを移動して、他のパーティションと結合する最も効率的な方法を選択します。

また、coalesce は、パーティションを増やす場合には使用できません。パーティション数を増やす場合には、repartition の方を使う必要があります。

一方で、repartition は、データをシャッフルして新しいパーティションに再分配します。使い方としては、パーティション数を増やす場合や、特定の列に基づいてデータを再分配する場合に使用します。PySpark では、処理ノード数に対して適切なパーティション数を持つことで効率的な処理が可能となります。このような調整を行う際には repartition を使用するのが適切です。

coalesce と repartition の使い分けの基準は以下のような考え方ができます。

• パーティション数を減少させる場合：coalesce
• パーティション数を増やす場合：repartition
• 特定の列に基づいてパーティションを再分割する場合：repartition

状況によりどちらを選択するべきか十分に検討してみてください。

まとめ

PySpark での DataFrame の入出力方法について解説しました。データ分析でよく利用される CSV、Parquet、ORC、JSON といったファイル形式を扱いました。

PySpark の DataFrame でのデータの書き込みは write メソッドとして、読み込みは read メソッドとして実装されています。それぞれのメソッドでは option 等のメソッドを追加で指定することで挙動をコントロールできます。

また、Spark を使用するとファイルの出力が複数になるという特徴があります。Spark では分散処理環境で処理を実行しており、それぞれの処理ノードの各タスクで各パーティションを処理して書き込みを行っているためです。必要に応じてファイル数を制御する coalesce や repartition といったメソッドについても紹介しました。

PySpark を用いたデータ処理の流れの中で、ファイルの入出力である read と write は非常に重要です。ぜひ使い方をしっかりと理解しましょう。

あわせて読みたい

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

configparser による設定ファイルの管理

システムを構築する際には、システムの動作を制御する設定情報を設定ファイルとして管理することがほとんどです。Python では、設定ファイルを管理するためのモジュールとして configparser モジュールが用意されています。

この記事では、configparser の基本的な使い方について紹介します。

設定ファイルの形式

configparser では、Windows で主に使用される INI ファイルに似た構造を扱うことができます。configparser の公式ドキュメントに注釈がありますが、Windows のレジストリ用に拡張された INI 文法はサポートされていません。

具体的には、以下のような形式のファイルになります。

[WEB_SERVER]
host = xxx.xxx.xxx.xxx
port = 80

[DB_SERVER]
host = xxx.xxx.xxx.xxx
port = 3306

設定ファイルの中で [] で囲われている部分をセクションと言い、設定情報の 1 つの区分を表しています。

例では、Web サーバーに関するホスト名 (host)、ポート (port) の情報を [WEB_SERVER] のセクションで管理しており、DB サーバーに関するホスト名 (host)、ポート (port) の情報を [DB_SERVER] のセクションで管理しています。

セクションや設定値は、任意に増やすことができます。以降では、このような設定ファイルを configparser で具体的に扱う方法について見ていきます。

configparser による設定ファイル管理の基本

configparser による設定ファイル管理について例を使って紹介します。

import configparser

config = configparser.ConfigParser()
config["WEB_SERVER"] = {"HOST": "xxx.xxx.xxx.xxx", "PORT": 80}
config["DB_SERVER"] = {"HOST": "xxx.xxx.xxx.xxx", "PORT": 3306}

# configファイルへの書き込み
with open("config.ini", "w") as config_file:
    config.write(config_file)

# configファイルからの読み込み
config1 = configparser.ConfigParser()
config1.read("config.ini")
# 読み込んだ結果を参照
print(config1["WEB_SERVER"])
print(config1["WEB_SERVER"]["HOST"])
print(config1["WEB_SERVER"]["PORT"])
print(config1["DB_SERVER"])
print(config1["DB_SERVER"]["HOST"])
print(config1["DB_SERVER"]["PORT"])

【実行結果】
<Section: WEB_SERVER>
xxx.xxx.xxx.xxx
80
<Section: DB_SERVER>
xxx.xxx.xxx.xxx
3306

例では、設定ファイル情報を config.ini ファイルに書き込み、その後に書き込んだ設定情報を読みこんで表示しています。

設定ファイルの書き込み

import configparser

config = configparser.ConfigParser()
config["WEB_SERVER"] = {"HOST": "xxx.xxx.xxx.xxx", "PORT": 80}
config["DB_SERVER"] = {"HOST": "xxx.xxx.xxx.xxx", "PORT": 3306}

configparser を使用するには、configparser をインポートし、ConfigParser クラスのオブジェクトを作成します。

ConfigParser クラスのオブジェクトでは「オブジェクト名["セクション名"] = {キー: 設定値, ...}」というように各セクションの設定値を辞書形式で指定します。

# configファイルへの書き込み
with open("config.ini", "w") as config_file:
    config.write(config_file)

上記部分は設定ファイルを書き込んでいる部分です。対象ファイルを書き込みモード ("w")で開いて、ConfigParser クラスの write メソッドにファイルオブジェクトを渡すことで設定情報の書き込みができます。

設定ファイルの読み込み

# configファイルからの読み込み
config1 = configparser.ConfigParser()
config1.read("config.ini")

設定ファイルへ読み込むには、書き込み時と同じように ConfigParse クラスのオブジェクトを生成し、read メソッドに読み込む config ファイルのパスを指定します。

# 読み込んだ結果を参照
print(config1["WEB_SERVER"])
print(config1["WEB_SERVER"]["HOST"])
print(config1["WEB_SERVER"]["PORT"])
print(config1["DB_SERVER"])
print(config1["DB_SERVER"]["HOST"])
print(config1["DB_SERVER"]["PORT"])

読み込んだ結果を設定値を参照する場合には、上記のように「オブジェクト名["セクション名"]["キー"]」といった形で指定することで設定値を参照できます。

まとめ

Python で設定ファイルの管理をするための configparser について解説しました。

システムを構築する際には、システムの動作を制御する設定情報を設定ファイルとして管理することがほとんどです。configparser は設定ファイルの管理にとても便利ですので、使い方を覚えて活用してみてください。

あわせて読みたい

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

Pythonのファイル入出力

Python でのファイル入出力は、ファイルを開いてデータを読み書きする基本的な操作です。Python にはファイル入出力用の様々な関数やメソッドが用意されており、簡単に処理を実行できます。

この記事では、Python のファイル入出力の基本となる各種関数・メソッドの使い方や with による自動ファイルクローズなど基本を紹介します。

ファイル入出力の手順

ファイル入出力の基本的な手順は以下のような流れとなります。

1. open 関数でファイルを開く。
2. read / readline メソッドでデータを読み込む、または write / writelines メソッドでデータを書き込む。
3. close メソッドでファイルを閉じる。

テキストファイルへの書き込み例で、流れを確認してみましょう。

input_text = "サンプル"

# ファイルを開く（オープン）
file = open("sample.txt", "w+", encoding="utf-8")
# 文字列の書き込み
file.write(input_text)
# ファイルを閉じる（クローズ）
file.close()

open 関数では、ファイルパス、モード、文字コードを指定します。例では、write でinput_text に格納した文字列をファイルに書き込み、close で閉じています。読み込みの場合は、メソッドが変わるだけで流れは同じです。

close を忘れるとファイルが占有されたままとなり、他のプログラムがアクセスできなくなる可能性がありますので注意が必要です。なお、後述する with を使うと、自動的にファイルを閉じることができます。

ファイルのモード（mode）

ファイルの入出力ではモード（mode）を指定することで挙動の制御ができます。

主なモードは以下の通りです。

w モードは書き込むたびに内容が上書きされるため注意が必要です。ログファイルのように追記する場合は a、a+ モードを使用します。

with による自動クローズ

ファイルを開いたら、不要になった時点で close する必要があります。しかし、コードが複雑で長くなるとクローズを忘れる可能性があることから、ファイルのオープン時間は短く保つことが推奨されます。

これらの問題を解決するために with を使用します。with を使用するとブロックが終了した時点で自動的にファイルがクローズされます。

input_text = "サンプル"

# withでopenを実行する
with open("sample.txt", "w+", encoding="utf-8") as file:
    # 文字列の書き込み
    file.write(input_text)

例では、文字列の書き込みの write が終わったら自動でファイルをクローズするため、close 忘れを防止できます。特に理由がない限りは積極的に with を使用するようにしましょう。

プログラミングでは不要になったらリソースを開放するのが基本です。C/C++ 言語などの他言語では、メモリも同様に確保・解放を行う必要があります。プログラマとしては、使い終わったものは片づける意識を持つように意識しましょう。

テキストファイルの入出力

テキストファイルの入出力方法について基本となる実装例を紹介します。

テキストファイルの読み込み

ファイル内容をまとめて取得する read

ファイル全体の内容をまとめて取得するには read メソッドを使用します。

以下は、事前に用意した sample_text.txt の内容をまとめて読み込んで表示する例です。任意のファイルを用意して試してみてください。

with open("sample_text.txt", "r", encoding="utf-8") as file:
    data = file.read()

print(data)

【実行結果】
Python
ファイルの入出力の基本
テキストファイルの入出力

ファイル内容を 1 文字ずつ取得する read(1)

ファイル内容を 1 文字ずつ読み込むには read(1) で順次読み込みます。

with open("sample_text.txt", "r", encoding="utf-8") as file:
    data = []
    # 一文字ずつ読み込む
    while d := file.read(1):
        data.append(d)

print(data, "\n")
data_str = "".join(data)
print(data_str)

【実行結果】
['P', 'y', 't', 'h', 'o', 'n', '\n', 'フ', 'ァ', 'イ', 'ル', 'の', '入', '出', '力', 'の', '基', '本', '\n', 'テ', 'キ', 'ス', 'ト', 'フ', 'ァ', 'イ', 'ル', 'の', '入', '出', '力'] 

Python
ファイルの入出力の基本
テキストファイルの入出力

この例では、1 文字ずつリストに格納し "".join(data) で結合しています。リストの結合は「リストを結合して文字列にする方法 ~ join ~」を参考にしてください。

ファイルの内容を 1 行ずつ取得する readline

ファイルの内容を 1 行ずつリストで取得するには readlines メソッドを使用します。

with open("sample_text.txt", "r", encoding="utf-8") as file:
    # 1行ずつデータを読み出す
    data = file.readlines()

print(data, "\n")
# 取得したデータを出力
for line in data:
    print(line, end="")

【実行結果】
['Python\n', 'ファイルの入出力の基本\n', 'テキストファイルの入出力'] 

Python
ファイルの入出力の基本
テキストファイルの入出力

readlines で取得した各行の末尾には改行が入っているため、そのまま print すると余計な改行が入ってしまいます。例では、余計な改行で見にくくならないように print(line, end="") としています。

順次 1 行ずつ取得して処理する場合

readlines 以外にも open したオブジェクトを使って、以下のように直接 for ループで処理することで 1 行ずつ読み込むことも可能です。

# for文で順次取り出す方法
with open("sample_text.txt", "r", encoding="utf-8") as file:
    for line in file:
        print(line, end="")

テキストファイルへの書き込み

文字列をテキストファイルへ書き込む write

文字列をテキストファイルを書き込むには、write メソッドを使用します。

data = "Python\nファイルの入出力の基本\nテキストファイルの入出力"

# テキストファイルの書き込み
with open("sample_text_out_str.txt", "w+", encoding="utf-8") as file:
    file.write(data)

例では "w+" の書き込みモードでファイルを open し、write メソッドに文字列を渡しています。出力先の sample_text_out_str.txt には以下が書き込まれます。

Python
ファイルの入出力の基本
テキストファイルの入出力

文字列リストをまとめてテキストファイルへ書き込む writelines

文字列リストをまとめて書き込むには、writelines メソッドを使用します。

data = [
    "Python\n",
    "ファイルの入出力の基本\n",
    "テキストファイルの入出力",
]

# テキストファイルの書き込み
with open("sample_text_out_list.txt", "w+", encoding="utf-8") as file:
    file.writelines(data)

writelines にリストを指定することでファイル出力が可能です。なお、各文字列ごとに改行したい場合は、リスト内の各文字列の末尾に "\n" を含める必要があります。

バイナリファイルの入出力

画像などのバイナリファイルの入出力の例を紹介します。

バイナリファイルの読み込み

ファイル内容をまとめて取得する read

"rb" モードでバイナリファイルを開き、read メソッドで読み込みます。

with open("sample_binary.png", "rb") as file:
    data = file.read()

print(data)

【実行結果例】
b'\x89PNG\r\n\x1a\n\x00\x00\x00（・・・中略・・・）\xaeB`\x82'

ファイル内容を 1 バイトずつ取得する read(1)

バイナリファイルを 1 バイトずつ読み込むには read(1) として読み込みます。

with open("sample_binary.png", "rb") as file:
    data = []
    while d := file.read(1):
        data.append(d)

print(data, "\n")
data_bin = b"".join(data)
print(data_bin)

【実行結果】
[b'\x89', b'P', b'N', b'G', b'\r', b'\n', b'\x1a', b'\n', b'\x00', b'\x00', b'\x00',（・・・中略・・・）, b'\xae', b'B', b'`', b'\x82']
b'\x89PNG\r\n\x1a\n\x00\x00\x00（・・・中略・・・）\xaeB`\x82'

バイナリファイルへの書き込み

データをバイナリファイルへ書き込む write

"wb" モードでバイナリデータを開き、write メソッドで書き込みます。

with open("sample_binary.png", "rb") as file:
    data = file.read()

# バイナリファイルの書き込み
with open("sample_binary_out.png", "wb") as file:
    file.write(data)

例では、バイナリファイルを読み込み、別名でコピーとして書き込んでいます。

まとめ

Python のファイル入出力の基本について解説しました。

ファイル入出力の基本的な流れは以下のようになります。

1. open 関数でファイルを開く。
2. read / readline メソッドでデータを読み込む、または write / writelines メソッドでデータを書き込む。
3. close メソッドでファイルを閉じる。

close 忘れを防止するには with を使うと自動的にファイルクローズができます。また、open、close、read、readlines、write、writelines といった各種関数・メソッドの使い方を説明しました。

ファイル入出力はプログラミングの基本であるため、しっかり使いこなせるようになりましょう。

あわせて読みたい

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