Flattening Data: Simplifying Complex Structures
Nel mondo della elaborazione e analisi dei dati, affrontare strutture di dati gerarchiche e multidimensionali può essere una sfida. Flattening è una tecnica che semplifica queste strutture di dati complesse convertendole in un formato piatto, bidimensionale.
Questo articolo spiegherà come appiattire i dati, i suoi concetti principali e i flussi di lavoro per organizzare dati gerarchici e multidimensionali. Verranno trattati anche i dati con relazioni. Parleremo anche dell’appiattimento utilizzando librerie specifiche e Python semplice, fornendo esempi lungo il percorso.
Capire il Flattening
Il flattening è il processo di conversione di una struttura di dati gerarchica o multidimensionale in un formato tabellare piatto. Significa trasformare relazioni annidate o gerarchiche in un unico livello, rendendo i dati più semplici da gestire e studiare. Il flattening è utile quando si lavora con JSON, XML o altri dati strutturati che hanno elementi annidati o relazioni.
Appiattire Dati Gerarchici
I dati gerarchici consistono in relazioni padre-figlio, dove ogni elemento può avere uno o più elementi figli. Per appiattire i dati gerarchici, dobbiamo attraversare la struttura ad albero ed estrarre le informazioni pertinenti. Ecco un esempio utilizzando 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
# Example usage
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)
Output:
[('person_name', 'John'), ('person_age', 30), ('person_address_street', '123 Main St'), ('person_address_city', 'New York')]In questo esempio, definiamo una funzione flatten_hierarchical_data che prende una struttura di dati gerarchici come input. Utilizza una funzione ricorsiva traverse per attraversare gli elementi annidati. La funzione combina le chiavi con un separatore di underscore per appiattirle. La funzione restituisce i dati appiattiti risultanti come una lista di coppie chiave-valore.
Appiattire Dati Multidimensionali
I dati multidimensionali consistono in più dimensioni o attributi, spesso rappresentati come array o matrici. Appiattire i dati multidimensionali significa convertirli in un formato bidimensionale. Ecco un esempio utilizzando la biblioteca numpy in 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)
Output:
[[1 2] [3 4] [5 6] [7 8]]
In questo esempio, abbiamo un array tridimensionale multidimensional_data. Utilizzando la funzione reshape di numpy, appiattiamo l’array in un formato bidimensionale. Il parametro -1 in reshape calcola automaticamente il numero di righe basato sul numero totale di elementi e il numero specificato di colonne.
Appiattire Dati con Relazioni
Nei database relazionali, una SELECT con JOIN combina dati da più tabelle utilizzando le relazioni definite con chiavi esterne. Ciò consente di interrogare dati da diverse tabelle collegate insieme.
I database stabiliscono relazioni utilizzando chiavi esterne che fanno riferimento a chiavi primarie in altre tabelle. Utilizzando le istruzioni SELECT con JOIN, gli utenti possono recuperare dati correlati da più tabelle in una singola query. Questo crea una vista denormalizzata dei dati.
Un’istruzione SELECT con JOIN combina i dati di diverse tabelle in un unico set di risultati. Tuttavia, non è esattamente lo stesso che appiattire. Appiattire, nel senso più stretto, è diverso da una SELECT con JOIN.
Appiattire significa cambiare la struttura dei dati, come trasformare JSON o XML annidati in una tabella semplice. Non descriveremo qui la situazione in cui un database relazionale contiene dati JSON annidati perché ciò interrompe la normalizzazione. Ma nota che RDMS MySQL e PostgreSQL includono strumenti JSON.
Appiattire significa denormalizzare i dati con relazioni o riferimenti a chiavi esterne combinando informazioni correlate in una singola tabella. Ecco un esempio utilizzando SQL:
Questo esempio lavora con i seguenti dati:
-- Create the customers table
CREATE TABLE customers (
customer_id INT PRIMARY KEY,
name VARCHAR(100)
);
-- Create the orders table
CREATE TABLE orders (
order_id INT PRIMARY KEY,
customer_id INT,
order_date DATE,
FOREIGN KEY (customer_id) REFERENCES customers(customer_id)
);
-- Create the products table
CREATE TABLE products (
product_id INT PRIMARY KEY,
name VARCHAR(100)
);
-- Create the order_items table
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)
);
-- Insert sample data into the customers table
INSERT INTO customers (customer_id, name) VALUES
(1, 'John Doe'),
(2, 'Jane Smith');
-- Insert sample data into the orders table
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 sample data into the products table
INSERT INTO products (product_id, name) VALUES
(1, 'Product A'),
(2, 'Product B'),
(3, 'Product C');
-- Insert sample data into the order_items table
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’appiattimento viene eseguito da una SELECT con 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
In questo esempio, abbiamo tre tabelle: orders, customers e order_items. Utilizzando le JOIN SQL, combiniamo le informazioni correlate di queste tabelle in un unico set di risultati appiattito. I dati appiattiti includono i dettagli dell’ordine insieme alle informazioni del cliente e del prodotto corrispondenti.
Appiattire con Librerie
Diverse librerie in Python forniscono funzionalità integrate per appiattire le strutture dei dati. Una libreria popolare è pandas, che offre la funzione json_normalize per appiattire i dati JSON.
Ecco un esempio:
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)
Output:
name age address.street address.city 0 John 30 123 Main St New York 1 Jane 25 456 Elm St London
La funzione json_normalize in pandas prende una struttura di dati simile a JSON e la appiattisce in un DataFrame. Gestisce automaticamente i campi annidati utilizzando la notazione puntata per creare i nomi delle colonne.
Conclusione
Il flattening è una tecnica potente per semplificare le strutture di dati gerarchiche e multidimensionali. Convertendo dati complessi in un formato piatto e tabellare, il flattening consente una più facile elaborazione, analisi e visualizzazione dei dati. Che si lavori con JSON, XML, array o dati relazionali, il flattening fornisce un modo per trasformare i dati in un formato più gestibile.
In tutto l’articolo, abbiamo esplorato le basi del flattening, le sue idee principali e i flussi di lavoro per varie strutture di dati. Abbiamo fornito esempi utilizzando Python semplice e librerie specifiche come ‘numpy’ e ‘pandas’. Comprendendo le tecniche descritte, Lei può gestire e analizzare efficacemente strutture di dati complesse nei Suoi progetti.
