Flèche Apache : Un guide pour les débutants avec des exemples pratiques

Apache Arrow permet à différents outils et systèmes de partager des données rapidement et facilement. Il stocke les données dans un format spécial basé sur des colonnes qui restent en mémoire, ce qui le rend très rapide à utiliser.

Dans ce tutoriel, je vais vous présenter les bases d'Apache Arrow. Vous aurez des exemples pratiques pour comprendre comment il fonctionne et comment l'utiliser dans vos projets.

Qu'est-ce que la flèche Apache ?

Apache Arrowest une plateforme open-source et multilingue pour le traitement de données en mémoire à haute performance. Il définit un format de mémoire en colonnes normalisé et optimisépour les processeurs modernes () afin de permettre des analyses efficaces et des calculs vectoriels.

Arrow supprime le besoin de sérialisation entre les systèmes et les langages, ce qui permet une lecture sans copie et réduit les coûts de traitement.

Parce qu'il fonctionne bien avec des outils comme pandas, Apache Spark et Dask, vous pouvez déplacer les données avec un minimum d'effort. Il s'agit donc d'un excellent choix pour tous ceux qui construisent des systèmes rapides et flexibles devant traiter de nombreuses données.

Explorons maintenant Arrow à l'aide de quelques exemples pratiques !

Installation d'Apache Arrow

Apache Arrow prend en charge de nombreux langages, notamment C, C++, C#, Python, Rust, Java, JavaScript, Julia, Go, Ruby et R. 

Il fonctionne sous Windows, macOS et les distributions Linux les plus courantes, telles que Debian, Ubuntu, CentOS et Red Hat Enterprise Linux.

Dans ce guide, nous l'utiliserons avec Python.

Guide d'installation pas à pas

Voyons comment installer Apache Arrow pour Python en utilisant les roues binaires officielles publiées sur PyPI. Ces étapes sont les mêmes pour Windows, macOS et Linux.

Étape 1 : Vérifier si Python est installé

Ouvrez votre terminal et exécutez :

python --version

Si vous obtenez un numéro de version, vous pouvez commencer. Si ce n'est pas le cas, installez Python à partir du site officiel.

Étape 2 : Installer pyarrow en utilisant pip

Pour installer Apache Arrow pour Python, exécutez :

pip install 'pyarrow==19.0.* '  

Le site * vous permet d'obtenir la dernière version des correctifs de la série 19.0. 

Je vous recommande également d'utiliser pyarrow==19.0.* dans votre fichier requirements.txt afin d'assurer la cohérence entre les différents environnements. Cela installera pyarrow ainsi que les bibliothèques binaires Apache Arrow et Parquet C++, fournies avec la roue.

Pour installer Arrow dans une autre langue, consultez la documentation complète.

Test de l'installation

Vous pouvez exécuter ce petit extrait Python pour vérifier que tout fonctionne :

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 installé correctement, vous verrez le tableau s'afficher dans votre terminal. Si ce n'est pas le cas, le code génère une erreur.

Principes fondamentaux d'Apache Arrow

Avant d'entrer dans le code, nous allons comprendre comment Apache Arrow est construit.

Comprendre le format de la mémoire en colonnes

Le format colonne en mémoire est l'une des fonctionnalités les plus importantes d'Apache Arrow. Il définit une structure de données en mémoire indépendante du langage. En outre, il comprend la sérialisation des métadonnées, un protocole pour le transport des données et une méthode standard pour représenter les données entre les systèmes.

Dans un format en colonnes, les données sont stockées en colonnes et non en lignes, ce qui est différent du stockage traditionnel en lignes. Les présentations en colonnes sont très appréciées pour les charges de travail analytiques, car elles sont beaucoup plus rapides à scanner et à traiter.

L'image ci-dessous explique le format :

Format en colonnes. Source : Documentation sur Apache Arrow

Le format d'Apache Arrow améliore l'efficacité en répartissant les colonnes dans des blocs de mémoire contigus. Il prend en charge les opérations vectorielles modernes (SIMD), qui accélèrent le traitement des données.

En utilisant une disposition en colonnes standard, Arrow évite à chaque système de devoir définir son format de données interne. Cela réduit à la fois la charge de sérialisation et la duplication des efforts. 

Les systèmes peuvent partager des données plus facilement et les développeurs peuvent réutiliser des algorithmes dans différents langages.

Sans un format partagé comme Arrow, chaque base de données ou outil doit sérialiser et désérialiser les données avant de les transmettre. Cela augmente les coûts et la complexité. De plus, les algorithmes communs doivent être réécrits pour la structure de données interne de chaque système. 

Arrow change cela en en normalisant la façon dont les données sont représentées dans la mémoire.

Bien que les formats en colonnes soient excellents pour les performances analytiques et la localité de la mémoire, ils ne sont pas conçus pour des mises à jour fréquentes. ne sont pas conçus pour des mises à jour fréquentes.

En effet, le stockage en colonnes est optimisé pour une lecture rapide, et non pour une modification. Pour modifier des données, il faut souvent copier ou réattribuer de la mémoire, ce qui peut être lent et gourmand en ressources.

Arrow se concentre sur une représentation en mémoire et une sérialisation efficaces. Si votre cas d'utilisation nécessite une mutation fréquente des données, vous devrez gérer cela au niveau de l'implémentation.

Pour approfondir les formats compatibles avec Arrow, consultez ce guide sur Apache Parquet. Apache Parquet, idéal pour le stockage de données columpour le stockage de données en colonnes.

Structures de données fléchées

Apache Arrow fournit deux structures de données clés : Array et Table: 

•  Réseau de flèches : Un site Array représente une seule colonne de données. Il stocke les valeurs dans un bloc de mémoire contiguë, ce qui permet un accès rapide, un balayage efficace et la prise en charge d'optimisations au niveau du processeur telles que SIMD. Chaque tableau peut également contenir des métadonnées telles que des indicateurs de nullité (bitmaps) et des informations sur le type de données.
• Tableau des flèches : Les données se présentent souvent sous des formats bidimensionnels, tels que des tableaux de base de données ou des fichiers CSV. Un site Arrow Table représente donc un ensemble de données en 2D. Chaque colonne est un tableau fractionné et toutes les colonnes suivent un schéma partagé qui définit les noms et les types de champs. Si les morceaux peuvent varier d'une colonne à l'autre, le nombre total d'éléments doit rester aligné pour que les lignes soient cohérentes.

Vous pouvez l'assimiler à un DataFrame dans pandas ou R. Il est tabulaire, efficace et permet d'effectuer des opérations sur plusieurs colonnes simultanément.

Exemple de structures de données de base

Voyons quelques exemples de création d'une flèche Array et Table en Python. 

Assurez-vous d'avoir installé pyarrow avant d'exécuter le code ci-dessous, en suivant les instructions précédentes.

Création d'un tableau de flèches

import pyarrow as pa

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

Imprimez un tableau de flèches. Image de l'auteur.

Création d'un tableau de flèches

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)

Imprimer un tableau de flèches. Image de l'auteur.          

Travailler avec les tableaux Apache Arrow

Voyons comment travailler avec les tableaux Arrow et effectuer des opérations courantes, telles que le découpage, le filtrage et la vérification des métadonnées.

Création de tableaux de flèches

Les tableaux de flèches fonctionnent avec différents types de données, notamment les chaînes de caractères, les nombres à virgule flottante et les nombres entiers. Voici comment les créer :

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)

Impression de tableaux de flèches avec différents types de données. Image de l'auteur.

Opérations de base sur les tableaux de flèches

Examinons quelques opérations courantes que vous pouvez effectuer avec les tableaux de flèches.

Trancher

Le découpage vous permet de saisir une sous-section d'un tableau. Par exemple, vous pouvez extraire des éléments dans des plages d'index spécifiques :

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)

Impression d'un tableau de flèches tranchées. Image par l'auteur.

Filtrage et métadonnées

Le filtrage utilise un masque booléen pour ne conserver que les valeurs qui correspondent à une condition. Vous pouvez également accéder à des métadonnées telles que le type, la longueur et le nombre de nullités. 

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())

Impression d'un tableau de flèches filtré. Image par l'auteur.

Impression des métadonnées d'un tableau de flèches. Image par l'auteur.

Utilisation des tableaux Apache Arrow

Vous pouvez créer des tableaux Arrow à partir de tableaux Arrow ou directement à partir de structures de données natives de Python comme les dictionnaires. Voyons comment. 

Création et visualisation de tableaux

Il existe deux façons courantes de créer un tableau fléché :

1. Utilisation de plusieurs tableaux de flèches
2. Utilisation d'un dictionnaire Python avec pa.table()

Explorons les deux voies l'une après l'autre.

1. Utilisation des tableaux de flèches

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)

Dans le code ci-dessus :

• Nous créons trois tableaux (integer, string, float)
• Nous définissons un schéma en donnant un nom à chaque colonne
• Nous les regroupons dans un tableau avec pa.table()

Création d'un tableau de flèches à l'aide de plusieurs tableaux de flèches. Image de l'auteur.

2. Utiliser un dictionnaire Python

Voyons maintenant comment créer un tableau à partir d'un dictionnaire 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)

Cette méthode est plus courte et plus compacte. Nous n'avons pas besoin de définir manuellement les tableaux ; Arrow s'en charge pour nous. 

Création d'un tableau de flèches directement à partir des dictionnaires Python. Image de l'auteur.

Conversion entre les tableaux Arrow et les DataFrames pandas

L'un des principaux atouts d'Arrow est son interopérabilité. Vous pouvez facilement passer d'un tableau Arrow à un DataFrame pandas. Voyons comment procéder :

Conversion d'un tableau Arrow en 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)

Conversion d'un tableau Arrow en DataFrame Pandas. Image de l'auteur.

Conversion d'un DataFrame Pandas en tableau Arrow

Voyons maintenant comment faire l'inverse : 

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)

Conversion de pandas DataFrame en tableau. Image de l'auteur.