Introducci贸n
Contenido
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.