How (in)efficient is a list comprehension if you don't assign it?
list-comprehension, performance, python
Solution
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.
Problem
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`?