Apache Arrow: Um guia para iniciantes com exemplos práticos

O Apache Arrow ajuda diferentes ferramentas e sistemas a compartilhar dados de forma rápida e fácil. Ele armazena dados em um formato especial baseado em colunas que permanece na memória, o que o torna muito rápido de trabalhar.

Neste tutorial, mostrarei a você os conceitos básicos do Apache Arrow. Você terá exemplos práticos para entender como ele funciona e como usá-lo em seus projetos.

O que é o Apache Arrow?

O Apache Arrowé uma plataforma de código aberto e de várias linguagens para processamento de dados na memória de alto desempenho. Ele define um formato de memória colunar padronizado, otimizadopara CPUs modernas, para permitir análises eficientes e computação vetorizada.

O Arrow também elimina a necessidade de serialização entre sistemas e linguagens, o que permite leituras de cópia zero e reduz a sobrecarga de processamento.

Como ele funciona bem com ferramentas como pandas, Apache Spark e Dask, você pode mover dados com o mínimo de esforço. Isso o torna uma excelente opção para quem está criando sistemas rápidos e flexíveis que precisam lidar com muitos dados.

Agora, vamos explorar o Arrow com alguns exemplos práticos!

Instalando o Apache Arrow

O Apache Arrow oferece suporte a várias linguagens, incluindo C, C++, C#, Python, Rust, Java, JavaScript, Julia, Go, Ruby e R. 

Ele funciona no Windows, macOS e em distribuições populares do Linux, como Debian, Ubuntu, CentOS e Red Hat Enterprise Linux.

Neste guia, você o usará com Python.

Guia de instalação passo a passo

Vamos ver como você pode instalar o Apache Arrow para Python usando as rodas binárias oficiais publicadas no PyPI. Essas etapas funcionam da mesma forma no Windows, macOS e Linux.

Etapa 1: Verifique se o Python está instalado

Abra seu terminal e execute:

python --version

Se isso retornar um número de versão, você está pronto para começar. Caso contrário, instale o Python do site oficial.

Etapa 2: Instalar pyarrow usando o pip

Para instalar o Apache Arrow para Python, execute:

pip install 'pyarrow==19.0.* '  

O site * garante que você receba a versão mais recente do patch da série 19.0. 

Também recomendo que você use pyarrow==19.0.* em seu arquivo requirements.txt para manter a consistência entre os ambientes. Isso instalará o pyarrow juntamente com as bibliotecas binárias necessárias do Apache Arrow e do Parquet C++ que acompanham o Wheel.

Para instalar o Arrow em outro idioma, consulte a documentação completa.

Testar a instalação

Você pode executar este rápido snippet Python para verificar se tudo 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)

Se o pyarrow estiver instalado corretamente, você verá a matriz impressa no terminal. Caso contrário, o código exibirá um erro.

Fundamentos do Apache Arrow

Antes de nos aprofundarmos no código, vamos entender como o Apache Arrow foi criado.

Entendendo o formato de memória colunar

O formato colunar na memória é um dos recursos mais importantes do Apache Arrow. Ele define uma estrutura de dados na memória, independente de linguagem. Além disso, inclui serialização de metadados, um protocolo para transporte de dados e uma forma padrão de representar dados entre sistemas.

Em um formato colunar, os dados são armazenados em colunas em vez de linhas, o que é diferente do armazenamento tradicional baseado em linhas. Os layouts colunares são populares para cargas de trabalho analíticas porque são muito mais rápidos de digitalizar e processar.

A imagem abaixo explica o formato:

Formato colunar. Fonte: Documentos do Apache Arrow

O formato do Apache Arrow aumenta a eficiência ao colocar as colunas em blocos de memória contíguos. Isso oferece suporte a operações vetoriais modernas (SIMD), que aceleram o processamento de dados.

Usando um layout colunar padrão, o Arrow elimina a necessidade de cada sistema definir seu formato de dados interno. Isso reduz a sobrecarga de serialização e a duplicação de esforços. 

Os sistemas podem compartilhar dados com mais facilidade, e os desenvolvedores podem reutilizar algoritmos em diferentes linguagens.

Sem um formato compartilhado como o Arrow, cada banco de dados ou ferramenta precisa serializar e desserializar os dados antes de passá-los adiante. Isso aumenta o custo e a complexidade. E os algoritmos comuns precisam ser reescritos para a estrutura de dados interna de cada sistema. 

O Arrow muda isso ao padronizando a forma como os dados são representados na memória.

Embora os formatos colunares sejam ótimos para desempenho analítico e localidade de memória, eles não foram projetados para atualizações frequentes. não foram projetados para atualizações frequentes.

Isso ocorre porque o armazenamento em colunas é otimizado para leitura rápida, não para modificação. Fazer alterações nos dados geralmente significa copiar ou realocar a memória, o que pode ser lento e exigir muitos recursos.

O Arrow se concentra na representação e na serialização eficientes na memória. Se o seu caso de uso precisar de mutação frequente de dados, você precisará lidar com isso no nível da implementação.

Para se aprofundar nos formatos compatíveis com o Arrow, confira este guiapara o Apache Parquet, ideal para o armazenamento de dados columde dados em colunas.

Estruturas de dados em forma de seta

O Apache Arrow fornece duas estruturas de dados importantes: Array e Table: 

•  Matriz de setas: Um Array representa uma única coluna de dados. Ele armazena valores em um bloco de memória contíguo, permitindo acesso rápido, varredura eficiente e suporte para otimizações no nível do processador, como SIMD. Cada matriz também pode conter metadados, como indicadores nulos (bitmaps) e informações de tipo de dados.
• Tabela de setas: Os dados geralmente vêm em formatos bidimensionais, como tabelas de banco de dados ou arquivos CSV. Portanto, um Arrow Table representa um conjunto de dados 2D. Cada coluna é uma matriz em pedaços, e todas as colunas seguem um esquema compartilhado que define os nomes e tipos de campo. Embora os blocos possam ser diferentes nas colunas, o número total de elementos deve permanecer alinhado para manter as linhas consistentes.

Você pode pensar nele como um DataFrame em pandas ou R. Ele é tabular, eficiente e suporta operações em várias colunas simultaneamente.

Exemplo de estruturas de dados básicas

Vamos dar uma olhada em alguns exemplos de criação de uma seta Array e Table em Python. 

Certifique-se de que você tenha o site pyarrow instalado antes de executar o código abaixo, seguindo as instruções anteriores.

Criando uma matriz de setas

import pyarrow as pa

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

Imprimir uma matriz de setas. Imagem do autor.

Criando uma tabela de setas

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)

Se você imprimir uma tabela de setas. Imagem do autor.          

Trabalhando com matrizes do Apache Arrow

Vamos ver como você pode trabalhar com Arrow Arrays e realizar operações comuns, como fatiamento, filtragem e verificação de metadados.

Criando matrizes de setas

As matrizes de setas funcionam com diferentes tipos de dados, incluindo cadeias de caracteres, números de ponto flutuante e inteiros. Veja como você pode criá-los:

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)

Impressão de matrizes de setas com diferentes tipos de dados. Imagem do autor.

Operações básicas em matrizes de setas

Vejamos algumas operações comuns que você pode realizar com Arrow Arrays.

Fatiamento

O fatiamento permite que você pegue uma subseção de uma matriz. Por exemplo, você pode extrair elementos em intervalos de índices específicos:

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)

Impressão de uma matriz de setas cortadas. Imagem do autor.

Filtragem e metadados

A filtragem usa uma máscara booleana para manter apenas os valores que correspondem a uma condição. Você também pode acessar metadados como tipo, comprimento e contagem 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())

Impressão de uma matriz de setas filtrada. Imagem do autor.

Impressão de metadados de uma matriz de setas. Imagem do autor.

Usando as tabelas de setas do Apache

Você pode criar tabelas de setas a partir de matrizes de setas ou diretamente de estruturas de dados nativas do Python, como dicionários. Vamos ver como. 

Criando e visualizando tabelas

Há duas maneiras comuns de criar uma tabela de setas:

1. Usando várias matrizes de setas
2. Usando um dicionário Python com pa.table()

Vamos explorar as duas formas, uma a uma.

1. Usando matrizes de setas

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)

No código acima:

• Criamos três arrays (inteiro, string, float)
• Definimos um esquema atribuindo um nome a cada coluna
• Nós os combinamos em uma tabela com pa.table()

Criando uma tabela de setas usando várias matrizes de setas. Imagem do autor.

2. Usando um dicionário Python

Agora, vamos ver como você pode criar uma tabela a partir de um dicionário 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)

Esse método é mais curto e mais compacto. Não precisamos definir matrizes manualmente; o Arrow cuida disso para nós. 

Criando uma tabela de setas diretamente dos dicionários do Python. Imagem do autor.

Convertendo entre tabelas Arrow e DataFrames do pandas

Um dos maiores pontos fortes do Arrow é sua interoperabilidade. Você pode alternar facilmente entre uma tabela de setas e um DataFrame do pandas. Vamos ver como você pode fazer isso:

Convertendo uma tabela de setas em um DataFrame do 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)

Convertendo uma tabela de setas em um DataFrame do Pandas. Imagem do autor.

Convertendo um DataFrame do Pandas em uma tabela de setas

Agora, vamos ver como você pode fazer o contrário: 

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)

Convertendo o DataFrame do pandas em uma tabela de matriz. Imagem do autor.