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.

     

    Etiquetas:

    Deja una respuesta

    Tu direcci贸n de correo electr贸nico no ser谩 publicada. Los campos obligatorios est谩n marcados con *