Comprensiones de listas anidadas en Python

La comprensión de listas es una de las características más sorprendentes de Python. Es una forma inteligente y concisa de crear listas iterando sobre un objeto iterable. Las comprensiones de lista anidadas no son más que una comprensión de lista dentro de otra comprensión de lista que es bastante similar a los bucles for anidados.

Echemos un vistazo a algunos ejemplos para comprender lo que pueden hacer las comprensiones de listas anidadas:

Ejemplo 1:

I want to create a matrix which looks like below:

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

El siguiente código utiliza bucles for anidados para la tarea dada:

matrix = []
  
for i in range(5):
      
    # Append an empty sublist inside the list
    matrix.append([])
      
    for j in range(5):
        matrix[i].append(j)
          
print(matrix)

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

Se puede lograr el mismo resultado utilizando la comprensión de listas anidadas en una sola línea:

# Nested list comprehension
matrix = [[j for j in range(5)] for i in range(5)]
  
print(matrix)

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

Explicación:

La sintaxis del programa anterior se muestra a continuación:

[expresión para i en el rango (5)] -> lo que significa que ejecuta esta expresión y agrega su salida a la lista hasta que la variable i itera de 0 a 4.

Por ejemplo:- [i for i in range(5)] –> En este caso, la salida de la expresión
es simplemente la variable i y, por lo tanto, agregamos su salida a la lista mientras i
itera de 0 a 4.

Por lo tanto, la salida sería –> [0, 1, 2, 3, 4]

Pero en nuestro caso, la expresión en sí misma es una lista de comprensión. Por lo tanto, primero debemos
resolver la expresión y luego agregar su salida a la lista.

expresión = [j para j en el rango (5)] –> El resultado de esta expresión es el mismo que el
ejemplo discutido anteriormente.

Por lo tanto expresión = [0, 1, 2, 3, 4].

Ahora simplemente agregamos esta salida hasta que la variable i itere de 0 a 4, lo que sería
un total de 5 iteraciones. Por lo tanto, la salida final sería solo una lista de la salida de la
expresión anterior repetida 5 veces.

Salida: [[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4] , [0, 1, 2, 3, 4]]

Ejemplo 2:

Suppose I want to flatten a given 2-D list:

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

Expected Output: flatten_matrix = [1, 2, 3, 4, 5, 6, 7, 8, 9]

Esto se puede hacer usando bucles for anidados de la siguiente manera:

# 2-D List
matrix = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
  
flatten_matrix = []
  
for sublist in matrix:
    for val in sublist:
        flatten_matrix.append(val)
          
print(flatten_matrix)

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

Nuevamente, esto se puede hacer usando la comprensión de listas anidadas que se muestra a continuación:

# 2-D List
matrix = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
  
# Nested List Comprehension to flatten a given 2-D matrix
flatten_matrix = [val for sublist in matrix for val in sublist]
  
print(flatten_matrix)

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

Explicación:

En este caso, debemos recorrer cada elemento en la lista 2-D dada y agregarlo
a otra lista. Para una mejor comprensión, podemos dividir la lista de comprensión en
tres partes:

flatten_matrix = [val
                  for sublist in matrix
                  for val in sublist]

La primera línea sugiere lo que queremos agregar a la lista. La segunda línea es el
bucle exterior y la tercera línea es el bucle interior.

‘for sublist in matrix’ devuelve las sublistas dentro de la array una por una que serían:

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

‘for val in sublist’ devuelve todos los valores dentro de la sublista.

Por lo tanto, si sublista = [1, 2, 3], ‘para val en sublista’ -> da 1, 2, 3 como salida uno por uno.

Para cada valor de este tipo, obtenemos el resultado como valor y lo agregamos a la lista.

Ejemplo 3:

Supongamos que quiero aplanar una lista 2-D determinada e incluir solo aquellas strings cuya longitud sea inferior a 6:

planetas = [[‘Mercurio’, ‘Venus’, ‘Tierra’], [‘Marte’, ‘Júpiter’, ‘Saturno’], [‘Urano’, ‘Neptuno’, ‘Plutón’]]

Salida esperada: flatten_planets = [‘Venus’, ‘Tierra’, ‘Marte’, ‘Plutón’]

Esto se puede hacer usando una condición if dentro de un bucle for anidado que se muestra a continuación:

# 2-D List of planets
planets = [['Mercury', 'Venus', 'Earth'], ['Mars', 'Jupiter', 'Saturn'], ['Uranus', 'Neptune', 'Pluto']]
  
flatten_planets = []
  
for sublist in planets:
    for planet in sublist:
          
        if len(planet) < 6:
            flatten_planets.append(planet)
          
print(flatten_planets)

['Venus', 'Earth', 'Mars', 'Pluto']

Esto también se puede hacer usando comprensiones de listas anidadas que se muestran a continuación:

# 2-D List of planets
planets = [['Mercury', 'Venus', 'Earth'], ['Mars', 'Jupiter', 'Saturn'], ['Uranus', 'Neptune', 'Pluto']]
  
# Nested List comprehension with an if condition
flatten_planets = [planet for sublist in planets for planet in sublist if len(planet) < 6]
          
print(flatten_planets)

['Venus', 'Earth', 'Mars', 'Pluto']

Explicación:

Este ejemplo es bastante similar al ejemplo anterior, pero en este ejemplo, solo
necesitamos una condición if adicional para verificar si la longitud de un planeta en particular es menor que
6 o no.

Esto se puede dividir en 4 partes de la siguiente manera:

flatten_planets = [planet 
                   for sublist in planets 
                   for planet in sublist 
                   if len(planet) < 6]