Acoplar 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 sencillo como veremos. Aprenderá a aplanar diferentes formas de listas con diferentes técnicas. Entonces, saltemos

Una lista de listas

Comencemos con un ejemplo simple de convertir [[0,1], [2,3]] en [0,1,2,3]. Este tipo de aplanamiento se denomina aplanamiento superficial, ya que solo aplanará listas de un nivel de profundidad.

01
02
03
04
05
06
07
08
09
10
11
l = [[0,1],[2,3]]
 
flatten_list = []
 
for subl in l:
 
    for item in subl:
 
        flatten_list.append(item)
 
print(flatten_list)

Usando la comprensión de listas

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

1
2
3
4
5
l = [[0,1], [2,3]]
 
flatten_list = [item for subl in l for item in subl]
 
print(flatten_list)

flatten_list = [artículo para subl en l para artículo en subl]

Rompamos esta línea de código.

El primer ciclo es "para subl en l" y el segundo ciclo anidado es "para elemento en subl".

Aplanamiento profundo

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

1
2
3
4
5
l = [ [0,1], [ [2 ] ], [ 3, 4 ] ]
 
flatten_list = [item for subl in l for item in subl]
 
print(flatten_list)

Pero nuestro objetivo es convertir [[0, 1], [[2]], [3, 4]] esta lista a esta lista [0, 1, 2, 3, 4]. Este problema se puede resolver 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. Necesita instalar esta biblioteca usando

1
pip install iteration-utilities
1
2
3
4
5
6
7
from iteration_utilities import deepflatten
 
multi_depth_list = [[0,1], [[2]], [3,4]]
 
flatten_list = list(deepflatten(multi_depth_list))
 
print(flatten_list)

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

1
2
3
4
5
6
7
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)

Usando recursividad

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

1
2
3
4
5
6
7
8
9
if len(L) == 1:
 
        if type(L[0]) == list:
 
                result = flatten(L[0])
 
        else:
 
                result = L

Verifique si la longitud de la lista es igual a 1. Si es verdadero, luego verifique si el tipo del primer índice de la lista es una "lista". Si es verdadero, luego llame a la función que aplana la lista; de lo contrario, almacene el número en el resultado .

La función será así:

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
dieciséis
17
18
19
20
21
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:

Aplanar sin recursividad

Para aplanar una lista sin recursividad, usaremos un ciclo while hasta que saquemos todos los elementos de él. Eche un vistazo al código, lo comprenderá mejor:

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
dieciséis
17
18
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

Aplanar listas anidadas

Para acoplar una lista anidada, puede utilizar un aplanamiento profundo. Para listas de acoplado profundo dentro de listas, use el siguiente código:

1
2
3
4
5
6
7
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)

Además, puede usar la función recursiva como lo 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 un aplanamiento superficial de tuplas, use el siguiente código:

1
2
3
4
5
list_of_tuples = [(1,2),(3,4)]
 
flatten_list = [item for subl in list_of_tuples for item in subl]
 
print(flatten_list)

El siguiente será el resultado:

Para un aplanamiento profundo, una lista de tuplas con profundidad variable (anidadas), puede usar el código que se proporciona a continuación:

1
2
3
4
5
6
7
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)

Aplanar matriz 2d

Tomemos una matriz 2d de 5 × 5 dimensiones y la convertiremos en una lista aplanada. Verifique el siguiente código:

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
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)

Lo siguiente será el resultado del código anterior:

Una lista de matrices NumPy

Hay tres funciones integradas definidas en la biblioteca NumPy que pueden convertir la matriz NumPy en listas aplanadas.

numpy.ravel ()

numpy.flatten ()

numpy.reshape (-1)

numpy.ravel ()

1
2
3
4
5
6
7
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.flatten ()

1
2
3
4
5
6
7
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.reshape (-1)

1
2
3
4
5
6
7
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á:

La diferencia entre estas tres funciones es la velocidad . La función aplanar devuelve una copia cada vez que aplana la matriz. Por lo tanto, si tiene un gran conjunto de datos, no utilice la función aplanar; es el más lento.

Aplanar objetos JSON

Para acoplar objetos JSON, hay una función incorporada en la biblioteca flatten_json llamada flatten ().

Primero necesitas instalarlo usando pip :

1
pip install flatten_json

Entonces puedes usar esta función en nuestro código:

1
2
3
4
5
6
7
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:

Aplanar una lista de objetos

Puede 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:

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
dieciséis
17
18
19
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á el resultado del código anterior:

La misma operación se puede lograr usando también la comprensión de listas:

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
dieciséis
17
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]

El siguiente será el resultado:

Aplanar una lista de DataFrames

Para acoplar una lista de DataFrames, la biblioteca de pandas tiene una función incorporada para acoplar llamada df.concat () Echemos un vistazo al código:

01
02
03
04
05
06
07
08
09
10
11
12
13
import pandas as df
 
dataframe1 = df.DataFrame({'colum1' : [1, 2