Lesen und Schreiben in Parquet-Dateien in Python

1. Parquet-Schnittstellen, die Parquet-Dateien in Python lesen und schreiben
2. Schreiben Sie DataFrames mithilfe des PyArrow-Moduls in Python in eine Parquet-Datei
3. Lesen Sie Metadaten von Parquet-Dateien mit dem PyArrow-Modul in Python
4. Schreiben Sie Daten mit der Fastparquet-Engine in Python in Parquet-Dateien
5. Lesen Sie Parquet-Dateien mit der Fastparquet-Engine in Python
6. Abschluss

Dieser Artikel konzentriert sich auf das Schreiben und Lesen von Parquet-Dateien in Python. Diese Dateitypen sind ein Speichersystemformat, das Daten spaltenweise speichert.

Parquet ist ein leistungsoptimiertes Dateiformat im Vergleich zu zeilenbasierten Dateiformaten wie CSV. Bei der Ausführung von Abfragen auf Ihrem Parquet-basierten Dateisystem kann der Fokus sehr schnell auf die erforderlichen Daten gelegt werden.

Parquet-Schnittstellen, die Parquet-Dateien in Python lesen und schreiben

Python verwendet Engines, um in Datenrahmen zu schreiben und Parquet-Dateien zu lesen. Dieser Artikel erklärt einige Engines, die Parquet-Dateien in Datenbanken schreiben.

Für die Verwendung in Datenanalysesystemen bietet das Apache Parquet-Projekt ein standardisiertes Open-Source-Spaltenspeicherformat. Apache Arrow ist die beste In-Memory-Transportschicht für Daten, die aus Parquet-Dateien gelesen oder in Parquet-Dateien geschrieben werden.

Wir werden zwei Parquet-Schnittstellen kennenlernen, die Parquet-Dateien in Python lesen: pyarrow und fastparquet.

Das PyArrow-Modul in Python

Apache Arrow oder PyArrow ist eine Entwicklungsplattform für In-Memory-Analysen. Es verfügt über eine Technologiesammlung, mit der Big-Data-Systeme Daten schnell speichern, verarbeiten und übertragen können.

Dieser Code ist Python-gebunden in pyarrow, was es ermöglicht, Parquet-Dateien mit Pandas zu schreiben und zu lesen.

Die Installation von pyarrow ist mit pip und conda einfach.

Verwenden Sie für pip den Befehl:

pip install pyarrow

Verwenden Sie für conda diesen Befehl:

conda install -c conda-forge pyarrow

Schreiben Sie DataFrames mithilfe des PyArrow-Moduls in Python in eine Parquet-Datei

Um zu verstehen, wie Datenrahmen geschrieben und Parkettdateien in Python gelesen werden, erstellen wir im folgenden Programm eine Pandas-Tabelle.

Es sind vier Importe erforderlich:

1. pyarrow - Zum Schreiben von Parkettprodukten.
2. numpy - Für mehrdimensionale Arrays.
3. pandas - Zum Erstellen von Datenrahmen.
4. Parkett - Eine Unterfunktion von pyarrow.

Dieses Programm erstellt einen Datenrahmen store1 mit Datensätzen verschiedener Typen wie Integer, String und Boolean. Die Indexliste wird auf 'abc' gesetzt, um die Zeilen in alphabetischer Reihenfolge anzuordnen.

In einer Variablen table1 wird eine Pandas-Tabelle mit der Syntax Table.from_pandas() erstellt. Diese Tabelle wird zur Kontrolle der Ergebnisse ausgedruckt.

import pyarrow.parquet as pq
import numpy as np

import pandas as pd

import pyarrow as pa

store1 = pd.DataFrame(
    {
        "first": [5, np.nan, -9],
        "second": ["apple", "samsung", "mi"],
        "third": [False, False, True],
    },
    index=list("abc"),
)

table1 = pa.Table.from_pandas(store1)
print(table1)

Ausgang:

C:\python38\python.exe "C:/Users/Win 10/main.py"
pyarrow.Table
first: double
second: string
third: bool
__index_level_0__: string
----
first: [[5,null,-9]]
second: [["apple","samsung","mi"]]
third: [[false,false,true]]
__index_level_0__: [["a","b","c"]]

Process finished with exit code 0

Diese Daten werden nun mit write_table im Parquet-Format geschrieben. Beim Schreiben einer Parquet-Datei enthält die Funktion write_table() mehrere Argumente, um verschiedene Einstellungen zu steuern.

1. data_page_size – Dieser Parameter regelt die ungefähre Anzahl kodierter Datenseiten innerhalb eines Spalten-Chunks. Derzeit ist 1 MB der Standardwert.
2. flavor – Dies stellt Kompatibilitätseinstellungen bereit, die für einen Apache Spark Parquet-Verbraucher spezifisch sind, wie etwa spark.
3. version – Dies ist die entsprechende Version des Parquet-Formats. Während 1.0 und höhere Werte die Kompatibilität mit früheren Readern garantieren, ermöglichen 2.4 und höhere Werte mehr Parquet-Typen und Kodierungen.

In diesem Programm wird der Parameter write_table() mit der Tabelle table1 und einer nativen Datei zum Schreiben des Parketts parquet.txt versehen.

Die Herkunft der Datei kann ohne die Verwendung einer Zeichenkette angegeben werden. Eines der folgenden ist möglich:

• Ein Dateipfad als Zeichenfolge
• Eine native PyArrow-Datei
• Ein Dateiobjekt in Python

Um diese Tabelle zu lesen, wird die Funktion read_table() verwendet. Eine Variable table2 wird verwendet, um die Tabelle darauf zu laden.

Zuletzt wird diese Parquet-Datei mit table2.to_pandas() in den Pandas-Datenrahmen konvertiert und gedruckt.

pq.write_table(table1, "sample_file.parquet")

table2 = pq.read_table("sample_file.parquet")

table2.to_pandas()

print("\n", table2)

Ausgang:

C:\python38\python.exe "C:/Users/Win 10/main.py"

 pyarrow.Table
first: double
second: string
third: bool

__index_level_0__: string
----

first: [[5,null,-9]]
second: [["apple","samsung","mi"]]
third: [[false,false,true]]
__index_level_0__: [["a","b","c"]]

Process finished with exit code 0

Parquet-Dateien sind normalerweise riesige Datendateien, und das Lesen von Parquet-Dateien in Python dauert lange zum Laden. So können bestimmte Spalten übergeben werden, um Daten schnell zu lesen, anstatt die gesamte Datei zu laden:

In die Variable table3 wird die Funktion pq.read_table zum Schreiben der Daten verwendet. Innerhalb der Parameterklammer sind zwei Spalten vorgesehen: first und third.

table3 = pq.read_table("parquet.txt", columns=["first", "third"])
print(table3)

Die Ausgabe zeigt die ausgewählten Spalten an.

Ausgang:

C:\python38\python.exe "C:/Users/Win 10/main.py"
pyarrow.Table
first: double
third: bool
----
first: [[5,null,-9]]
third: [[false,false,true]]

Process finished with exit code 0

Wir verwenden read_pandas, um zusätzliche Indexspaltendaten beim Lesen einer Teilmenge von Spalten aus einer Datei mit einem Pandas-Datenrahmen als Quelle beizubehalten:

table4 = pq.read_pandas("parquet.txt", columns=["second"]).to_pandas()
print(table4)

Ausgang:

C:\python38\python.exe "C:/Users/Win 10/main.py"
       second
a    apple
b  samsung
c       mi

Process finished with exit code 0

Ein String-Dateipfad oder eine Instanz von NativeFile (insbesondere Speicherzuordnungen) werden beim Lesen eine bessere Leistung erbringen als ein Python-Dateiobjekt, das normalerweise die schlechteste Lesegeschwindigkeit hat.

Eine oder mehrere spezielle Spalten werden automatisch erstellt, wenn pa.Table.from_pandas verwendet wird, um eine Tabelle in eine Arrow-Tabelle zu konvertieren, um den Index (Zeilenbeschriftungen) zu verfolgen. Wenn der Index nicht wertvoll ist, kann er durch Übergeben von preserve index=False weggelassen werden, da das Speichern des Index mehr Speicherplatz benötigt.

import numpy as np
import pandas as pd
import pyarrow as pa
import pyarrow.parquet as pq

store = pd.DataFrame(
    {
        "first": [5, np.nan, -9],
        "second": ["apple", "samsung", "mi"],
        "third": [False, False, True],
    },
    index=list("abc"),
)

print(store)

table = pa.Table.from_pandas(store, preserve_index=False)
pq.write_table(table, "sample_file.parquet")
t = pq.read_table("sample_file.parquet")

print("\n", t.to_pandas())

Der Index der angezeigten Parquet-Datei ist gelöscht.

Ausgang:

C:\python38\python.exe "C:/Users/Win 10/main.py"
   first   second  third
a    5.0    apple  False
b    NaN  samsung  False
c   -9.0       mi   True

    first   second  third
0    5.0    apple  False
1    NaN  samsung  False
2   -9.0       mi   True

Process finished with exit code 0

Lesen Sie Metadaten von Parquet-Dateien mit dem PyArrow-Modul in Python

Neben dem Auslesen von Daten aus Dateien bietet die Klasse ParquetFile, welche die Methode read_table verwendet, zusätzliche Features wie das Auslesen der Metadaten.

import pyarrow.parquet as pq

parquet_file = pq.ParquetFile("example.parquet")
print(parquet_file.metadata)

Ausgang:

C:\python38\python.exe "C:/Users/Win 10/main.py"
<pyarrow._parquet.FileMetaData object at 0x000001DADCBDCA90>
  created_by: parquet-cpp-arrow version 9.0.0
  num_columns: 4
  num_rows: 3
  num_row_groups: 1
  format_version: 2.6
  serialized_size: 2580

Process finished with exit code 0

Schreiben Sie Daten mit der Fastparquet-Engine in Python in Parquet-Dateien

Es ist eine Python-Schnittstelle für das Parquet-Dateiformat.

Dieses Programm schreibt mit fastparquet auf eine Parquet-Datei. Es wird ein Datenrahmen store mit zwei Spalten erstellt: student und marks.

Der Datenrahmen wird mit der Funktion dataframe.to_parquet() in eine Parkettdatei sample.parquet geschrieben.

Die Engine ist als fastparquet ausgewählt, kann aber auch auf pyarrow eingestellt werden.

import pandas as pd

store = pd.DataFrame(
    {
        "student": ["Michael", "Jackson", "N", "John", "Cena"],
        "marks": [20, 10, 22, 21, 22],
    }
)

print(store)
store.to_parquet("sample.parquet", engine="fastparquet")

Ausgang:

C:\python38\python.exe "C:/Users/Win 10/main.py"
   student  marks
0  Michael     20
1  Jackson     10
2        N     22
3     John     21
4     Cena     22

Process finished with exit code 0

Während die Daten in die Parquet-Datei geschrieben werden, lesen wir die Datei.

Lesen Sie Parquet-Dateien mit der Fastparquet-Engine in Python

Die Parquet-Datei wird mit der Funktion pd.read_parquet gelesen, indem die Engine auf fastparquet gesetzt und in einer Variablen df gespeichert wird. Anschließend werden die Ergebnisse gedruckt.

df = pd.read_parquet("sample.parquet", engine="fastparquet")
print(df)

Ausgang:

C:\python38\python.exe "C:/Users/Win 10/PycharmProjects/read_parquet/main.py"
   student  marks
0  Michael     20
1  Jackson     10
2        N     22
3     John     21
4     Cena     22

Process finished with exit code 0

Abschluss

Dieser Artikel erklärt, wie man Parquet-Dateien in Python liest. Die Programmbeispiele demonstrieren das Lesen von Parkettdateien sowohl mit pyarrow als auch mit fastparquet.

Der Leser sollte in der Lage sein, Programme zu erstellen, die Parquet-Dateien in Python lesen.