Inicio
Centro de Conocimiento
Aplanamiento de Datos: Técnicas para Simplificar Estructuras Complejas

Aplanamiento de Datos: Técnicas para Simplificar Estructuras Complejas

En el mundo del procesamiento y análisis de datos, tratar con estructuras de datos jerárquicas y multidimensionales puede resultar desafiante. Una solución común es aplanar la estructura, una técnica que simplifica conjuntos de datos complejos al convertirlos en un formato bidimensional. Este enfoque facilita el almacenamiento, análisis y visualización de datos a través de plataformas y herramientas.

Al trabajar con JSON anidado, arreglos o tablas vinculadas por claves foráneas, a menudo es necesario aplanar la estructura para hacer que los datos sean utilizables en análisis, reportes o aprendizaje automático. El aplanamiento elimina jerarquías anidadas y sitúa todos los valores en un único nivel, resultando en columnas y filas limpias. Esto no solo simplifica las consultas, sino que también mejora la compatibilidad con bases de datos relacionales y herramientas de inteligencia empresarial.

Comprendiendo Cómo Aplanar una Estructura

El aplanamiento es el proceso de convertir una estructura de datos jerárquica o multidimensional en un formato plano y tabular. Significa transformar relaciones anidadas o jerárquicas en un único nivel, de modo que los datos sean más sencillos de manejar y estudiar. El aplanamiento es útil cuando se trabaja con JSON, XML u otros datos estructurados que tienen elementos o relaciones anidadas.

Aplanamiento de Datos Jerárquicos

Los datos jerárquicos consisten en relaciones de padre-hijo, donde cada elemento puede tener uno o más elementos hijos. Para aplanar datos jerárquicos, es necesario recorrer la estructura en forma de árbol y extraer la información relevante. A continuación, se presenta un ejemplo utilizando 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)

Salida:

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

En este ejemplo, definimos la función flatten_hierarchical_data que toma una estructura de datos jerárquica como entrada. Utiliza una función recursiva traverse para recorrer los elementos anidados. La función combina las claves con un separador de guión bajo para aplanarlas. La función devuelve los datos aplanados resultantes como una lista de pares clave-valor.

Aplanamiento de Datos Multidimensionales

Los datos multidimensionales consisten en múltiples dimensiones o atributos, a menudo representados como arreglos o matrices. Aplanar datos multidimensionales implica convertirlos en un formato bidimensional. A continuación, se presenta un ejemplo utilizando la biblioteca 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)

Salida:

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

En este ejemplo, tenemos un arreglo tridimensional llamado multidimensional_data. Usando la función reshape de numpy, aplanamos el arreglo a un formato bidimensional. El parámetro -1 en reshape calcula automáticamente el número de filas basándose en el número total de elementos y el número de columnas especificado.

Aplanamiento de Datos con Relaciones

En las bases de datos relacionales, una sentencia SELECT unida combina datos de múltiples tablas utilizando sus relaciones definidas mediante claves foráneas. Esto permite consultar datos de tablas diferentes que están vinculadas entre sí.

Las bases de datos establecen relaciones mediante claves foráneas que hacen referencia a claves primarias en otras tablas. Utilizar sentencias SELECT con JOIN permite a los usuarios recuperar datos relacionados de múltiples tablas en una sola consulta. Esto crea una vista desnormalizada de los datos.

Una sentencia SELECT con JOIN combina datos de diferentes tablas en un único conjunto de resultados. Sin embargo, no es exactamente lo mismo que aplanar. El aplanamiento, en el sentido estricto, es diferente de una sentencia SELECT con JOIN.

Aplanar significa cambiar la estructura de los datos, como transformar JSON o XML anidados en una tabla simple. No describiremos aquí la situación en la que una base de datos relacional contiene datos JSON anidados, ya que esto rompe la normalización. Pero hay que tener en cuenta que los sistemas de gestión de bases de datos MySQL y PostgreSQL incluyen herramientas para JSON.

El aplanamiento implica desnormalizar datos con relaciones o referencias de claves foráneas al combinar información relacionada en una sola tabla. A continuación, se presenta un ejemplo utilizando SQL:

El ejemplo trabaja con los siguientes datos:

-- 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
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);

El aplanamiento se realiza mediante una sentencia 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

Este resultado es un ejemplo de cómo los JOINs en SQL pueden aplanar la estructura a través de tablas relacionadas, produciendo un formato desnormalizado y amigable para el análisis.

Aplanamiento con Bibliotecas

Varias bibliotecas en Python ofrecen funcionalidades integradas para aplanar estructuras de datos. Una biblioteca popular es pandas, que ofrece la función json_normalize para aplanar datos JSON.

A continuación, se presenta un ejemplo:

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)

Salida:

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

La función json_normalize en pandas toma una estructura similar a JSON y la aplana en un DataFrame. Utiliza la notación de puntos para nombrar campos anidados, facilitando el trabajo en flujos de análisis o al exportar a CSV.

Conclusión

Ya sea que estés preparando datos para SQL, APIs o paneles de control, saber cómo aplanar una estructura es una habilidad vital para cualquiera que trabaje en ciencia de datos, análisis o flujos de trabajo ETL.

El aplanamiento es una técnica poderosa para simplificar estructuras de datos jerárquicas y multidimensionales. Al convertir datos complejos en un formato plano y tabular, el aplanamiento permite un procesamiento, análisis y visualización de datos más sencillos. Ya sea que estés trabajando con JSON, XML, arreglos o datos relacionales, el aplanamiento ofrece una forma de transformar los datos en un formato más manejable.

A lo largo de este artículo, exploramos los conceptos básicos del aplanamiento, sus ideas principales y flujos de trabajo para diversas estructuras de datos. Proporcionamos ejemplos utilizando Python básico y bibliotecas específicas como ‘numpy’ y ‘pandas’. Al comprender las técnicas descritas, podrás manejar y analizar de manera efectiva estructuras de datos complejas en tus proyectos.