Diferencia entre comprensión de listas y Lambda en Python

La comprensión de listas es una forma elegante de definir y crear una lista en Python . Podemos crear listas como enunciados matemáticos y en una sola línea. La sintaxis de la comprensión de listas es más fácil de entender. 

Una lista de comprensión generalmente consta de estas partes:

• expresión de salida,
• Secuencia de entrada,
• Una variable que representa un miembro de la secuencia de entrada y
• Una parte de predicado opcional.

Sintaxis de comprensión de listas

List = [expression(i) for i in another_list if filter(i)]

Ejemplo: 

lst = [x ** 2 for x in range(1, 11) if x % 2 == 1]
print(lst)

Producción:

[1, 9, 25, 49, 81]

En el ejemplo anterior,

• x ** 2 es la expresión.
• range (1, 11) es una secuencia de entrada u otra lista.
• x es la variable.
• si x % 2 == 1 es parte predicada.

¿Qué es lambda?

En Python, una función anónima significa que una función no tiene nombre. Como ya sabemos, la palabra clave def se usa para definir las funciones normales y la palabra clave lambda se usa para crear funciones anónimas. Tiene la siguiente sintaxis: 

Sintaxis de lambda

lambda arguments : expression

Ejemplo: 

lst = list(map(lambda x: x**2, range(1, 5)))
print(lst)

Producción:

[1, 4, 9, 16]

La diferencia entre Lambda y la comprensión de listas

La comprensión de listas se usa para crear listas, Lambda es una función que puede procesar como otras funciones y, por lo tanto, devolver valores o listas. 

Ejemplo: 

# list from range 0 to 10
list_ = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list_)
  
# lambda function
lambda_list = list(map(lambda x: x * 2, list_))
 
# Map basically iterates every element
# in the list_ and returns the lambda
# function result
print(lambda_list)
  
# list comprehension
list_comp = [x * 2 for x in list_]
print(list_comp)

Producción:

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

Representación gráfica de comprensión de lista vs lambda + filtro

Como podemos ver en el gráfico, la comprensión general de la lista es mucho más rápida que la función de filtro. El filtro es más rápido solo para una lista pequeña.

import numpy as np
import matplotlib.pyplot as plt
import time
 
 
# Compare runtime of both methods
sizes = [i * 10000 for i in range(100)]
 
filter_runtimes = []
list_comp_runtimes = []
 
for lis_size in sizes:
 
    lst = list(range(lis_size))
 
    # Get time stamps
    time_A = time.time()
    list(filter(lambda x: x % 2, lst))
    time_B = time.time()
    [x for x in lst if x % 2]
    time_C = time.time()
 
    # Calculate runtimes
    filter_runtimes.append((lis_size, time_B - time_A))
    list_comp_runtimes.append((lis_size, time_C - time_B))
 
 
# list comprehension vs. lambda + filter using Matplotlib
 
filt = np.array(filter_runtimes)
lis = np.array(list_comp_runtimes)
 
plt.plot(filt[:, 0], filt[:, 1], label='filter')
plt.plot(lis[:, 0], lis[:, 1], label='list comprehension')
 
plt.xlabel('list size')
plt.ylabel('runtime in seconds)')
 
plt.legend()
plt.show()

Producción: