Expanding on Paulo’s answer, generator expressions are often slower than list comprehensions because of the overhead of function calls. In this case, the short-circuiting behavior of in offsets that slowness if the item is found fairly early, but otherwise, the pattern holds. I ran a simple script through the profiler for a more detailed analysis. … Read more
Both work differently. The list comprehension version takes advantage of the special bytecode LIST_APPEND which calls PyList_Append directly for us. Hence it avoids an attribute lookup to list.append and a function call at the Python level. >>> def func_lc(): [x**2 for x in y] … >>> dis.dis(func_lc) 2 0 LOAD_CONST 1 (<code object <listcomp> at … Read more
Python’s generator expressions are late binding (see PEP 289 — Generator Expressions) (what the other answers call “lazy”): Early Binding versus Late Binding After much discussion, it was decided that the first (outermost) for-expression [of the generator expression] should be evaluated immediately and that the remaining expressions be evaluated when the generator is executed. […] … Read more
Note: this was a bug in the CPython’s handling of yield in comprehensions and generator expressions, fixed in Python 3.8, with a deprecation warning in Python 3.7. See the Python bug report and the What’s New entries for Python 3.7 and Python 3.8. Generator expressions, and set and dict comprehensions are compiled to (generator) function … Read more
Both 3. and 4. should be syntax errors on all Python versions. However you’ve found a bug that affects Python versions 2.5 – 3.4, and which was subsequently posted to the Python issue tracker. Because of the bug, an unparenthesized generator expression was accepted as an argument to a function if it was accompanied only … Read more
If you use any(lst) you see that lst is the iterable, which is a list of some items. If it contained [0, False, ”, 0.0, [], {}, None] (which all have boolean values of False) then any(lst) would be False. If lst also contained any of the following [-1, True, “X”, 0.00001] (all of which … Read more
John’s answer is good (that list comprehensions are better when you want to iterate over something multiple times). However, it’s also worth noting that you should use a list if you want to use any of the list methods. For example, the following code won’t work: def gen(): return (something for something in get_some_stuff()) print … Read more