Flecha Apache: Guía para principiantes con ejemplos prácticos

Apache Arrow ayuda a diferentes herramientas y sistemas a compartir datos de forma rápida y sencilla. Almacena los datos en un formato especial basado en columnas que permanece en memoria, lo que hace que sea muy rápido trabajar con él.

En este tutorial, te guiaré a través de los fundamentos de Apache Arrow. Tendrás ejemplos prácticos para entender cómo funciona y cómo utilizarlo en tus proyectos.

¿Qué es Flecha Apache?

Apache Arrowes una plataforma multilingüe de código abierto para el procesamiento de datos en memoria de alto rendimiento. Define un formato de memoria columnar estandardizado y optimizadopara las CPU modernas, que permite un análisis eficiente y un cálculo vectorizado.

Arrow también elimina la necesidad de serialización entre sistemas y lenguajes, lo que permite lecturas de copia cero y reduce la sobrecarga de procesamiento.

Como funciona bien con herramientas como pandas, Apache Spark y Dask, puedes mover los datos con el mínimo esfuerzo. Esto lo convierte en una opción excelente para cualquiera que construya sistemas rápidos y flexibles que necesiten manejar muchos datos.

Ahora, ¡exploremos Arrow con algunos ejemplos prácticos!

Instalación de Apache Arrow

Apache Arrow es compatible con varios lenguajes, como C, C++, C#, Python, Rust, Java, JavaScript, Julia, Go, Ruby y R. 

Funciona en Windows, macOS y distribuciones populares de Linux, como Debian, Ubuntu, CentOS y Red Hat Enterprise Linux.

En esta guía, lo utilizaremos con Python.

Guía de instalación paso a paso

Veamos cómo instalar Apache Arrow para Python utilizando las ruedas binarias oficiales publicadas en PyPI. Estos pasos funcionan igual en Windows, macOS y Linux.

Paso 1: Comprueba si Python está instalado

Abre tu terminal y ejecuta

python --version

Si esto devuelve un número de versión, estás listo. Si no, instala Python desde el sitio oficial.

Paso 2: Instala pyarrow usando pip

Para instalar Apache Arrow para Python, ejecuta:

pip install 'pyarrow==19.0.* '  

La página * te garantiza que obtendrás la última versión del parche de la serie 19.0. 

También te recomiendo que utilices pyarrow==19.0.* en tu archivo requirements.txt para mantener la coherencia entre entornos. Esto instalará pyarrow junto con las bibliotecas binarias Apache Arrow y Parquet C++ necesarias incluidas con la rueda.

Para instalar Arrow en otro idioma, consulta la documentación completa.

Probar la instalación

Puedes ejecutar este rápido fragmento de Python para comprobar si todo funciona:

import pyarrow as pa
# Create a simple Arrow array
data = pa.array([1, 2, 3, 4, 5])
print("Apache Arrow is installed and working!")
print("Arrow Array:", data)

Si pyarrow está instalado correctamente, verás el arreglo impreso en tu terminal. Si no, el código arrojará un error.

Fundamentos de Apache Arrow

Antes de profundizar en el código, vamos a entender cómo se construye Apache Arrow.

Comprender el formato de la memoria columnar

El formato columnar en memoria es una de las características más importantes de Apache Arrow. Define una estructura de datos en memoria independiente del lenguaje. Además, incluye la serialización de metadatos, un protocolo para el transporte de datos y una forma estándar de representar datos entre sistemas.

En un formato columnar, los datos se almacenan en columnas en lugar de filas, lo que difiere del almacenamiento tradicional basado en filas. Las distribuciones en columnas son populares para las cargas de trabajo analíticas porque son mucho más rápidas de escanear y procesar.

La imagen siguiente explica el formato:

Formato columnar. Fuente: Documentación sobre Apache Arrow

El formato de Apache Arrow aumenta la eficiencia colocando las columnas en bloques de memoria contiguos. Esto admite modernas operaciones vectorizadas (SIMD), que aceleran el procesamiento de datos.

Al utilizar una disposición en columnas estándar, Arrow elimina la necesidad de que cada sistema defina su formato de datos interno. Eso reduce tanto la sobrecarga de serialización como la duplicación de esfuerzos. 

Los sistemas pueden compartir datos más fácilmente, y los programadores pueden reutilizar algoritmos en distintos lenguajes.

Sin un formato compartido como Arrow, cada base de datos o herramienta tiene que serializar y deserializar los datos antes de pasarlos. Eso añade costes y complejidad. Y los algoritmos comunes tienen que reescribirse para la estructura de datos interna de cada sistema. 

Arrow cambia esto normalizando cómo se representan los datos en la memoria.

Aunque los formatos columnares son excelentes para el rendimiento analítico y la localización en memoria, no están diseñados para actualizaciones frecuentes. no están diseñados para actualizaciones frecuentes.

Esto se debe a que el almacenamiento en columnas está optimizado para la lectura rápida, no para la modificación. Hacer cambios en los datos a menudo significa copiar o reasignar memoria, lo que puede ser lento y consumir muchos recursos.

Arrow se centra en la representación y serialización eficientes en memoria. Si tu caso de uso necesita una mutación frecuente de los datos, tendrás que gestionarlo a nivel de implementación.

Para profundizar en los formatos compatibles con Arrow, consulta esta guíade Apache Parquet, ideal para el almacenamienalmacenamiento de datos de columnas.

Estructuras de datos en flecha

Apache Arrow proporciona dos estructuras de datos clave: Array y Table: 

•  Arreglo de flechas: Un Array representa una sola columna de datos. Almacena los valores en un bloque de memoria contiguo, lo que permite un acceso rápido, un escaneo eficaz y la compatibilidad con optimizaciones a nivel de procesador como SIMD. Cada arreglo puede llevar también metadatos, como indicadores de nulos (mapas de bits) e información sobre el tipo de datos.
• Tabla de flechas: Los datos suelen presentarse en formatos bidimensionales, como tablas de bases de datos o archivos CSV. Así, un Arrow Table representa un conjunto de datos 2D. Cada columna es un arreglo en trozos, y todas las columnas siguen un esquema compartido que define los nombres y tipos de los campos. Aunque los trozos pueden diferir entre columnas, el número total de elementos debe permanecer alineado para mantener la coherencia de las filas.

Puedes pensar en él como en un DataFrame en pandas o R. Es tabular, eficiente y admite operaciones en varias columnas simultáneamente.

Ejemplo de estructuras básicas de datos

Veamos algunos ejemplos de creación de una Flecha Array y Table en Python. 

Asegúrate de que tienes instalado pyarrow antes de ejecutar el código que aparece a continuación, siguiendo las instrucciones anteriores.

Crear un arreglo de flechas

import pyarrow as pa

# Create an Arrow Array (single column)
data = pa.array([1, 2, 3, 4, 5])
print("Arrow Array:")
print(data)

Imprime un arreglo de flechas. Imagen del autor.

Crear una tabla de flechas

import pyarrow as pa

# Create an Arrow Table (multiple columns)
table = pa.table({
    'column1': pa.array([1, 2, 3]),
    'column2': pa.array(['a', 'b', 'c'])
})

print("\nArrow Table:")
print(table)

Imprimir una tabla de flechas. Imagen del autor.          

Trabajar con Arreglos Apache Arrow

Veamos cómo trabajar con Arreglos en Flecha y realizar operaciones habituales, como trocear, filtrar y comprobar metadatos.

Crear arreglos de flechas

Los Arreglos en Flecha funcionan con distintos tipos de datos, como cadenas, números en coma flotante y enteros. Aquí te explicamos cómo crearlos:

import pyarrow as pa

# Integer Array
int_array = pa.array([10, 20, 30], type=pa.int32())
print("Integer Array:")
print(int_array)

# String Array
string_array = pa.array(["apple", "banana", "cherry"], type=pa.string())
print("\nString Array:")
print(string_array)

# Floating-point Array
float_array = pa.array([1.1, 2.2, 3.3], type=pa.float64())
print("\nFloating-point Array:")
print(float_array)

Imprimir Arreglos de flechas con distintos tipos de datos. Imagen del autor.

Operaciones básicas con Arreglos en Flecha

Veamos algunas operaciones habituales que puedes realizar con los Arreglos en Flecha.

Rebanar

Rebanar te permite tomar una subsección de un arreglo. Por ejemplo, puedes extraer elementos en rangos de índices concretos:

import pyarrow as pa
arr = pa.array([10, 20, 30, 40, 50])
# Slice from index 1 to 4 (3 elements: 20, 30, 40)
sliced = arr.slice(1, 3)
print("Original Array:", arr)
print("Sliced Array (1:4):", sliced)

Imprimir un arreglo de flechas troceado. Imagen del autor.

Filtrado y metadatos

El filtrado utiliza una máscara booleana para conservar sólo los valores que cumplen una condición. También puedes acceder a metadatos como tipo, longitud y recuento de nulos. 

import pyarrow.compute as pc

arr = pa.array([10, 20, 30, 40, 50])

# Create a boolean mask: Keep elements > 25
mask = pc.greater(arr, pa.scalar(25))

# Apply the filter
filtered = pc.filter(arr, mask)

print("Filtered Array (values > 25):", filtered)

print("Array Type:", arr.type)
print("Array Length:", len(arr))
print("Null Count:", arr.null_count)
print("Is Null Bitmap Buffers:", arr.buffers())

Imprimir un arreglo de flechas filtrado. Imagen del autor.

Impresión de metadatos de un arreglo de flechas. Imagen del autor.

Utilizar tablas de flechas Apache

Puedes crear Tablas Flecha a partir de Arreglos Flecha o directamente a partir de estructuras de datos nativas de Python, como los diccionarios. Veamos cómo. 

Crear y visualizar tablas

Hay dos formas habituales de crear una tabla de flechas:

1. Utilizar varios Arreglos de Flechas
2. Utilizar un diccionario Python con pa.table()

Exploremos ambas vías una por una.

1. Uso de arreglos de flechas

import pyarrow as pa

# Create individual Arrow Arrays
ids = pa.array([1, 2, 3])
names = pa.array(['Alice', 'Bob', 'Charlie'])
scores = pa.array([85.0, 92.5, 78.3])

# Combine them into a Table
table = pa.table({
    'id': ids,
    'name': names,
    'score': scores
})

print("Arrow Table from Arrays:")
print(table)

En el código anterior:

• Creamos tres arreglos (entero, cadena, flotante)
• Definimos un esquema dando un nombre a cada columna
• Las combinamos en una Tabla con pa.table()

Crear una tabla de flechas utilizando varios arreglos de flechas. Imagen del autor.

2. Utilizar un diccionario Python

Veamos ahora cómo crear una Tabla a partir de un diccionario Python.

# Create a table directly from Python data
data = {
    'id': [4, 5, 6],
    'name': ['Diana', 'Eve', 'Frank'],
    'score': [88.0, 79.5, 91.2]
}

table2 = pa.table(data)

print("\nArrow Table from Dictionary:")
print(table2)

Este método es más corto y compacto. No tenemos que definir los arreglos manualmente; Arrow lo hace por nosotros. 

Crear una tabla de flechas directamente a partir de diccionarios de Python. Imagen del autor.

Conversión entre Tablas Flecha y DataFrames pandas

Uno de los mayores puntos fuertes de Arrow es su interoperabilidad. Puedes moverte fácilmente entre una Tabla Flecha y un DataFrame pandas. Veamos cómo hacerlo:

Convertir una tabla Arrow en un DataFrame Pandas

import pyarrow as pa
import pandas as pd

# Create an Arrow Table
data = {
    'numbers': [1, 2, 3],
    'fruits': ['apple', 'banana', 'cherry'],
    'prices': [1.1, 2.2, 3.3]
}
arrow_table = pa.table(data)

# Convert Arrow Table to pandas DataFrame
df = arrow_table.to_pandas()

# Show the DataFrame
print(df)

Convertir una tabla Arrow en un DataFrame Pandas. Imagen del autor.

Convertir un DataFrame de Pandas en una tabla de flechas

Veamos ahora cómo hacer lo contrario: 

import pyarrow as pa
import pandas as pd

# Create a pandas DataFrame
df = pd.DataFrame({
    'numbers': [1, 2, 3],
    'fruits': ['apple', 'banana', 'cherry'],
    'prices': [1.1, 2.2, 3.3]
})

# Convert pandas DataFrame to Arrow Table
arrow_table = pa.Table.from_pandas(df)

# Show the Arrow Table
print(arrow_table)

Convertir un DataFrame de pandas en una tabla de arreglo. Imagen del autor.