Startseite
Wissenszentrum
Daten abflachen: Techniken zur Vereinfachung komplexer Strukturen

Daten abflachen: Techniken zur Vereinfachung komplexer Strukturen

In der Welt der Datenverarbeitung und -analyse kann der Umgang mit hierarchischen und mehrdimensionalen Datenstrukturen eine Herausforderung darstellen. Eine häufige Lösung besteht darin, die Struktur abzuflachen – eine Technik, die komplexe Datensätze vereinfacht, indem sie in ein zweidimensionales Format umgewandelt werden. Dieser Ansatz erleichtert das Speichern, Analysieren und Visualisieren von Daten über verschiedene Plattformen und Werkzeuge hinweg.

Beim Arbeiten mit verschachtelten JSON, Arrays oder Tabellen, die durch Fremdschlüssel verbunden sind, ist es oft notwendig, die Struktur abzuflachen, um die Daten für Analysen, Berichte oder maschinelles Lernen nutzbar zu machen. Das Abflachen beseitigt verschachtelte Hierarchien und platziert alle Werte auf einer einzigen Ebene, was zu klaren Spalten und Zeilen führt. Dies vereinfacht nicht nur Abfragen, sondern verbessert auch die Kompatibilität mit relationalen Datenbanken und BI-Tools.

Verstehen, wie man eine Struktur abflacht

Das Abflachen ist der Prozess, eine hierarchische oder mehrdimensionale Datenstruktur in ein flaches, tabellarisches Format zu überführen. Es bedeutet, verschachtelte oder hierarchische Beziehungen auf eine einzige Ebene zu bringen, sodass die Daten einfacher zu handhaben und zu analysieren sind. Das Abflachen ist nützlich beim Arbeiten mit JSON, XML oder anderen strukturierten Daten, die verschachtelte Elemente oder Beziehungen enthalten.

Abflachen hierarchischer Daten

Hierarchische Daten bestehen aus Eltern-Kind-Beziehungen, bei denen jedes Element ein oder mehrere untergeordnete Elemente haben kann. Um hierarchische Daten abzuflachen, müssen wir die baumartige Struktur durchlaufen und die relevanten Informationen extrahieren. Hier ist ein Beispiel in 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

# Beispielverwendung
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)

Ausgabe:

[('person_name', 'John'), ('person_age', 30), ('person_address_street', '123 Main St'), ('person_address_city', 'New York')]

In diesem Beispiel definieren wir eine Funktion flatten_hierarchical_data, die eine hierarchische Datenstruktur als Eingabe nimmt. Sie verwendet eine rekursive traverse-Funktion, um verschachtelte Elemente zu durchlaufen. Die Funktion kombiniert Schlüssel mithilfe eines Unterstrichs als Trennzeichen, um sie abzuflachen. Sie gibt die resultierenden abgeflachten Daten als Liste von Schlüssel-Wert-Paaren zurück.

Abflachen mehrdimensionaler Daten

Mehrdimensionale Daten bestehen aus mehreren Dimensionen oder Attributen, die häufig als Arrays oder Matrizen dargestellt werden. Das Abflachen mehrdimensionaler Daten bedeutet, sie in ein zweidimensionales Format zu überführen. Hier ist ein Beispiel unter Verwendung der numpy-Bibliothek 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)

Ausgabe:

[[1 2]
 [3 4]
 [5 6]
 [7 8]]

In diesem Beispiel haben wir ein 3-dimensionales Array namens multidimensional_data. Durch die Verwendung der reshape-Funktion von numpy wird das Array in ein zweidimensionales Format abgeflacht. Der Parameter -1 in reshape berechnet automatisch die Anzahl der Zeilen basierend auf der Gesamtzahl der Elemente und der angegebenen Anzahl von Spalten.

Abflachen von Daten mit Relationen

In relationalen Datenbanken kombiniert eine JOINed SELECT-Anweisung Daten aus mehreren Tabellen unter Verwendung der definierten Beziehungen mittels Fremdschlüsseln. Dadurch können Daten aus verschiedenen, miteinander verknüpften Tabellen in einer einzigen Abfrage abgefragt werden.

Datenbanken stellen Beziehungen her, indem sie Fremdschlüssel verwenden, die auf Primärschlüssel in anderen Tabellen verweisen. Der Einsatz von JOINed SELECT-Anweisungen ermöglicht es den Nutzern, zusammenhängende Daten aus mehreren Tabellen in einer einzigen Abfrage abzurufen. Dies führt zu einer denormalisierten Sicht der Daten.

Eine JOINed SELECT-Anweisung kombiniert Daten aus unterschiedlichen Tabellen zu einem Ergebnisset. Allerdings ist dies nicht exakt dasselbe wie das Abflachen. Das Abflachen im strengsten Sinne unterscheidet sich von einer JOINed SELECT-Anweisung.

Das Abflachen bedeutet, die Datenstruktur zu verändern, indem beispielsweise verschachtelte JSON- oder XML-Daten in eine einfache Tabelle überführt werden. Wir werden hier nicht den Fall beschreiben, in dem eine relationale Datenbank verschachtelte JSON-Daten enthält, da dies die Normalisierung verletzt. Beachten Sie jedoch, dass MySQL- und PostgreSQL-RDMS über integrierte JSON-Tools verfügen.

Das Abflachen beinhaltet das Denormalisieren von Daten mit Beziehungen oder Fremdschlüsselverweisen, indem zusammengehörige Informationen in einer einzigen Tabelle kombiniert werden. Hier ist ein Beispiel unter Verwendung von SQL:

Das Beispiel arbeitet mit den folgenden Daten:

-- Erstelle die Tabelle customers
CREATE TABLE customers (
    customer_id INT PRIMARY KEY,
    name VARCHAR(100)
);
-- Erstelle die Tabelle orders
CREATE TABLE orders (
    order_id INT PRIMARY KEY,
    customer_id INT,
    order_date DATE,
    FOREIGN KEY (customer_id) REFERENCES customers(customer_id)
);
-- Erstelle die Tabelle products
CREATE TABLE products (
    product_id INT PRIMARY KEY,
    name VARCHAR(100)
);
-- Erstelle die Tabelle 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)
);
-- Füge Beispieldaten ein
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);

Das Abflachen wird durch einen JOINed SELECT durchgeführt:

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

Dieses Ergebnis ist ein Beispiel dafür, wie SQL-Joins Strukturen über verwandte Tabellen hinweg abflachen können und ein denormalisiertes, analysefreundliches Format erzeugen.

Abflachen mit Bibliotheken

Mehrere Bibliotheken in Python bieten eingebaute Funktionalitäten zum Abflachen von Datenstrukturen. Eine beliebte Bibliothek ist pandas, die die Funktion json_normalize zum Abflachen von JSON-Daten anbietet.

Hier ist ein Beispiel:

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)

Ausgabe:

  name  age address.street address.city
0 John   30   123 Main St    New York
1 Jane   25   456 Elm St     London

Die Funktion json_normalize in pandas nimmt eine JSON-ähnliche Struktur und flacht sie zu einem DataFrame ab. Sie verwendet die Punktnotation, um verschachtelte Felder zu benennen, was die Arbeit in Analyse-Workflows oder beim Export in CSV-Formate erleichtert.

Fazit

Egal, ob Sie Daten für SQL, APIs oder Dashboards vorbereiten – die Fähigkeit, eine Struktur abzuflachen, ist eine wesentliche Kompetenz für jeden, der in den Bereichen Data Science, Analytics oder ETL-Workflows tätig ist.

Das Abflachen ist eine leistungsstarke Technik zur Vereinfachung hierarchischer und mehrdimensionaler Datenstrukturen. Durch die Umwandlung komplexer Daten in ein flaches, tabellarisches Format wird die Datenverarbeitung, Analyse und Visualisierung erheblich erleichtert. Egal, ob Sie mit JSON, XML, Arrays oder relationalen Daten arbeiten – das Abflachen bietet eine Möglichkeit, die Daten in ein handhabbareres Format zu transformieren.

Im Verlauf dieses Artikels haben wir die Grundlagen des Abflachens, seine Hauptideen und Workflows für verschiedene Datenstrukturen untersucht. Wir haben Beispiele unter Verwendung von einfachem Python sowie spezifischer Bibliotheken wie numpy und pandas gezeigt. Durch das Verständnis der beschriebenen Techniken können Sie komplexe Datenstrukturen in Ihren Projekten effektiv handhaben und analysieren.