Python: cómo acoplar una lista de listas

Introducción

Una lista es la estructura de datos más flexible en Python. Considerando que, una lista 2D que se conoce comúnmente como una lista de listas, es un objeto de lista donde cada elemento es una lista en sí mismo, por ejemplo: [[1,2,3], [4,5,6], [7,8,9]].

Aplanar una lista de listas implica convertir una lista 2D en una lista 1D desanidando cada elemento de la lista almacenado en la lista de listas, es decir, convirtiendo [[1, 2, 3], [4, 5, 6], [7, 8, 9]] dentro [1, 2, 3, 4, 5, 6, 7, 8, 9].

El proceso de acoplado se puede realizar utilizando bucles for anidados, listas por comprensión, recursividad, funciones integradas o importando bibliotecas en Python, según la regularidad y profundidad de las listas anidadas.

Tipos de listas anidadas

Dado que Python tiene un tipo débil, puede encontrar listas de listas regulares e irregulares.

Lista regular de listas

Cada elemento de esta lista es una sublista, por lo que se adhiere a la uniformidad del tipo de elemento.
Ejemplo: [[1, 2, 3], [4, 5, 6], [7, 8, 9]] es una lista regular de listas como [1, 2, 3], [4, 5, 6], [7, 8, 9] es de tipo list.

Lista irregular de listas

Cada elemento de esta lista es una sublista o un elemento que no está en la lista (por ejemplo, un número entero o una cadena). Por tanto, existe una irregularidad en cuanto al tipo de elemento. Ejemplo: [[1, 2, 3], [4, 5], 6] dónde [1, 2, 3] y [4, 5] son de tipo list y 6 es de tipo int.

Aplanar lista de listas usando bucles for anidados

Este es un enfoque de fuerza bruta para obtener una lista plana seleccionando cada elemento de la lista de listas y poniéndolo en una lista 1D.

El código es intuitivo como se muestra a continuación y funciona tanto para listas de listas regulares como irregulares:

def flatten_list(_2d_list):
    flat_list = []
    # Iterate through the outer list
    for element in _2d_list:
        if type(element) is list:
            # If the element is of type list, iterate through the sublist
            for item in element:
                flat_list.append(item)
        else:
            flat_list.append(element)
    return flat_list

nested_list = [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10]]
print('Original List', nested_list)
print('Transformed Flat List', flatten_list(nested_list))

Esto resulta en:

Original List [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10]]
Transformed Flat List [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Aplanar lista de listas usando una comprensión de lista

Este enfoque proporciona una solución elegante pero menos intuitiva para crear una lista plana basada en una lista 2D existente:

regular_list = [[1, 2, 3, 4], [5, 6, 7], [8, 9]]
flat_list = [item for sublist in regular_list for item in sublist]
print('Original list', regular_list)
print('Transformed list', flat_list)

Lo que daría como resultado lo siguiente:

Original list [[1, 2, 3, 4], [5, 6, 7], [8, 9]]
Transformed list [1, 2, 3, 4, 5, 6, 7, 8, 9]

Aplanar lista de listas de forma recursiva

La lista 2D también se puede aplanar de forma recursiva. La siguiente implementación funciona tanto para listas de listas regulares como irregulares:

def flatten(list_of_lists):
    if len(list_of_lists) == 0:
        return list_of_lists
    if isinstance(list_of_lists[0], list):
        return flatten(list_of_lists[0]) + flatten(list_of_lists[1:])
    return list_of_lists[:1] + flatten(list_of_lists[1:])


print(flatten([[1, 2, 3, 4], [5, 6, 7], [8, 9], 10]))

Lo que nos daría:

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Usar bibliotecas

También puede confiar en la ayuda de las bibliotecas de Pyhon para esta tarea.

Aplanar lista de listas usando functools (reduce () e iconcat ())

los iconcat() La función realiza la operación básica de concatenación y se aplica acumulativamente a los elementos de una lista de listas, de izquierda a derecha, para reducirla a una sola lista:

import functools
import operator
regular_list = []

# Transform irregular 2D list into a regular one.
def transform(nested_list):
    for ele in nested_list:
        if type(ele) is list:
            regular_list.append(ele)
        else:
            regular_list.append([ele])
    return regular_list


irregular_list = [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10], 11]
regular_2D_list = transform(irregular_list)
print('Original list', irregular_list)
print('Transformed list', functools.reduce(operator.iconcat, regular_2D_list, []))

Lo que nos daría el resultado deseado:

Original list [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10], 11]
Transformed list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]

Aplanar lista de listas usando itertools (chain ())

Este enfoque es ideal para transformar una lista 2-D en una sola lista plana, ya que trata las secuencias consecutivas como una sola secuencia iterando a través del iterable pasado como argumento de manera secuencial.

import itertools

regular_list = [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10]]
flat_list = list(itertools.chain(*regular_list))

print('Original list', regular_list)
print('Transformed list', flat_list)

Nuevamente, esto nos daría una lista aplanada como resultado:

Original list [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10]]
Transformed list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Aplanar lista de listas usando numpy (concatenar () y plano ())

Numpy ofrece operaciones comunes que incluyen la concatenación de matrices 2D regulares en filas o columnas. También estamos usando el flat atributo para obtener un iterador 1D sobre la matriz para lograr nuestro objetivo. Sin embargo, este enfoque es relativamente lento:

import numpy

regular_list = [[1, 2, 3, 4], [5, 6, 7], [8, 9]]

flat_list = list(numpy.concatenate(regular_list).flat)

print('Original list', regular_list)
print('Transformed list', flat_list)

Lo que nos da el resultado deseado:

Original list [[1, 2, 3, 4], [5, 6, 7], [8, 9]]
Transformed list [1, 2, 3, 4, 5, 6, 7, 8, 9]

Uso de funciones integradas

La tarea de acoplar también se puede realizar mediante el uso de funciones integradas que ofrece Python.

Aplanar lista de listas usando suma

Sumar las listas internas es otra solución. La función tiene dos parámetros: iterable que es una lista de listas y start que es una lista vacía en nuestro caso que sirve como la lista plana inicial a la que se agregan elementos de las sublistas internas.

Este enfoque es conveniente ya que no tiene que importar nada, pero es más lento que itertools() y el chain() funciona cuando el número de sublistas es grande:

regular_list = [[1, 2, 3, 4], [5, 6, 7], [8, 9]]

flat_list = sum(regular_list, [])

print('Original list', regular_list)
print('Transformed list', flat_list)

Con la salida:

Original list [[1, 2, 3, 4], [5, 6, 7], [8, 9]]
Transformed list [1, 2, 3, 4, 5, 6, 7, 8, 9]

Aplanar lista de listas con Lambda

Se puede definir una función anónima utilizando la palabra clave lambda. La lista regular / irregular se pasa como argumento a esta función anónima y la evaluación de la expresión se realiza para obtener una lista 1D plana:

irregular_list = [[1, 2, 3], [3, 6, 7], [7, 5, 4],7]

# Using lambda arguments: expression
flatten_list = lambda irregular_list:[element for item in irregular_list for element in flatten_list(item)] if type(irregular_list) is list else [irregular_list]

print("Original list ", irregular_list)
print("Transformed List ", flatten_list(irregular_list))

De nuevo obtendríamos el resultado deseado:

Original list  [[1, 2, 3], [3, 6, 7], [7, 5, 4], 7]
Transformed List  [1, 2, 3, 3, 6, 7, 7, 5, 4, 7]

Conclusión

En este artículo, proporcionamos una lista extensa de formas en que podemos completar la tarea de acoplar una lista de listas en Python.