Leer y escribir en archivos de Parquet en Python

1. Interfaces de Parquet que leen y escriben en archivos de Parquet en Python
2. Escribir marcos de datos en un archivo de parquet usando el módulo PyArrow en Python
3. Leer metadatos de archivos de parquet usando el módulo PyArrow en Python
4. Escribir datos en archivos Parquet usando el motor Fastparquet en Python
5. Lea archivos de Parquet usando Fastparquet Engine en Python
6. Conclusión

Este artículo se centra en cómo escribir y leer archivos de parquet en Python. Estos tipos de archivos son un formato de sistema de almacenamiento que almacena datos en forma de columnas.

Parquet es un formato de archivo de rendimiento optimizado en comparación con los formatos de archivo basados en filas como CSV. El foco se puede colocar en los datos requeridos muy rápidamente al ejecutar consultas en su sistema de archivos basado en Parquet.

Interfaces de Parquet que leen y escriben en archivos de Parquet en Python

Python usa motores para escribir en marcos de datos y leer archivos de parquet. Este artículo explicará algunos motores que escriben archivos de parquet en bases de datos.

Para su uso en sistemas de análisis de datos, el proyecto Apache Parquet ofrece un formato estandarizado de almacenamiento en columnas de código abierto. Apache Arrow es la mejor capa de transporte en memoria para datos que se leen o escriben en archivos Parquet.

Aprenderemos sobre dos interfaces de parquet que leen archivos de parquet en Python: pyarrow y fastparquet.

El módulo PyArrow en Python

Apache Arrow o PyArrow es una plataforma de desarrollo de análisis en memoria. Tiene una colección de tecnología que permite que los sistemas de big data almacenen, procesen y transfieran datos rápidamente.

Este código está vinculado a Python en pyarrow, lo que permite escribir y leer archivos de parquet usando Pandas.

Instalar pyarrow es fácil con pip y conda.

Para pip, usa el comando:

pip install pyarrow

Para conda, usa este comando:

conda install -c conda-forge pyarrow

Escribir marcos de datos en un archivo de parquet usando el módulo PyArrow en Python

Para comprender cómo escribir marcos de datos y leer archivos de parquet en Python, creemos una tabla Pandas en el siguiente programa.

Se necesitan cuatro importaciones:

1. pyarrow - Para escribir productos de parquet.
2. numpy: para matrices multidimensionales.
3. pandas - Para crear marcos de datos.
4. parquet - Una subfunción de pyarrow.

Este programa crea un marco de datos store1 con conjuntos de datos de múltiples tipos como enteros, cadenas y booleanos. La lista de índice se establece en 'abc' para organizar las filas en orden alfabético.

En una variable table1, se crea una tabla Pandas utilizando la sintaxis Table.from_pandas(). Esta tabla se imprime para comprobar los resultados.

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)

Producción :

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

Ahora bien, estos datos se escriben en formato parquet con write_table. Al escribir un archivo de parquet, la función write_table() incluye varios argumentos para controlar diferentes configuraciones.

1. data_page_size: este parámetro regula la cantidad aproximada de páginas de datos codificadas dentro de un fragmento de columna. Actualmente, 1 MB es el valor predeterminado.
2. sabor: proporciona configuraciones de compatibilidad específicas para un consumidor de Apache Spark Parquet, como spark.
3. versión: esta es la versión adecuada del formato Parquet. Mientras que 1.0 y valores superiores garantizan la compatibilidad con lectores anteriores, 2.4 y valores superiores permiten más tipos y codificaciones de Parquet.

En este programa, el parámetro write_table() se proporciona con la tabla table1 y un archivo nativo para escribir el parquet parquet.txt.

El origen del archivo se puede indicar sin el uso de una cadena. Cualquiera de los siguientes son posibles:

• Una ruta de archivo como una cadena
• Un archivo nativo PyArrow
• Un objeto de archivo en Python

Para leer esta tabla se utiliza la función read_table(). Se utiliza una variable tabla2 para cargar la tabla en ella.

Por último, este archivo de parquet se convierte en marco de datos de Pandas utilizando table2.to_pandas() y se imprime.

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

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

table2.to_pandas()

print("\n", table2)

Producción :

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

Los archivos de parquet suelen ser archivos de datos enormes, y la lectura de archivos de parquet en Python tarda mucho tiempo en cargarse. Por lo tanto, se pueden pasar columnas específicas para leer datos rápidamente en lugar de cargar todo el archivo:

En la variable table3, se utiliza la función pq.read_table para escribir los datos. Dentro del paréntesis de parámetros, se proporcionan dos columnas: primera y tercera.

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

La salida mostrará las columnas seleccionadas.

Producción :

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

Usamos read_pandas para mantener cualquier dato de columna de índice adicional cuando leemos un subconjunto de columnas de un archivo usando un marco de datos de Pandas como fuente:

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

Producción :

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

Process finished with exit code 0

Una ruta de archivo de cadena o una instancia de NativeFile (particularmente mapas de memoria) funcionará mejor cuando se lea que un objeto de archivo de Python, que generalmente tiene la velocidad de lectura más baja.

Una o más columnas especiales se crean automáticamente cuando se usa pa.Table.from_pandas para convertir una tabla en una tabla Arrow para realizar un seguimiento del índice (etiquetas de fila). Si el índice no es valioso, se puede optar por omitirlo pasando preserve index=False porque almacenar el índice requiere más espacio de almacenamiento.

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

El archivo de parquet mostrado tiene su índice borrado.

Producción :

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

Leer metadatos de archivos de parquet usando el módulo PyArrow en Python

Además de leer datos de archivos, la clase ParquetFile, que utiliza el método read_table, ofrece funciones adicionales como la lectura de metadatos.

import pyarrow.parquet as pq

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

Producción :

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

Escribir datos en archivos Parquet usando el motor Fastparquet en Python

Es una interfaz de Python para el formato de archivo parquet.

Este programa escribe en un archivo de parquet utilizando fastparquet. Se crea un marco de datos tienda con dos columnas: estudiante y notas.

El marco de datos se escribe en un archivo de parquet sample.parquet utilizando la función dataframe.to_parquet().

El motor se selecciona como fastparquet, pero también se puede configurar como pyarrow.

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

Producción :

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

A medida que los datos se escriben en el archivo de parquet, leamos el archivo.

Lea archivos de Parquet usando Fastparquet Engine en Python

El archivo de parquet se lee mediante la función pd.read_parquet, poniendo el motor en fastparquet y almacenándolo dentro de una variable df. Luego se imprimen los resultados.

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

Producción :

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

Conclusión

Este artículo explica cómo leer archivos de parquet en Python. Los ejemplos del programa demuestran la lectura de archivos de parquet utilizando tanto pyarrow como fastparquet.

El lector debería poder crear fácilmente programas que lean archivos de parquet en Python.