Flattening Data: Simplifier les Structures Complexes
Dans le monde du traitement et de l’analyse des données, il peut être difficile de gérer des structures de données hiérarchiques et multidimensionnelles. Le flattening est une technique qui simplifie ces structures de données complexes en les convertissant en un format plat et bidimensionnel.
Cet article expliquera comment aplatir les données, ses principaux concepts et les flux de travail pour organiser les données hiérarchiques et multidimensionnelles. Il couvrira également les données avec des relations. Nous discuterons aussi de l’aplatissement en utilisant des bibliothèques spécifiques et du Python simple, en fournissant des exemples en cours de route.
Comprendre le Flattening
Le flattening 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érarchiques en un seul niveau, de sorte que les données soient plus faciles à gérer et à étudier. Le flattening est utile lorsque vous travaillez avec JSON, XML ou d’autres données structurées qui ont des éléments ou des relations imbriqués.
Flattening 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 les données hiérarchiques, nous devons parcourir la structure arborescente 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 une structure de données hiérarchique en entrée. 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 pour les aplatir. La fonction renvoie les données aplaties résultantes sous forme de liste de paires clé-valeur.
Flattening des Données Multidimensionnelles
Les données multidimensionnelles consistent en plusieurs dimensions ou attributs, souvent représentés sous forme de tableaux ou de matrices. Le flattening 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 multidimensionnel à 3 dimensions 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é.
Flattening des Données avec Relations
Dans les bases de données relationnelles, une instruction SELECT JOIN combine des données provenant de plusieurs tables en utilisant leurs relations définies avec des clés étrangères. Cela permet d’interroger des données de différentes tables qui sont liées entre elles.
Les bases de données établissent des relations en utilisant des clés étrangères qui se réfèrent à des clés primaires dans d’autres tables. L’utilisation des instructions SELECT JOIN permet aux utilisateurs de récupérer des données liées de plusieurs tables dans une seule requête. Cela crée une vue dénormalisée des données.
Une instruction SELECT JOIN combine les données de différentes tables en un seul ensemble de résultats. Cependant, ce n’est pas exactement la même chose que le flattening. Le flattening, dans le sens le plus strict, est différent d’une instruction SELECT JOIN.
Le flattening consiste à changer 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 où une base de données relationnelle contient des données JSON imbriquées car cela enfreint la normalisation. Mais notez que les SGBD MySQL et PostgreSQL incluent les outils JSON.
Le flattening consiste à dénormaliser des données avec des relations ou des références de clés étrangères en combinant les informations liées en une seule table. Voici un exemple en utilisant SQL :
L’exemple fonctionne avec les données suivantes :
-- Créer la table des clients CREATE TABLE customers ( customer_id INT PRIMARY KEY, name VARCHAR(100) ); -- Créer la table des commandes 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 des produits CREATE TABLE products ( product_id INT PRIMARY KEY, name VARCHAR(100) ); -- Créer la table des éléments de commande 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 dans la table des clients INSERT INTO customers (customer_id, name) VALUES (1, 'John Doe'), (2, 'Jane Smith'); -- Insérer des données d'exemple dans la table des commandes 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'); -- Insérer des données d'exemple dans la table des produits INSERT INTO products (product_id, name) VALUES (1, 'Product A'), (2, 'Product B'), (3, 'Product C'); -- Insérer des données d'exemple dans la table des éléments de commande 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);
Le flattening est effectué par une instruction select join :
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_id
Dans cet exemple, nous avons trois tables : orders, customers, et order_items. En utilisant des jointures SQL, nous combinons les informations liées de ces tables en un seul ensemble de résultats aplatis. Les données aplaties incluent les détails de la commande ainsi que les informations correspondantes du client et du produit.
Flattening avec des Bibliothèques
Plusieurs bibliothèques en Python offrent des fonctionnalités intégrées pour aplatir les structures de données. Une bibliothèque populaire est pandas, qui propose la fonction json_normalize pour aplatir les 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 données de type JSON et l’aplatit en un DataFrame. Elle gère automatiquement les champs imbriqués en utilisant la notation point pour créer des noms de colonnes.
Conclusion
Le flattening est une technique puissante pour simplifier les structures de données hiérarchiques et multidimensionnelles. En convertissant des données complexes en un format plat et tabulaire, le flattening permet de simplifier leur traitement, analyse et visualisation. Que vous travailliez avec JSON, XML, tableaux ou données relationnelles, le flattening offre un moyen de transformer les données en un format plus gérable.
Tout au long de cet article, nous avons exploré les bases du flattening, ses principales idées et flux de travail pour diverses structures de données. Nous avons fourni des exemples en utilisant Python pur et des bibliothèques spécifiques comme ‘numpy’ et ‘pandas’. En comprenant les techniques décrites, vous pouvez gérer et analyser efficacement des structures de données complexes dans vos projets.
