Recentemente, publiquei uma pergunta usando uma função lambda e, em uma resposta, alguém mencionou que a lambda está saindo de moda, para usar as compreensões da lista. Eu sou relativamente novo no Python. Eu fiz um teste simples:

import time

S=[x for x in range(1000000)]
T=[y**2 for y in range(300)]
#
#
time1 = time.time()
N=[x for x in S for y in T if x==y]
time2 = time.time()
print 'time diff [x for x in S for y in T if x==y]=', time2-time1
#print N
#
#
time1 = time.time()
N=filter(lambda x:x in S,T)
time2 = time.time()
print 'time diff filter(lambda x:x in S,T)=', time2-time1
#print N
#
#
#http://snipt.net/voyeg3r/python-intersect-lists/
time1 = time.time()
N = [val for val in S if val in T]
time2 = time.time()
print 'time diff [val for val in S if val in T]=', time2-time1
#print N
#
#
time1 = time.time()
N= list(set(S) & set(T))
time2 = time.time()
print 'time diff list(set(S) & set(T))=', time2-time1
#print N  #the results will be unordered as compared to the other ways!!!
#
#
time1 = time.time()
N=[]
for x in S:
    for y in T:
        if x==y:
            N.append(x)
time2 = time.time()
print 'time diff using traditional for loop', time2-time1
#print N

Todos eles imprimem o mesmo N, então eu comentei que print stmt out (exceto a última maneira que ele é desordenado), mas as diferenças de tempo resultantes foram interessantes ao longo de testes repetidos, como visto neste exemplo:

time diff [x for x in S for y in T if x==y]= 54.875
time diff filter(lambda x:x in S,T)= 0.391000032425
time diff [val for val in S if val in T]= 12.6089999676
time diff list(set(S) & set(T))= 0.125
time diff using traditional for loop 54.7970001698

Portanto, embora eu ache que a compreensão de listas é mais fácil de ler, parece haver alguns problemas de desempenho, pelo menos neste exemplo.

Então, duas perguntas:

Por que o lambda etc está sendo deixado de lado?

Para as formas de compreensão da lista, existe uma implementação mais eficiente e como você sabe que é mais eficiente sem testes? Quero dizer, lambda / map / filter deveria ser menos eficiente por causa das chamadas de funções extras, mas parece ser MAIS EFICIENTE.

Paulo