Parquet: almacenamiento columnar rápido
Escriba un DataFrame de Pandas en Parquet con to_parquet(), vuelva a leerlo más rápido que un CSV y use la selección de columnas para cargar solo los campos necesarios.
Parquet: almacenamiento columnar rápido es una lección gratuita de Pandas & NumPy Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Pandas & NumPy Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Pandas & NumPy Academy incluye 4 lecciones en total.
¿Qué es Parquet?
Apache Parquet es un formato de archivo binario columnar diseñado para cargas de trabajo analíticas. A diferencia del CSV, que almacena los datos fila por fila como texto, Parquet almacena cada columna en un bloque contiguo, la comprime de forma eficiente y codifica metadatos. Esto lo hace mucho más rápido para las consultas que leen solo unas pocas columnas de una tabla ancha. Parquet es el formato estándar de facto en los lagos de datos (AWS S3 y Google Cloud Storage) y es compatible de forma nativa con Pandas, Dask, Spark y BigQuery.
Escritura de Parquet con to_parquet()
Convertir un DataFrame de Pandas a Parquet requiere una sola llamada a un método: df.to_parquet('output.parquet'). El motor predeterminado es pyarrow (se instala con pip install pyarrow). Parquet conserva exactamente los tipos de datos de las columnas; ya no tendrá que preocuparse de que las columnas de fechas se vuelvan a leer como cadenas. También admite compresión de forma integrada mediante el parámetro compression; 'snappy' ofrece lecturas y escrituras rápidas con una compresión moderada, mientras que 'gzip' proporciona una mayor compresión a cambio de velocidad.
import pandas as pd
import numpy as np
# Create a sample DataFrame
np.random.seed(0)
df = pd.DataFrame({
'date': pd.date_range('2024-01-01', periods=100000, freq='T'),
'value': np.random.randn(100000),
'category': np.random.choice(['A', 'B', 'C'], 100000)
})
# Write to Parquet
df.to_parquet('data.parquet', index=False, compression='snappy')
print('Written to data.parquet')Lectura de Parquet con read_parquet()
pd.read_parquet('output.parquet') vuelve a leer el archivo en un DataFrame. En comparación con la lectura del CSV equivalente, la lectura de Parquet suele ser entre 5 y 10 veces más rápida en tablas anchas con muchas columnas. Los tipos de datos se conservan exactamente: las fechas siguen siendo datetime64, las categorías siguen siendo category y los enteros siguen siendo int32 o int64, según cómo se almacenaron. No es necesario inferir los tipos porque los metadatos están integrados en el archivo.
import pandas as pd
import time
# Read Parquet
start = time.time()
df = pd.read_parquet('data.parquet')
print(f'Read Parquet: {time.time()-start:.3f}s')
print(df.dtypes)
print(df.shape)Poda de columnas: lectura solo de las columnas necesarias
La mayor ventaja del almacenamiento columnar es la poda de columnas: puede leer solo columnas específicas sin analizar el resto del archivo. Pase una lista de nombres de columnas al parámetro columns. Si una tabla de 100 columnas tiene 100 MB por columna y solo necesita 3 columnas, Parquet lee 3 MB en lugar de 10 GB. El CSV debe analizar cada carácter para extraer cualquier columna. Esto hace que Parquet sea ideal para tablas anchas en canalizaciones analíticas.
import pandas as pd
# Only load the 2 columns needed for this analysis
df = pd.read_parquet('large_table.parquet',
columns=['date', 'revenue'])
print(df.columns.tolist())
print(df.shape)
print(df.memory_usage(deep=True).sum() / 1e6, 'MB loaded')Filtrado de grupos de filas (predicate pushdown)
Parquet almacena estadísticas (mínimo/máximo) para cada grupo de filas (bloque de filas) en el pie del archivo. Cuando aplica un filtro mediante el parámetro filters, el lector omite los grupos de filas completos en los que el filtro no puede coincidir; esto se denomina predicate pushdown. Por ejemplo, al filtrar fechas en un archivo Parquet ordenado cronológicamente, se omiten bloques mensuales completos que están fuera del intervalo y solo se leen las partes pertinentes. El motor pyarrow admite esta función de forma nativa.
import pandas as pd
# Filter using predicate pushdown — row groups outside range are skipped
df = pd.read_parquet(
'time_series.parquet',
columns=['date', 'value'],
filters=[('date', '>=', '2024-06-01'),
('date', '<', '2024-07-01')]
)
print(f'Loaded {len(df):,} rows (June only)')
print(df.head())Parquet frente a CSV: comparación
Esta es una comparación práctica entre Parquet y CSV para un conjunto de datos de 10 millones de filas y 20 columnas:
- Tamaño del archivo: CSV ~2 GB, Parquet (snappy) ~400 MB
- Tiempo de lectura (todas las columnas): CSV ~15 s, Parquet ~2 s
- Tiempo de lectura (3 columnas): CSV ~15 s (debe analizarlo todo), Parquet ~0,3 s
- Conservación de tipos: CSV pierde los tipos, Parquet los conserva
- Legibilidad para las personas: CSV sí, Parquet no (binario)
En las canalizaciones de producción, donde los datos se escriben una vez y se leen muchas veces, Parquet casi siempre es la mejor opción.
Conjuntos de datos Parquet particionados
Para conjuntos de datos muy grandes, Parquet admite conjuntos de datos particionados: los datos se dividen en varios archivos organizados en una jerarquía de directorios según los valores de las columnas. Por ejemplo, particionar por año y mes crea data/year=2024/month=01/part.parquet. Al leer un conjunto de datos particionado, se filtran automáticamente los directorios que coinciden con una consulta. Esta es la disposición estándar en los lagos de datos y permite realizar consultas eficientes por intervalos sobre miles de millones de filas.
import pandas as pd
# Write a partitioned dataset (requires pyarrow)
df = pd.read_parquet('all_data.parquet')
df['year'] = df['date'].dt.year
df['month'] = df['date'].dt.month
df.to_parquet(
'partitioned_data/',
partition_cols=['year', 'month'],
index=False
)
# Creates: partitioned_data/year=2024/month=1/part-0.parquet etc.Lectura de conjuntos de datos particionados
Leer un directorio Parquet particionado es idéntico a leer un solo archivo; Pandas (mediante pyarrow) detecta automáticamente todos los archivos de las particiones. Los valores de la columna de partición se incluyen como columnas en el DataFrame resultante. También puede usar filters para aprovechar la poda de particiones, mediante la cual se omiten subárboles de directorios completos según los valores de la columna de partición. Esto hace que consultar un conjunto de datos particionado de 1 TB se sienta como leer unos pocos MB.
import pandas as pd
# Read the entire partitioned dataset
df_all = pd.read_parquet('partitioned_data/')
print('All years:', df_all['year'].unique())
# Read only 2024 data using partition pruning
df_2024 = pd.read_parquet(
'partitioned_data/',
filters=[('year', '==', 2024)]
)
print('2024 rows:', len(df_2024))Parquet con Dask
Dask lee y escribe Parquet de forma nativa mediante dd.read_parquet() y ddf.to_parquet(). Cada archivo de un directorio Parquet particionado se convierte en una partición de Dask, lo que permite realizar lecturas totalmente paralelas. Dask también aprovecha el predicate pushdown cuando se especifican filtros. Escribir un resultado grande de Dask en un conjunto de datos Parquet particionado es la forma estándar de producir resultados en las canalizaciones modernas de ingeniería de datos.
import dask.dataframe as dd
# Read partitioned Parquet with Dask (each file = one partition)
ddf = dd.read_parquet('partitioned_data/',
columns=['date', 'revenue', 'region'],
filters=[('year', '==', 2024)])
# Compute aggregation in parallel
result = ddf.groupby('region')['revenue'].sum().compute()
print(result.sort_values(ascending=False))Opciones de compresión y codificación
Parquet admite varios algoritmos de compresión y esquemas de codificación internos. Snappy (predeterminado) prioriza la velocidad con una compresión moderada. Gzip consigue archivos aproximadamente un 30 % más pequeños, pero es más lento al leer y escribir. Zstd ofrece un mejor equilibrio entre velocidad y compresión que ambos. Para las columnas de enteros, Parquet aplica automáticamente codificación delta o codificación mediante diccionario para reducir aún más el tamaño, sin que tenga que realizar ninguna configuración adicional.
import pandas as pd
import numpy as np
np.random.seed(0)
df = pd.DataFrame({'id': range(500000), 'val': np.random.randn(500000)})
for comp in ['snappy', 'gzip', 'zstd']:
fname = f'data_{comp}.parquet'
df.to_parquet(fname, compression=comp, index=False)
import os
size_mb = os.path.getsize(fname) / 1e6
print(f'{comp}: {size_mb:.2f} MB')Sustituir CSV en su canalización
La forma más sencilla de adoptar Parquet es añadir un paso de conversión único al principio del proyecto: leer el CSV una vez, limpiar los datos y convertir sus tipos, y guardarlo como Parquet. En las ejecuciones posteriores se lee el archivo Parquet en lugar del CSV. Esto proporciona mejoras inmediatas de velocidad y almacenamiento con cambios mínimos en el código. Para los datos nuevos que llegan como CSV (por ejemplo, exportaciones nocturnas), añada un paso de conversión a la canalización que escriba en Parquet antes de comenzar cualquier análisis.
import pandas as pd
# One-time conversion
df = pd.read_csv('raw_data.csv',
parse_dates=['date'],
dtype={'category': 'category',
'amount': 'float32'})
df.to_parquet('clean_data.parquet', index=False)
# All future reads use Parquet
df_fast = pd.read_parquet('clean_data.parquet')
print('Loaded from Parquet:', df_fast.dtypes.to_dict())Comprobación rápida
Ponga a prueba su comprensión de los conceptos de análisis de datos de esta lección.
Resumen de la lección
En esta lección ha aprendido que to_parquet() y read_parquet() ofrecen operaciones de E/S de archivos más rápidas, compactas y que conservan los tipos de datos, en comparación con CSV; la poda de columnas con el parámetro columns lee solo las columnas necesarias y evita analizar archivos completos; y los conjuntos de datos Parquet particionados, organizados por valores de columna, permiten podar particiones para realizar consultas de rangos de forma eficiente en lagos de datos grandes. A continuación, conectaremos Pandas con bases de datos relacionales mediante SQLAlchemy.
Aprende Python con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 30
- Lecciones
- 120
Preguntas frecuentes
¿La lección «Parquet: almacenamiento columnar rápido» es gratis?
Sí — el texto completo de «Parquet: almacenamiento columnar rápido» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Pandas & NumPy Academy, actualiza a CoddyKit PRO. El curso de Pandas & NumPy Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Parquet: almacenamiento columnar rápido»?
Escriba un DataFrame de Pandas en Parquet con to_parquet(), vuelva a leerlo más rápido que un CSV y use la selección de columnas para cargar solo los campos necesarios. Practicas Pandas & NumPy Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Pandas & NumPy Academy?
No se requiere experiencia previa. Pandas & NumPy Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.
¿Cuánto tiempo toma la lección «Parquet: almacenamiento columnar rápido»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Pandas & NumPy Academy?
Sí. Cada lección de Pandas & NumPy Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Transmitir CSV con chunksize
- Agregación incremental entre bloques
- Introducción a los DataFrames de Dask
- Parquet: almacenamiento columnar rápido