python - files - ¿Cuáles son las diferencias entre pluma y parquet?

pyarrow read csv

Question

Ambos son formatos de almacenamiento en columna (disco) para uso en sistemas de análisis de datos. Ambos están integrados dentro de Apache Arrow (paquete pyarrow para python) y están diseñados para corresponder con Arrow como una capa analítica en memoria de columnas.

¿Cómo difieren ambos formatos?

¿Siempre deberías preferir las plumas cuando trabajas con pandas cuando es posible?

¿Cuáles son los casos de uso donde la feather es más adecuada que el parquet y al revés?

Apéndice

Encontré algunos consejos aquí https://github.com/wesm/feather/issues/188 , pero dada la corta edad de este proyecto, posiblemente esté un poco desactualizado.

No es una prueba de velocidad seria porque solo estoy descargando y cargando un Dataframe completo, pero para darte una impresión si nunca has oído hablar de los formatos anteriores:

 # IPython    
import numpy as np
import pandas as pd
import pyarrow as pa
import pyarrow.feather as feather
import pyarrow.parquet as pq
import fastparquet as fp


df = pd.DataFrame({''one'': [-1, np.nan, 2.5],
                   ''two'': [''foo'', ''bar'', ''baz''],
                   ''three'': [True, False, True]})

print("pandas df to disk ####################################################")
print(''example_feather:'')
%timeit feather.write_feather(df, ''example_feather'')
# 2.62 ms ± 35.8 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
print(''example_parquet:'')
%timeit pq.write_table(pa.Table.from_pandas(df), ''example.parquet'')
# 3.19 ms ± 51 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
print()

print("for comparison:")
print(''example_pickle:'')
%timeit df.to_pickle(''example_pickle'')
# 2.75 ms ± 18.8 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
print(''example_fp_parquet:'')
%timeit fp.write(''example_fp_parquet'', df)
# 7.06 ms ± 205 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)
print(''example_hdf:'')
%timeit df.to_hdf(''example_hdf'', ''key_to_store'', mode=''w'', table=True)
# 24.6 ms ± 4.45 ms per loop (mean ± std. dev. of 7 runs, 100 loops each)
print()

print("pandas df from disk ##################################################")
print(''example_feather:'')
%timeit feather.read_feather(''example_feather'')
# 969 µs ± 1.8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
print(''example_parquet:'')
%timeit pq.read_table(''example.parquet'').to_pandas()
# 1.9 ms ± 5.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

print("for comparison:")
print(''example_pickle:'')
%timeit pd.read_pickle(''example_pickle'')
# 1.07 ms ± 6.21 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
print(''example_fp_parquet:'')
%timeit fp.ParquetFile(''example_fp_parquet'').to_pandas()
# 4.53 ms ± 260 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)
print(''example_hdf:'')
%timeit pd.read_hdf(''example_hdf'')
# 10 ms ± 43.4 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

# pandas version: 0.22.0
# fastparquet version: 0.1.3
# numpy version: 1.13.3
# pandas version: 0.22.0
# pyarrow version: 0.8.0
# sys.version: 3.6.3
# example Dataframe taken from https://arrow.apache.org/docs/python/parquet.html

Answer 1

• El formato de parquet está diseñado para el almacenamiento a largo plazo, donde Arrow está más diseñado para el almacenamiento a corto plazo o efímero (Arrow puede ser más adecuado para el almacenamiento a largo plazo después de la versión 1.0.0, ya que el formato binario será estable entonces)

• Escribir en parquet es más caro que Feather ya que cuenta con más capas de codificación y compresión. La pluma es una columna de flecha en bruto sin modificar. Probablemente agregaremos compresión simple a Feather en el futuro.

• Debido a la codificación del diccionario, la codificación RLE y la compresión de la página de datos, los archivos de parquet a menudo serán mucho más pequeños que los archivos Feather

• Parquet es un formato de almacenamiento estándar para análisis que es compatible con muchos sistemas diferentes: Spark, Hive, Impala, varios servicios de AWS, en el futuro por BigQuery, etc. Entonces, si está haciendo análisis, Parquet es una buena opción como un formato de almacenamiento de referencia para consulta por múltiples sistemas

Los puntos de referencia que mostraste serán muy ruidosos, ya que los datos que leíste y escribiste son muy pequeños. Debe intentar comprimir al menos 100 MB o más de 1 GB de datos para obtener algunos puntos de referencia más informativos, consulte, por ejemplo, http://wesmckinney.com/blog/python-parquet-multithreading/

Espero que esto ayude