¿Qué es Apache Arrow?
Apache Arrow es un formato de memoria columnar independiente del lenguaje para datos planos y jerárquicos. Creado por Wes McKinney (el creador de pandas) y donado a la Apache Software Foundation en 2016, Arrow se ha convertido en la lengua franca del intercambio de datos en memoria en la pila de datos moderna.
La innovación clave de Arrow no es qué almacena — es cómo lo almacena: en un diseño de memoria columnar estandarizado y sin copia que es idéntico en todos los lenguajes de programación y entornos de ejecución. Esto significa que un proceso Python puede pasar datos directamente a un proceso Java, C++, Go o R, sin sobrecarga de serialización, deserialización o copia de datos.
El problema que resuelve Arrow
Antes de Arrow, mover datos entre herramientas requería una serialización costosa. Con Arrow, los mismos datos pueden compartirse mediante punteros a los mismos buffers de memoria — sin copias, sin análisis, sin conversión de formato.
Formatos de archivo Arrow
Formato de archivo IPC de Arrow (.arrow)
El Formato de Archivo IPC (Inter-Process Communication) de Arrow (también llamado formato "Feather v2") es un formato de archivo de acceso aleatorio para almacenar datos Arrow en disco. Los archivos terminan con .arrow o .feather.
Estructura:
Bytes mágicos ("ARROW1\0\0")
Mensaje de esquema (nombres de campo, tipos, metadatos)
[Mensajes DictionaryBatch] (para columnas con codificación de diccionario)
[Mensajes RecordBatch] (filas de datos reales, en diseño columnar)
...
Pie de archivo (esquema + desplazamientos a todos los lotes de registros)
Bytes mágicos ("ARROW1")
Comparación con Parquet
| Característica | Arrow IPC | Parquet |
|---|---|---|
| Orientación | Columnar, optimizado para velocidad de lectura | Columnar, optimizado para eficiencia de almacenamiento |
| Compresión | Opcional (LZ4, ZSTD) | Fuerte (Snappy, ZSTD, GZIP) |
| Velocidad de lectura | Extremadamente rápida (mapeado en memoria) | Rápida |
| Tamaño de archivo | Mayor (menos comprimido) | Menor |
| Caso de uso | Caché en memoria, intercambio rápido | Almacenamiento a largo plazo, analítica |
| Extensión | .arrow, .feather |
.parquet |
Regla general: Usa Parquet para almacenamiento (archivos más pequeños, CDN, S3), usa Arrow para computación (lecturas rápidas, DataFrames en memoria, pipelines entre lenguajes).
Trabajar con Apache Arrow en Python
# pip install pyarrow
import pyarrow as pa
import pyarrow.ipc as ipc
import pyarrow.compute as pc
# Crear una tabla Arrow desde objetos Python
tabla = pa.table({
'id': pa.array([1, 2, 3, 4, 5], type=pa.int32()),
'nombre': pa.array(['Ana', 'Luis', 'Carmen', 'David', 'Eva']),
'puntuacion': pa.array([95.2, 87.3, 91.8, 78.5, 88.0], type=pa.float64()),
'activo': pa.array([True, True, False, True, False]),
})
print(tabla.schema)
print(f"Filas: {tabla.num_rows}, Columnas: {tabla.num_columns}")
print(f"Memoria: {tabla.nbytes / 1024:.1f} KB")
# Filtrar filas
filtrado = tabla.filter(pc.greater(tabla['puntuacion'], 88))
print(filtrado.to_pydict())
Leer y escribir archivos Arrow
import pyarrow as pa
import pyarrow.ipc as ipc
# Escribir archivo IPC de Arrow
with ipc.new_file('datos.arrow', tabla.schema) as escritor:
escritor.write_table(tabla)
# Leer archivo IPC de Arrow
with ipc.open_file('datos.arrow') as lector:
tabla2 = lector.read_all()
# Lectura mapeada en memoria (realmente sin copia)
fuente = pa.memory_map('datos.arrow', 'r')
lector = ipc.open_file(fuente)
tabla3 = lector.read_all()
# ¡Los buffers de columna de tabla3 apuntan directamente al archivo mapeado!
Integración con pandas
import pandas as pd
import pyarrow as pa
# pandas → Arrow (sin copia para tipos numéricos)
df = pd.DataFrame({'a': [1, 2, 3], 'b': [4.0, 5.0, 6.0]})
tabla_arrow = pa.Table.from_pandas(df)
# Arrow → pandas (sin copia para tipos numéricos)
df2 = tabla_arrow.to_pandas()
Integración con Polars
import polars as pl
import pyarrow as pa
# Polars usa Arrow de forma nativa
lf = pl.scan_ipc('datos.arrow')
resultado = lf.filter(pl.col('puntuacion') > 88).collect()
# Convertir entre Polars y Arrow
tabla_arrow = resultado.to_arrow()
de_vuelta_a_polars = pl.from_arrow(tabla_arrow)
Arrow Flight: Transferencia de datos de alto rendimiento
Arrow Flight es un protocolo basado en gRPC para transferir datos Arrow por la red a velocidades extremas. Transmite lotes de registros Arrow directamente sin serializar a JSON o Protocol Buffers, logrando 10-50× mayor rendimiento que las APIs REST para transferencias de grandes conjuntos de datos.
Arrow en el ecosistema
El formato de memoria columnar de Arrow se usa internamente en:
- pandas 2.0+: Los DataFrames respaldados por Arrow son la nueva opción predeterminada
- Polars: completamente nativo en Arrow; usa Arrow IPC como formato de intercambio
- Apache Spark:
spark.sql.execution.arrow.pyspark.enabled=truepermite transferencias Python↔Spark sin copia - DuckDB: usa Arrow internamente;
duckdb.arrow()devuelve una tabla Arrow directamente - RAPIDS cuDF (DataFrames GPU): diseño de memoria compatible con Arrow para intercambio GPU↔CPU
- Paquete R
{arrow}: integración completa de Arrow para data frames de R
La estandarización de Arrow como formato en memoria significa que un DataFrame de Polars, un resultado de consulta de DuckDB, un DataFrame de pandas y una partición de Spark pueden compartir los mismos buffers de memoria sin ninguna copia.
Conversiones relacionadas
Conversiones frecuentes del catálogo: