Python – Comprensión de listas

La comprensión de una lista de Python consta de corchetes que contienen la expresión, que se ejecuta para cada elemento junto con el bucle for para iterar sobre cada elemento de la lista de Python . 

La comprensión de Python List proporciona una sintaxis mucho más corta para crear una nueva lista basada en los valores de una lista existente.

Ventajas de la comprensión de listas

• Más eficiente en tiempo y espacio que los bucles.
• Requiere menos líneas de código.
• Transforma la declaración iterativa en una fórmula.

Sintaxis de comprensión de listas

newList = [ expresión(elemento) for elemento en oldList if condition ] 

Ejemplo de comprensión de listas en Python

Ejemplo 1: iteración con comprensión de lista

# Using list comprehension to iterate through loop
List = [character for character in [1, 2, 3]]
 
# Displaying list
print(List)

Producción:

[1, 2, 3]

Ejemplo 2: lista par usando comprensión de lista

list = [i for i in range(11) if i % 2 == 0]
print(list)

Producción:

[0, 2, 4, 6, 8, 10]

Ejemplo 3: Array usando comprensión de listas

matrix = [[j for j in range(3)] for i in range(3)]
   
print(matrix)

Producción:

[[0, 1, 2], [0, 1, 2], [0, 1, 2]]

Lista de comprensiones vs For Loop

Hay varias formas de iterar a través de una lista. Sin embargo, el enfoque más común es usar el bucle for . Veamos el siguiente ejemplo:

# Empty list
List = []
 
# Traditional approach of iterating
for character in 'Geeks 4 Geeks!':
    List.append(character)
 
# Display list
print(List)

Producción:

['G', 'e', 'e', 'k', 's', ' ', '4', ' ', 'G', 'e', 'e', 'k', 's', '!']

Arriba está la implementación del enfoque tradicional para iterar a través de una lista, string, tupla, etc. Ahora la comprensión de listas hace la misma tarea y también hace que el programa sea más simple. 

Las Comprensiones de listas traducen el enfoque de iteración tradicional utilizando for loop en una fórmula simple, lo que las hace fáciles de usar. A continuación se muestra el enfoque para iterar a través de una lista, string, tupla, etc. utilizando la comprensión de listas.

# Using list comprehension to iterate through loop
List = [character for character in 'Geeks 4 Geeks!']
 
# Displaying list
print(List)

Producción:

['G', 'e', 'e', 'k', 's', ' ', '4', ' ', 'G', 'e', 'e', 'k', 's', '!']

Análisis de tiempo en comprensión de listas y bucle

Las listas por comprensión son más eficientes tanto computacionalmente como en términos de espacio y tiempo de codificación que un bucle for a. Por lo general, se escriben en una sola línea de código. El siguiente programa muestra la diferencia entre los bucles for y la comprensión de listas en función del rendimiento.

# Import required module
import time
 
 
# define function to implement for loop
def for_loop(n):
    result = []
    for i in range(n):
        result.append(i**2)
    return result
 
 
# define function to implement list comprehension
def list_comprehension(n):
    return [i**2 for i in range(n)]
 
 
# Driver Code
 
# Calculate time takens by for_loop()
begin = time.time()
for_loop(10**6)
end = time.time()
 
# Display time taken by for_loop()
print('Time taken for_loop:', round(end-begin, 2))
 
# Calculate time takens by list_comprehension()
begin = time.time()
list_comprehension(10**6)
end = time.time()
 
# Display time taken by for_loop()
print('Time taken for list_comprehension:', round(end-begin, 2))

Producción:

Time taken for_loop: 0.56
Time taken for list_comprehension: 0.47

Del programa anterior, podemos ver que las listas de comprensión son bastante más rápidas que las del ciclo for.

Comprensiones de listas anidadas

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. A continuación se muestra el programa que implementa el bucle anidado:

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

Producción

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

Ahora, mediante el uso de comprensiones de listas anidadas, se puede generar el mismo resultado en menos líneas de código.

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

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

Comprensiones de lista y Lambda

Las expresiones lambda no son más que representaciones abreviadas de las funciones de Python. El uso de listas de comprensión con lambda crea una combinación eficiente. Veamos los siguientes ejemplos:

# using lambda to print table of 10
numbers = []
 
for i in range(1, 6):
    numbers.append(i*10)
 
print(numbers)

[10, 20, 30, 40, 50]

Aquí, hemos usado for loop para imprimir una tabla de 10.

numbers = [i*10 for i in range(1, 6)]
 
print(numbers)

 Producción:

[10, 20, 30, 40, 50]

 Ahora aquí, hemos usado solo la comprensión de listas para mostrar una tabla de 10.

# using lambda to print table of 10
numbers = list(map(lambda i: i*10, [i for i in range(1, 6)]))
 
print(numbers)

Producción:

[10, 20, 30, 40, 50]

Finalmente, usamos lambda + lista de comprensión para mostrar la tabla de 10. Esta combinación es muy útil para obtener soluciones eficientes en menos líneas de código para problemas complejos.

Condicionales en la comprensión de listas

También podemos agregar declaraciones condicionales a la lista de comprensión. Podemos crear una lista usando range(), operadores , etc. y también podemos aplicar algunas condiciones a la lista usando la instrucción if .

Puntos clave

• La comprensión de la lista es un medio efectivo para describir y construir listas basadas en listas actuales.
• En general, la comprensión de listas es más liviana y simple que las funciones y bucles de formación de listas estándar.
• No debemos escribir códigos largos para la comprensión de listas para garantizar un código fácil de usar.
• Cada comprensión de la lista se puede reescribir en un bucle for, pero en el contexto de la interpretación de la lista, cada bucle for no se puede reescribir.

A continuación se muestran algunos ejemplos que representan el uso de listas de comprensión en lugar del enfoque tradicional para iterar a través de iterables:

Ejemplo 1: Comprensión de listas de Python usando If-else

lis = ["Even number" if i % 2 == 0
       else "Odd number" for i in range(8)]
print(lis)

Producción:

['Even number', 'Odd number', 'Even number', 'Odd number', 'Even number',
 'Odd number', 'Even number', 'Odd number']

Ejemplo 2: IF anidado con comprensión de lista

lis = [num for num in range(100)
       if num % 5 == 0 if num % 10 == 0]
print(lis)

Producción:

[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]

Ejemplo 3: Muestra un cuadrado de números del 1 al 10.

# Getting square of from 1 to 10
squares = [n**2 for n in range(1, 11)]
 
# Display square of even numbers
print(squares)

Producción

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Ejemplo 4: Transposición de visualización de array 2D.

# Assign matrix
twoDMatrix = [[10, 20, 30],
              [40, 50, 60],
              [70, 80, 90]]
 
# Generate transpose
trans = [[i[j] for i in twoDMatrix] for j in range(len(twoDMatrix))]
 
print(trans)

Producción:

[[10, 40, 70], [20, 50, 80], [30, 60, 90]]

Ejemplo 5: cambia el caso de cada carácter en una string.

# Initializing string
string = 'Geeks4Geeks'
 
# Toggle case of each character
List = list(map(lambda i: chr(ord(i) ^ 32), string))
 
# Display list
print(List)

Producción

['g', 'E', 'E', 'K', 'S', '\x14', 'g', 'E', 'E', 'K', 'S']

Ejemplo 6: invertir cada string en una tupla.

# Reverse each string in tuple
List = [string[::-1] for string in ('Geeks', 'for', 'Geeks')]
 
# Display list
print(List)

Producción:

['skeeG', 'rof', 'skeeG']

Ejemplo 7: Muestra la suma de dígitos de todos los elementos impares en una lista.

# Explicit function
def digitSum(n):
    dsum = 0
    for ele in str(n):
        dsum += int(ele)
    return dsum
 
 
# Initializing list
List = [367, 111, 562, 945, 6726, 873]
 
# Using the function on odd elements of the list
newList = [digitSum(i) for i in List if i & 1]
 
# Displaying new list
print(newList)

Producción:

[16, 3, 18, 18]