Python en Español

20+ ejemplos para aplanar listas en Python

Aplanar listas significa convertir una lista multidimensional o anidada en una lista unidimensional. Por ejemplo, el proceso de convertir esta lista [[1,2], [3,4]] en [1,2,3,4] se llama aplanamiento.

El proceso de aplanamiento es muy fácil, como veremos. Aprenderás a aplanar diferentes formas de listas con diferentes técnicas. Así que, vamos a ponernos en eso.

 

 

Una lista de listas

Comencemos con un simple ejemplo de conversión de [[0,1], [2,3]] en [0,1,2,3]. Este tipo de aplanamiento se llama aplanamiento superficial, ya que sólo aplanará listas de un nivel de profundidad.

l = [[0,1],[2,3]]

flatten_list = []

for subl in l:

    for item in subl:

        flatten_list.append(item)

print(flatten_list)

aplanamiento superficial

Utilizar la comprensión de lista

La comprensión de la lista es una forma de crear listas en una línea de código. Veamos cómo podemos usar la comprensión de listas para aplanarlas.

l = [[0,1], [2,3]]

flatten_list = [item for subl in l for item in subl]

print(flatten_list)

comprensión de lista

flatten_list = [item for subl in l for item in subl]

Rompamos esta línea de código.

El primer bucle es “para subl en l” y el segundo bucle anidado es “para el artículo en subl”.

 

Aplanamiento profundo

Cuando intentamos aplanar una lista de profundidad variable como esta [ [ 0, 1 ], [ 2 ] ] ][ 3, 4 ] ] lista con un aplanamiento poco profundo, el resultado será el siguiente:

l = [ [0,1], [ [2 ] ], [ 3, 4 ] ]

flatten_list = [item for subl in l for item in subl]

print(flatten_list)

Aplane la profundidad variable

Pero nuestro objetivo es convertir [ 0, 1 ], [ 2 ], [ 3, 4 ] ] esta lista en esta [ 0, 1, 2, 3, 4 ] lista. Puedes resolver este problema con un aplanamiento profundo. En el aplanamiento profundo, el proceso se somete a múltiples niveles de profundidad para crear una lista aplanada.

Hay una función incorporada llamada deepflatten en la biblioteca iteration_utilities. Necesitas instalar esta biblioteca usando:

pip install iteration-utilities
from iteration_utilities import deepflatten

multi_depth_list = [[0,1], [[2]], [3,4]]

flatten_list = list(deepflatten(multi_depth_list))

print(flatten_list)

Profundidad variable (iteration_utilities)

Hemos logrado nuestro objetivo. Tomemos otro ejemplo cambiando la profundidad de la lista.

from iteration_utilities import deepflatten

multi_depth_list = [[0,1], [[2, [3, [4, [5, [6 ]]]]]], [7,8]]

flatten_list = list(deepflatten(multi_depth_list))

print(flatten_list)

Profundidad variable (profundidad de cambio)

Utilizar recursión

Para aplanar una lista de forma recursiva, llamaremos a la función dentro de sí misma para que funcione hasta el final:

if len(L) == 1:

        if type(L[0]) == list:

                result = flatten(L[0])

        else:

                result = L

Comprobar si la longitud de la lista es igual a 1. Si es cierto, entonces comprobar si el tipo del primer índice de la lista es una “lista” .si es cierto, entonces llamar a la función que aplana la lista más, almacenar el número en el resultado.

La función será así:

def flatten(L):
    
    if len(L) == 1:
        
            if type(L[0]) == list:
                
                    result = flatten(L[0])
                    
            else:
                
                    result = L
                
    elif type(L[0]) == list:
        
            result = flatten(L[0]) + flatten(L[1:])
            
    else:
        
            result = [L[0]] + flatten(L[1:])
        
    return result

Cuando ejecutamos este código contra esta lista [[0,1], [2], [3,4]], los resultados serán:

Utilizar recursión

Aplanamiento sin recursión

Para aplanar una lista sin recursividad, usaremos un bucle de tiempo hasta que saquemos todos los elementos de ella. Echa un vistazo al código; tendrás una mejor comprensión:

def flatten_without_rec(non_flat):
    
    flat = []
    
    while non_flat: #runs until the given list is empty.
        
            e = non_flat.pop()
            
            if type(e) == list: #checks the type of the poped item.
                
                    non_flat.extend(e) #if list extend the item to given list.
            else:
                
                    flat.append(e) #if not list then add it to the flat list.
            
    flat.sort()
    
    return flat

Aplanamiento sin recursión

Aplanamiento de listas anidadas

Para aplanar una lista anidada, puedes usar un aplanamiento profundo. Para aplanar las listas dentro de las listas, utilice el código que se indica a continuación:

from iteration_utilities import deepflatten

multi_depth_list = [[0,1],[[2,[3,[4,[5,[6]]]]]],[7,8]]

flatten_list = list(deepflatten(multi_depth_list))

print(flatten_list)

Aplanamiento de listas anidadas

También, puedes usar la función recursiva como hicimos anteriormente.

Una lista de tuplas

Aplanar una lista de tuplas de una sola profundidad es lo mismo que aplanar listas dentro de listas. Para el aplanamiento de tuplas de poca profundidad, use el siguiente código:

list_of_tuples = [(1,2),(3,4)]

flatten_list = [item for subl in list_of_tuples for item in subl]

print(flatten_list)

Lo siguiente será la salida:

Una lista de tuplas

para aplanamiento profundo, una lista de tuplas de profundidad variable (anidadas), puede utilizar el código que se indica a continuación:

from iteration_utilities import deepflatten

multi_depth_list = [(0,1),((2,(3,(4,(5,(6)))))),(7,8)]

flatten_list = list(deepflatten(multi_depth_list))

print(flatten_list)

Una lista de tuplas (deep flattening)

Aplanamiento de arreglos 2D

Tomemos un arreglo 2d de dimensiones 5×5 y convirtámoslo en una lista aplanada. Comprueba el siguiente código:

from iteration_utilities import deepflatten

rows = 5

cols = 5

array = [[i for i in range(cols)] for j in range(rows)]

print(array)

print("After applying flattening")

flatten_list = list(deepflatten(array))

print(flatten_list)

La siguiente será la salida del código anterior:

Aplanamiento de arreglos 2D

Una lista de arreglos NumPy

Existen tres funciones incorporadas definidas en la biblioteca de NumPy que pueden convertir el arreglo NumPy en listas aplanadas.

numpy.ravel()

numpy.flatten()

numpy.reshape(-1)

 

numpy.ravel()

import numpy as np

lst = np.array([[1,2,3], [4,5,6], [7,8,9]])

out = lst.ravel()

print(out)

La salida del código será:

NumPy ravel

numpy.flatten()

import numpy as np

lst = np.array([[1,2,3], [4,5,6], [7,8,9]])

out = lst.flatten()

print(out)

La salida del código será:

NumPy flatten

numpy.reshape(-1)

import numpy as np

lst = np.array([[1,2,3], [4,5,6], [7,8,9]])

out = lst.reshape(-1)

print(out)

La salida del código será:

NumPy reshape

La diferencia entre estas tres funciones es la velocidad. La función de aplanar devuelve una copia cada vez que aplana la matriz. Así que, si tienes un gran conjunto de datos, no uses la función flatten; es la más lenta.

 

Aplanamiento de objetos JSON

Para aplanar los objetos JSON, puedes usar la función incorporada flatten() de la biblioteca flatten_json.

Primero necesitaras instalarla utilizando pip:

pip install flatten_json

Entonces ahora puedes utilizar esta funcion en nuestro codigo:

from flatten_json import flatten

sample_object = {'FirstName':'Ali', 'Address':{'City':'Lahore','State':'Punjab'}}

flat = flatten(sample_object)

print(flat)

Lo siguiente será la salida del código:

Aplanamiento de objetos JSON

Aplanamiento de una lista de objetos

Puedes aplanar una lista de objetos usando una función incorporada disponible en la biblioteca itertools con el nombre de función itertools.chain.from_iterable() Veamos cómo usar esta función:

import itertools

class numbers:

    def __init__(self):
        pass


Object1, Object2, Object3 = [numbers() for _ in range(3)]

List_of_objects = [Object1, Object2, Object3]

Object1.myList = [1, 2, 3]

Object2.myList = [4, 5, 6]

Object3.myList = [7, 8, 9]

print(list(itertools.chain.from_iterable(x.myList for x in List_of_objects)))

Lo siguiente será la salida del código anterior:

Aplanamiento de una lista de objetos

También se puede lograr la misma operación utilizando la comprensión de la lista:

class numbers:

    def __init__(self):
        pass


Object1, Object2, Object3 = [numbers() for _ in range(3)]

List_of_objects = [Object1, Object2, Object3]

Object1.myList = [1, 2, 3]

Object2.myList = [4, 5, 6]

Object3.myList = [7, 8, 9]

[i for obj in List_of_objects for i in obj.myList]

Lo siguiente será la salida:

Aplanamiento de una lista de objetos (list comprehension)

Aplanamiento de una lista de DataFrames

Para aplanar una lista de Dataframes la biblioteca de pandas tiene incorporada una función para aplanamiento llamada df.concat() vamos a ver el código:

import pandas as df

dataframe1 = df.DataFrame({'colum1' : [1, 2, 3, 4], 'colum2' : [4., 3., 2., 1.]})

dataframe2 = df.DataFrame({'colum1' : [5, 6, 7, 8], 'colum2' : [9., 10., 11., 12.]})

dataframe3 = df.DataFrame({'colum1' : [15, 16, 17, 18], 'colum2' : [19., 10., 11., 12.]})

list_of_dataframes = [dataframe1, dataframe2, dataframe3]

flatten_df = df.concat(list_of_dataframes)

print(flatten_df)

Lo siguiente será la salida.

Aplanamiento de una lista de DataFrames

Aplanamiento y remoción de duplicados

Primero, aplanaremos nuestra lista; luego eliminaremos los duplicados.

Para aplanar la lista, usaremos nuestra propia función flatten_without_rec(), y luego eliminaremos los duplicados.

Echemos un vistazo al código:

def flatten_without_rec(non_flat):
    
    flat = []

    while non_flat:  # runs until the given list is empty.

        e = non_flat.pop()
        
        if type(e) == list:  # checks the type of popped item.
            
            non_flat.extend(e)  # if list extend the item in it to given list.
            
        else:
            flat.append(e)  # if not list then add it to the flat list.
    flat.sort()
    
    return flat


nested_list = [[0, 1], [[2, [3, [4, [5, [2]]]]]], [1, 2]]

flat_list = flatten_without_rec(nested_list)

set_tuple = set(flat_list)  # converting the list into set to remove duplicates

flat_list = list(set_tuple)  # converting the set back to list

print(flat_list)

La siguiente será la salida:

Aplanamiento y remoción de duplicados

Aplanar un diccionario en una lista

Puedes aplanar un diccionario a una lista usando un simple bucle:

Echemos un vistazo al código:

dic = {
      'alex': 1,
    
      'sharukh': 2,
    
      'flex': 3
}
flat = []

for k in dic:
    
    flat.append(k)
    
    flat.append(dic[k])
    
print(flat)

La salida del siguiente código será así:

Aplanar un diccionario en una lista

También puedes lograr lo mismo usando la comprensión de la lista:

dic = {

'alex': 1,

'sharukh': 2,

'flex': 3

}

[item for k in dic for item in (k, dic[k])]

La siguiente será la salida del código:

Aplanar un diccionario en una lista (list comprehension)

 

Utilizar reduce

La función reduce() está definida en la biblioteca de functools. Primero necesitas importar reduce desde los functools.

Echemos un vistazo al código:

from functools import reduce

multi_depth_list = [[1,2,3],[3,4,5]]

reduce(list.__add__, (list(items) for items in multi_depth_list))

La salida será:

Utilizar reduce

Hemos aplanado listas con diferentes formas y tipos de diferentes maneras. Espero que encuentres útil el tutorial. Sigan regresando.

Gracias.

Mokhtar Ebrahim
Fundadora de LikeGeeks. Estoy trabajando como administrador de sistemas Linux desde 2010. Soy responsable de mantener, proteger y solucionar problemas de servidores Linux para múltiples clientes de todo el mundo. Me encanta escribir guiones de shell y Python para automatizar mi trabajo.

Deja una respuesta

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