Homepage
Centro di Conoscenza
Appianamento dei Dati: Tecniche per semplificare strutture complesse

Appianamento dei Dati: Tecniche per semplificare strutture complesse

Nel mondo dell’elaborazione e dell’analisi dei dati, gestire strutture di dati gerarchiche e multidimensionali può essere una sfida. Una soluzione comune è appianare la struttura, una tecnica che semplifica dataset complessi convertendoli in un formato bidimensionale. Questo approccio facilita l’archiviazione, l’analisi e la visualizzazione dei dati su piattaforme e strumenti.

Quando si lavora con JSON annidato, array o tabelle collegate da chiavi esterne, è spesso necessario appianare la struttura per rendere i dati utilizzabili per analisi, reportistica o machine learning. L’appianamento elimina le gerarchie annidate e posiziona tutti i valori a un unico livello, producendo colonne e righe ordinate. Ciò non solo semplifica le query, ma migliora anche la compatibilità con database relazionali e strumenti BI.

Comprendere come appianare una struttura

L’appianamento è il processo di conversione di una struttura di dati gerarchica o multidimensionale in un formato piatto e tabellare. Ciò significa trasformare relazioni annidate o gerarchiche in un unico livello, rendendo i dati più semplici da gestire e analizzare. L’appianamento risulta utile quando si lavora con JSON, XML o altri dati strutturati che presentano elementi o relazioni annidate.

Appianamento dei dati gerarchici

I dati gerarchici sono costituiti da relazioni genitore-figlio, in cui ogni elemento può avere uno o più elementi figli. Per appianare i dati gerarchici, è necessario percorrere la struttura ad albero ed estrarre le informazioni rilevanti. 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

# Esempio di utilizzo
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 la funzione flatten_hierarchical_data che prende in input una struttura di dati gerarchica. Utilizza una funzione ricorsiva traverse per attraversare gli elementi annidati. La funzione combina le chiavi con un separatore di underscore per appiattirle. Restituisce i dati appiattiti come lista di coppie chiave-valore.

Appianamento dei dati multidimensionali

I dati multidimensionali sono costituiti da più dimensioni o attributi, spesso rappresentati come array o matrici. L’appianamento dei dati multidimensionali comporta la conversione in un formato bidimensionale. Ecco un esempio che utilizza la libreria 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, disponiamo di un array tridimensionale denominato multidimensional_data. Utilizzando la funzione reshape di numpy, appianiamo l’array in un formato bidimensionale. Il parametro -1 in reshape calcola automaticamente il numero di righe in base al numero totale di elementi e al numero specificato di colonne.

Appianamento dei dati con relazioni

Nei database relazionali, una query SELECT con join combina dati da più tabelle utilizzando le relazioni definite tramite chiavi esterne. Questo consente di interrogare dati da diverse tabelle collegate tra loro.

I database stabiliscono relazioni utilizzando chiavi esterne che fanno riferimento alle chiavi primarie in altre tabelle. Utilizzare query SELECT con join permette agli utenti di recuperare dati correlati da più tabelle in un’unica query. Questo crea una vista denormalizzata dei dati.

Una query SELECT con join combina dati provenienti da tabelle differenti in un unico set di risultati. Tuttavia, non è esattamente equivalente all’appianamento. L’appianamento, nel senso stretto del termine, è diverso da una query SELECT con join.

L’appianamento implica modificare la struttura dei dati, ad esempio trasformando JSON o XML annidati in una semplice tabella. Non descriveremo qui la situazione in cui un database relazionale contiene dati JSON annidati, in quanto ciò viola la normalizzazione. Ma si noti che i RDBMS come MySQL e PostgreSQL includono strumenti per JSON.

L’appianamento comporta la denormalizzazione dei dati con relazioni o riferimenti a chiavi esterne, combinando le informazioni correlate in un’unica tabella. Ecco un esempio utilizzando SQL:

L’esempio lavora con i seguenti dati:

-- Creare la tabella customers
CREATE TABLE customers (
    customer_id INT PRIMARY KEY,
    name VARCHAR(100)
);
-- Creare la tabella orders
CREATE TABLE orders (
    order_id INT PRIMARY KEY,
    customer_id INT,
    order_date DATE,
    FOREIGN KEY (customer_id) REFERENCES customers(customer_id)
);
-- Creare la tabella products
CREATE TABLE products (
    product_id INT PRIMARY KEY,
    name VARCHAR(100)
);
-- Creare la tabella 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)
);
-- Inserire dati di esempio
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’appianamento viene eseguito tramite 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

Questo risultato è un esempio di come i join SQL possano appianare la struttura tra tabelle correlate, producendo un formato denormalizzato adatto all’analisi.

Appianamento con librerie

Diversi pacchetti in Python offrono funzionalità integrate per l’appianamento delle strutture di dati. Una libreria popolare è pandas, che offre la funzione json_normalize per appianare 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 simile a JSON e la appiana in un DataFrame. Utilizza la notazione a punti per denominare i campi annidati, rendendo più semplice il lavoro in flussi di analisi o nell’esportazione in CSV.

Conclusione

Che Lei stia preparando dati per SQL, API o dashboard, conoscere come appianare una struttura è una competenza fondamentale per chiunque lavori in data science, analisi o flussi ETL.

L’appianamento è una tecnica potente per semplificare strutture di dati gerarchiche e multidimensionali. Convertendo dati complessi in un formato piatto e tabellare, l’appianamento consente un’elaborazione, analisi e visualizzazione dei dati più agevole. Che Lei stia lavorando con JSON, XML, array o dati relazionali, l’appianamento offre un modo per trasformare i dati in un formato più gestibile.

Nel corso di questo articolo, abbiamo esplorato le basi dell’appianamento, le sue idee principali e i flussi di lavoro per diverse strutture di dati. Abbiamo fornito esempi utilizzando Python puro e librerie specifiche come numpy e pandas. Comprendendo le tecniche descritte, Lei potrà gestire e analizzare in modo efficace strutture di dati complesse nei Suoi progetti.