python - How (in)efficient is a list comprehension if you don't assign it?

Question

In this question, I'm having an argument with a commenter who argues that

for t in threads:
    t.join()

would be better than

[t.join() for t in threads]

Leaving the matter of "abusing comprehensions" aside - I tend to agree but I would like a one-liner for this: How (in-)efficient is my version (the second one) really?. Does Python materialize list comprehensions always / in my case or does it use a generator internally?

Would map(lambda t: t.join(), threads) be more efficient? Or is there another way to apply the function to each element in the list threads?

Answer 1

A list comprehension will always produce a list object, in this case with the return values of all the t.join() calls. Python thus produces as list with None values of length len(threads) for you. Python will never try to optimize away the list object creation.

Using map() is also not any more efficient as you add additional stack pushes with the lambda. Just stick with the explicit for loop.

Really, for a series of thread joins there is no point in trying to micro optimize here. You are hurting readability for a non-critical piece of code.

In other words, I entirely agree with the commenter. Do not use a list comprehension or map() just for the side effects and saving yourself having to hit ENTER and create two lines of code.

Quoting the Zen of Python:

• Readability counts.