Écraser les données : Techniques pour simplifier des structures complexes
Dans le monde du traitement et de l’analyse des données, traiter des structures de données hiérarchiques et multidimensionnelles peut être complexe. Une solution courante consiste à aplatir la structure — une technique qui simplifie des ensembles de données complexes en les convertissant en un format bidimensionnel. Cette approche facilite le stockage, l’analyse et la visualisation des données sur différentes plateformes et outils.
Lorsqu’on travaille avec du JSON imbriqué, des tableaux ou des tables reliées par des clés étrangères, il est souvent nécessaire d’aplatir la structure pour rendre les données exploitables pour l’analyse, le reporting ou le machine learning. L’aplatissement élimine les hiérarchies imbriquées et place toutes les valeurs sur un seul niveau, aboutissant à des colonnes et des lignes claires. Cela non seulement simplifie les requêtes, mais améliore également la compatibilité avec les bases de données relationnelles et les outils de BI.
Comprendre comment aplatir une structure
L’aplatissement est le processus de conversion d’une structure de données hiérarchique ou multidimensionnelle en un format plat et tabulaire. Cela signifie transformer des relations imbriquées ou hiérarchisées en un seul niveau, afin que les données soient plus simples à manipuler et à étudier. L’aplatissement est utile lorsqu’on travaille avec du JSON, du XML ou d’autres données structurées comportant des éléments ou des relations imbriqués.
Aplatir des données hiérarchiques
Les données hiérarchiques consistent en des relations parent-enfant, où chaque élément peut avoir un ou plusieurs éléments enfants. Pour aplatir des données hiérarchiques, il faut parcourir la structure en forme d’arbre et extraire les informations pertinentes. Voici un exemple utilisant Python :
def flatten_hierarchical_data(data):
flattened_data = []
def traverse(node, prefix=''):
for key, value in node.items():
if isinstance(value, dict):
traverse(value, prefix + key + '_')
else:
flattened_data.append((prefix + key, value))
traverse(data)
return flattened_data
# Exemple d'utilisation
hierarchical_data = {
'person': {
'name': 'John',
'age': 30,
'address': {
'street': '123 Main St',
'city': 'New York'
}
}
}
flattened_data = flatten_hierarchical_data(hierarchical_data)
print(flattened_data)Sortie :
[('person_name', 'John'), ('person_age', 30), ('person_address_street', '123 Main St'), ('person_address_city', 'New York')]Dans cet exemple, nous définissons une fonction flatten_hierarchical_data qui prend en entrée une structure de données hiérarchique. Elle utilise une fonction récursive traverse pour parcourir les éléments imbriqués. La fonction combine les clés avec un séparateur de soulignement afin de les aplatir. La fonction retourne les données aplaties résultantes sous forme de liste de paires clé-valeur.
Aplatir des données multidimensionnelles
Les données multidimensionnelles se composent de plusieurs dimensions ou attributs, souvent représentées sous forme de tableaux ou de matrices. Aplatir des données multidimensionnelles consiste à les convertir en un format bidimensionnel. Voici un exemple utilisant la bibliothèque numpy en Python :
import numpy as np
multidimensional_data = np.array([
[[1, 2], [3, 4]],
[[5, 6], [7, 8]]
])
flattened_data = multidimensional_data.reshape(-1, multidimensional_data.shape[-1])
print(flattened_data)Sortie :
[[1 2] [3 4] [5 6] [7 8]]
Dans cet exemple, nous avons un tableau tridimensionnel multidimensional_data. En utilisant la fonction reshape de numpy, nous aplatissons le tableau en un format bidimensionnel. Le paramètre -1 dans reshape calcule automatiquement le nombre de lignes en fonction du nombre total d’éléments et du nombre de colonnes spécifié.
Aplatir des données avec des relations
Dans les bases de données relationnelles, une instruction SELECT avec jointure combine des données provenant de plusieurs tables à l’aide de leurs relations définies par des clés étrangères. Cela permet d’interroger des données provenant de différentes tables qui sont liées entre elles.
Les bases de données établissent des relations à l’aide de clés étrangères qui se réfèrent aux clés primaires d’autres tables. L’utilisation d’instructions SELECT jointes permet aux utilisateurs d’extraire des données liées à partir de plusieurs tables en une seule requête. Cela crée une vue dénormalisée des données.
Une instruction SELECT jointe combine les données de différentes tables en un seul ensemble de résultats. Cependant, cela n’est pas exactement la même chose que l’aplatissement. L’aplatissement, dans le sens strict, est différent d’une instruction SELECT jointe.
L’aplatissement signifie modifier la structure des données, comme transformer un JSON ou un XML imbriqué en une table simple. Nous ne décrirons pas ici la situation dans laquelle une base de données relationnelle contient des données JSON imbriquées, car cela enfreint la normalisation. Mais notez que les SGBDR MySQL et PostgreSQL incluent des outils JSON.
L’aplatissement consiste à dénormaliser des données avec des relations ou des références de clés étrangères en combinant les informations connexes dans une seule table. Voici un exemple utilisant SQL :
L’exemple fonctionne avec les données suivantes :
-- Créer la table customers
CREATE TABLE customers (
customer_id INT PRIMARY KEY,
name VARCHAR(100)
);
-- Créer la table orders
CREATE TABLE orders (
order_id INT PRIMARY KEY,
customer_id INT,
order_date DATE,
FOREIGN KEY (customer_id) REFERENCES customers(customer_id)
);
-- Créer la table products
CREATE TABLE products (
product_id INT PRIMARY KEY,
name VARCHAR(100)
);
-- Créer la table order_items
CREATE TABLE order_items (
order_id INT,
product_id INT,
quantity INT,
PRIMARY KEY (order_id, product_id),
FOREIGN KEY (order_id) REFERENCES orders(order_id),
FOREIGN KEY (product_id) REFERENCES products(product_id)
);
-- Insérer des données d'exemple
INSERT INTO customers (customer_id, name) VALUES (1, 'John Doe'), (2, 'Jane Smith');
INSERT INTO orders (order_id, customer_id, order_date) VALUES (1, 1, '2023-05-01'), (2, 1, '2023-05-02'), (3, 2, '2023-05-03');
INSERT INTO products (product_id, name) VALUES (1, 'Product A'), (2, 'Product B'), (3, 'Product C');
INSERT INTO order_items (order_id, product_id, quantity) VALUES (1, 1, 2), (1, 2, 1), (2, 2, 3), (3, 1, 1), (3, 3, 2);L’aplatissement est effectué par une instruction SELECT jointe :
SELECT
orders.order_id,
orders.customer_id,
customers.name AS customer_name,
orders.order_date,
order_items.product_id,
products.name AS product_name,
order_items.quantity
FROM
orders
JOIN customers ON orders.customer_id = customers.customer_id
JOIN order_items ON orders.order_id = order_items.order_id
JOIN products ON order_items.product_id = products.product_idCe résultat est un exemple de la façon dont les jointures SQL peuvent aplatir la structure de tables liées, produisant un format dénormalisé et adapté à l’analyse.
Aplatir avec des bibliothèques
Plusieurs bibliothèques en Python offrent des fonctionnalités intégrées pour aplatir des structures de données. L’une des bibliothèques populaires est pandas, qui propose la fonction json_normalize pour aplatir des données JSON.
Voici un exemple :
import pandas as pd
json_data = [
{
'name': 'John',
'age': 30,
'address': {
'street': '123 Main St',
'city': 'New York'
}
},
{
'name': 'Jane',
'age': 25,
'address': {
'street': '456 Elm St',
'city': 'London'
}
}
]
flattened_data = pd.json_normalize(json_data)
print(flattened_data)Sortie :
name age address.street address.city 0 John 30 123 Main St New York 1 Jane 25 456 Elm St London
La fonction json_normalize de pandas prend une structure de type JSON et l’aplatit dans un DataFrame. Elle utilise la notation par points pour nommer les champs imbriqués, ce qui facilite la manipulation dans les workflows analytiques ou lors de l’exportation en CSV.
Conclusion
Que vous prépariez des données pour SQL, des API ou des tableaux de bord, savoir comment aplatir une structure est une compétence essentielle pour quiconque travaille dans la science des données, l’analyse ou les workflows ETL.
L’aplatissement est une technique puissante pour simplifier des structures de données hiérarchiques et multidimensionnelles. En convertissant des données complexes en un format plat et tabulaire, l’aplatissement permet un traitement, une analyse et une visualisation des données plus aisés. Que vous travailliez avec du JSON, du XML, des tableaux ou des données relationnelles, l’aplatissement offre une manière de transformer les données en un format plus maniable.
Dans cet article, nous avons exploré les bases de l’aplatissement, ses idées principales et les workflows pour diverses structures de données. Nous avons fourni des exemples en Python classique ainsi qu’avec des bibliothèques spécifiques telles que numpy et pandas. En comprenant les techniques décrites, vous pourrez traiter et analyser efficacement des structures de données complexes dans vos projets.
