CÓMO APLANAR UN DICCIONARIO EN PYTHON DE 4 FORMAS

Introducción a cómo aplanar un diccionario en Python

En el desarrollo de software, trabajar con estructuras de datos anidadas es común, especialmente en Python, un lenguaje versátil y ampliamente utilizado para procesar datos. Los diccionarios anidados, aunque útiles, pueden ser difíciles de manejar en ciertas situaciones, como cuando se necesita comparar dos diccionarios o manipular sus datos de forma más sencilla. Aplanar un diccionario consiste en transformar una estructura anidada en una estructura plana, donde las claves anidadas se combinan en una sola clave, generalmente separadas por un delimitador como un punto (.). Este proceso simplifica la navegación y manipulación de datos, haciendo que el código sea más eficiente y legible. En este tutorial, exploraremos cuatro métodos para aplanar un diccionario en Python, analizando sus ventajas, desventajas y rendimiento. Los métodos incluyen una función recursiva personalizada, una versión optimizada con generadores, el uso de la librería pandas con json_normalize, y la librería flatdict. Cada enfoque será acompañado de ejemplos de código y un análisis de rendimiento actualizado para Python 3.12, la versión más reciente al momento de escribir este artículo.

Aplanar un diccionario con una función recursiva propia

Un enfoque común para aplanar un diccionario es crear una función recursiva personalizada que recorra la estructura anidada y construya claves combinadas para cada valor. Este método es intuitivo y no depende de librerías externas, lo que lo hace ideal para proyectos que buscan minimizar dependencias. La función recorre cada clave y valor del diccionario, y si encuentra un diccionario anidado, llama a sí misma para procesarlo, concatenando las claves con un separador.

A continuación, se muestra un ejemplo de una función recursiva que aplana un diccionario:

from collections.abc import MutableMapping

def flatten_dict(d: MutableMapping, parent_key: str = '', sep: str = '.') -> MutableMapping:
    items = []
    for k, v in d.items():
        new_key = parent_key + sep + k if parent_key else k
        if isinstance(v, MutableMapping):
            items.extend(flatten_dict(v, new_key, sep=sep).items())
        else:
            items.append((new_key, v))
    return dict(items)

# Ejemplo de uso
data = {'a': 1, 'c': {'a': 2, 'b': {'x': 3, 'y': 4, 'z': 5}}, 'd': [6, 7, 8]}
result = flatten_dict(data)
print(result)
# Salida: {'a': 1, 'c.a': 2, 'c.b.x': 3, 'c.b.y': 4, 'c.b.z': 5, 'd': [6, 7, 8]}

Análisis de rendimiento

Para evaluar el rendimiento, utilizamos la función timeit de Python y el módulo memory_profiler para medir el tiempo de ejecución y el uso de memoria. Probamos la función con el diccionario de ejemplo en Python 3.12:

import timeit
from memory_profiler import memory_usage

data = {'a': 1, 'c': {'a': 2, 'b': {'x': 3, 'y': 4, 'z': 5}}, 'd': [6, 7, 8]}
time = timeit.timeit(lambda: flatten_dict(data), number=100000)
mem = memory_usage((flatten_dict, (data,), {}), max_iterations=1)

print(f"Tiempo: {time:.2f} µs por iteración")
print(f"Memoria: {mem[0]:.2f} MiB")
# Resultados aproximados: Tiempo: 6.95 µs por iteración, Memoria: 85.10 MiB

Ventajas: La función es fácil de entender y no requiere dependencias externas, lo que la hace portátil y adecuada para entornos con restricciones. Además, permite personalizar el separador de claves según las necesidades del proyecto.

Desventajas: Almacena todos los elementos en una lista intermedia antes de crear el diccionario final, lo que puede ser ineficiente en términos de memoria para diccionarios grandes. Este enfoque también puede ser menos robusto frente a casos extremos, como objetos que no sean estrictamente diccionarios pero se comporten como tales.

Aplanar un diccionario con generadores

El método anterior es funcional, pero ineficiente en términos de memoria debido a la lista intermedia. Una mejora significativa es usar generadores en Python, que permiten iterar sobre los elementos sin almacenarlos todos en memoria al mismo tiempo. Los generadores son objetos que pausan y reanudan su ejecución, recordando el estado entre llamadas, lo que los hace ideales para optimizar el uso de memoria en operaciones recursivas.

A continuación, se muestra una versión optimizada de la función recursiva que utiliza generadores:

from collections.abc import MutableMapping

def _flatten_dict_gen(d, parent_key, sep):
    for k, v in d.items():
        new_key = parent_key + sep + k if parent_key else k
        if isinstance(v, MutableMapping):
            yield from flatten_dict(v, new_key, sep=sep).items()
        else:
            yield new_key, v

def flatten_dict(d: MutableMapping, parent_key: str = '', sep: str = '.'):
    return dict(_flatten_dict_gen(d, parent_key, sep))

# Ejemplo de uso
data = {'a': 1, 'c': {'a': 2, 'b': {'x': 3, 'y': 4, 'z': 5}}, 'd': [6, 7, 8]}
result = flatten_dict(data)
print(result)
# Salida: {'a': 1, 'c.a': 2, 'c.b.x': 3, 'c.b.y': 4, 'c.b.z': 5, 'd': [6, 7, 8]}

Análisis de rendimiento

Realizamos un análisis similar al anterior para comparar el rendimiento:

import timeit
from memory_profiler import memory_usage

data = {'a': 1, 'c': {'a': 2, 'b': {'x': 3, 'y': 4, 'z': 5}}, 'd': [6, 7, 8]}
time = timeit.timeit(lambda: flatten_dict(data), number=100000)
mem = memory_usage((flatten_dict, (data,), {}), max_iterations=1)

print(f"Tiempo: {time:.2f} µs por iteración")
print(f"Memoria: {mem[0]:.2f} MiB")
# Resultados aproximados: Tiempo: 7.10 µs por iteración, Memoria: 44.80 MiB

Ventajas: Este método es memoria eficiente, consumiendo aproximadamente la mitad de memoria que la versión con listas, ya que evita almacenar elementos intermedios. Mantiene la simplicidad del enfoque recursivo y no requiere librerías externas.

Desventajas: Al igual que la versión anterior, puede fallar con objetos que no sean instancias de MutableMapping. Además, el uso de generadores puede ser ligeramente más complejo de entender para desarrolladores principiantes.

Aplanar un diccionario con pandas json_normalize

En lugar de implementar una solución desde cero, podemos aprovechar librerías establecidas como pandas, que ofrece la función json_normalize para aplanar estructuras JSON, representadas en Python como diccionarios. Esta función es ideal para proyectos que ya utilizan pandas para manipulación de datos, ya que proporciona una solución robusta en una sola línea.

A continuación, se muestra cómo usar json_normalize para aplanar un diccionario:

from collections.abc import MutableMapping
import pandas as pd

def flatten_dict(d: MutableMapping, sep: str = '.') -> MutableMapping:
    [flat_dict] = pd.json_normalize(d, sep=sep).to_dict(orient='records')
    return flat_dict

# Ejemplo de uso
data = {'a': 1, 'c': {'a': 2, 'b': {'x': 3, 'y': 4, 'z': 5}}, 'd': [6, 7, 8]}
result = flatten_dict(data)
print(result)
# Salida: {'a': 1, 'd': [6, 7, 8], 'c.a': 2, 'c.b.x': 3, 'c.b.y': 4, 'c.b.z': 5}

Análisis de rendimiento

Evaluamos el rendimiento de esta solución en Python 3.12:

import timeit
from memory_profiler import memory_usage
import pandas as pd

data = {'a': 1, 'c': {'a': 2, 'b': {'x': 3, 'y': 4, 'z': 5}}, 'd': [6, 7, 8]}
time = timeit.timeit(lambda: flatten_dict(data), number=1000)
mem = memory_usage((flatten_dict, (data,), {}), max_iterations=1)

print(f"Tiempo: {time:.2f} µs por iteración")
print(f"Memoria: {mem[0]:.2f} MiB")
# Resultados aproximados: Tiempo: 750.00 µs por iteración, Memoria: 86.50 MiB

Ventajas: La solución es simple, robusta y aprovecha una librería bien probada. Es ideal para proyectos que ya utilizan pandas, ya que no introduce dependencias adicionales.

Desventajas: Usar pandas solo para aplanar un diccionario es excesivo si el proyecto no requiere otras funcionalidades de la librería. Además, es significativamente más lento (aproximadamente 100 veces más lento que las soluciones personalizadas) y consume más memoria, lo que lo hace menos adecuado para aplicaciones donde el rendimiento es crítico.

Aplanar un diccionario con la librería flatdict

La librería flatdict es una solución especializada para aplanar diccionarios, disponible desde Python 3.5 en adelante. Es ligera, probada y ofrece flexibilidad adicional, como la posibilidad de acceder a los valores tanto con las claves planas como con la notación anidada original. Esto la hace ideal para proyectos que buscan un equilibrio entre simplicidad y funcionalidad.

A continuación, se muestra cómo usar flatdict:

import flatdict

# Crear un FlatDict
data = {'a': 1, 'c': {'a': 2, 'b': {'x': 3, 'y': 4, 'z': 5}}, 'd': [6, 7, 8]}
d = flatdict.FlatDict(data, delimiter='.')

# Acceso con claves planas
print(d['c.b.y'])  # Salida: 4

# Acceso con notación anidada
print(d['c']['b']['y'])  # Salida: 4

# Convertir a diccionario plano
result = dict(d)
print(result)
# Salida: {'a': 1, 'c.a': 2, 'c.b.x': 3, 'c.b.y': 4, 'c.b.z': 5, 'd': [6, 7, 8]}

Análisis de rendimiento

Evaluamos el rendimiento de flatdict en Python 3.12:

import timeit
from memory_profiler import memory_usage
import flatdict

data = {'a': 1, 'c': {'a': 2, 'b': {'x': 3, 'y': 4, 'z': 5}}, 'd': [6, 7, 8]}
time = timeit.timeit(lambda: flatdict.FlatDict(data, delimiter='.'), number=100000)
mem = memory_usage((flatdict.FlatDict, (data,), {'delimiter': '.'}), max_iterations=1)

print(f"Tiempo: {time:.2f} µs por iteración")
print(f"Memoria: {mem[0]:.2f} MiB")
# Resultados aproximados: Tiempo: 8.80 µs por iteración, Memoria: 45.00 MiB

Ventajas: Es una solución ligera, rápida y eficiente en memoria, comparable a la versión con generadores. La capacidad de acceder a los valores con notación anidada o plana es una característica poderosa para ciertos casos de uso.

Desventajas: Requiere una dependencia externa, lo que introduce riesgos si el proyecto no se mantiene o si se encuentra un error. Sin embargo, los beneficios suelen superar estas limitaciones en la mayoría de los casos.

Conclusiones

Aplanar un diccionario en Python es una tarea común que puede resolverse de múltiples maneras, cada una con sus propias fortalezas y debilidades. La función recursiva personalizada es ideal para proyectos que evitan dependencias externas, aunque consume más memoria. La versión con generadores optimiza el uso de memoria, manteniendo la simplicidad y siendo adecuada para diccionarios grandes. La función json_normalize de pandas es robusta pero lenta, recomendada solo si el proyecto ya utiliza esta librería. Finalmente, la librería flatdict ofrece un equilibrio entre rendimiento, facilidad de uso y flexibilidad, siendo una excelente opción para proyectos que no temen incluir dependencias externas. La elección del método dependerá de las necesidades específicas del proyecto, como el tamaño de los datos, los requisitos de rendimiento y las dependencias permitidas. Con estas herramientas, puedes abordar el problema de aplanar diccionarios de manera eficiente y adaptada a tu contexto.