É Pythônico usar compreensões de lista apenas para efeitos colaterais?

Pense em uma função que estou chamando por seus efeitos colaterais, não por valores de retorno (como imprimir na tela, atualizar a GUI, imprimir em um arquivo etc.).

def fun_with_side_effects(x):
    ...side effects...
    return y

Agora, é Pythônico usar compreensões de lista para chamar esta função:

[fun_with_side_effects(x) for x in y if (...conditions...)]

Observe que eu não salvo a lista em nenhum lugar

Ou devo chamar essa função assim:

for x in y:
    if (...conditions...):
        fun_with_side_effects(x)

Qual é melhor e por que?

É muito anti-pitônico fazer isso, e qualquer pythonista experiente vai te dar uma bronca por isso. A lista intermediária é descartada após ser criada e pode ser potencialmente muito grande e, portanto, cara de criar.

Você não deve usar uma compreensão de lista , porque como as pessoas disseram, construirá uma grande lista temporária de que você não precisa. Os dois métodos a seguir são equivalentes:

consume(side_effects(x) for x in xs)

for x in xs:
    side_effects(x)

com a definição de consumeda itertoolspágina de manual:

def consume(iterator, n=None):
    "Advance the iterator n-steps ahead. If n is none, consume entirely."
    # Use functions that consume iterators at C speed.
    if n is None:
        # feed the entire iterator into a zero-length deque
        collections.deque(iterator, maxlen=0)
    else:
        # advance to the empty slice starting at position n
        next(islice(iterator, n, n), None)

Claro, o último é mais claro e fácil de entender.

As compreensões de lista servem para criar listas. E a menos que você esteja realmente criando uma lista, você não deve usar compreensões lista.

Portanto, eu escolheria a segunda opção, apenas iterar a lista e, em seguida, chamar a função quando as condições se aplicassem.

O segundo é melhor.

Pense na pessoa que precisa entender seu código. Você pode obter carma ruim facilmente com o primeiro :)

Você pode ir no meio dos dois usando filter (). Considere o exemplo:

y=[1,2,3,4,5,6]
def func(x):
    print "call with %r"%x

for x in filter(lambda x: x>3, y):
    func(x)

Depende do seu objetivo.

Se você está tentando fazer alguma operação em cada objeto em uma lista, a segunda abordagem deve ser adotada.

Se você está tentando gerar uma lista de outra lista, você pode usar a compreensão de lista.

Explícito é melhor do que implícito. Simples é melhor que complexo. (Python Zen)

Você pode fazer

for z in (fun_with_side_effects(x) for x in y if (...conditions...)): pass

mas não é muito bonito.

Usar uma compreensão de lista para seus efeitos colaterais é feio, não Pythônico, ineficiente e eu não faria isso. Eu usaria um forloop em vez disso, porque um forloop sinaliza um estilo de procedimento no qual os efeitos colaterais são importantes.

Mas, se você absolutamente insiste em usar uma compreensão de lista para seus efeitos colaterais, deve evitar a ineficiência usando uma expressão geradora. Se você insiste absolutamente neste estilo, escolha um destes dois:

any(fun_with_side_effects(x) and False for x in y if (...conditions...))

ou:

all(fun_with_side_effects(x) or True for x in y if (...conditions...))

Essas são expressões geradoras e não geram uma lista aleatória que é descartada. Eu acho que oall forma talvez seja um pouco mais clara, embora ache que ambas são confusas e não devam ser usadas.

Eu acho isso feio e eu não faria isso em código. Mas se você insiste em implementar seus loops dessa maneira, é assim que eu faria.

Tenho a tendência de achar que as compreensões de lista e de sua laia devem sinalizar uma tentativa de usar algo que se assemelhe pelo menos um pouco a um estilo funcional. Colocar coisas com efeitos colaterais que quebrem essa suposição fará com que as pessoas tenham que ler seu código com mais cuidado, e acho isso uma coisa ruim.