Let's take this code that prints all positive integer of a list:
l = [1, -1, 1, 0, 2]
for i in l:
if i > 0:
print(i)
I can do it with a list comprehension but I guess this has the disadvantage to create a new useless list:
[print(i) for i in l if i > 0]
So my question: is there a more pythonic way to write this?
The plain for-loop is perfectly Pythonic. You want to loop over the elements of the list, select the ones that are greater than zero, and print them, and that's exactly what it does - no more, no less.
The list comprehension is not Pythonic, mostly for the reason you gave: it creates a new useless list. Even if you were going to use the list, using a list comprehension for side effects is still bad practice.
The most Pythonic way to apply a function to some subset of a list of elements is to use a for loop, just as you already have.
Within that for loop, there is an argument to be made for filtering the list before assigning any value to i; whether that constitutes an improvement is usually a matter of opinion and will depend on the context.
for i in filter(lambda x: x > 0, l):
print(i)
In this case, I think it's worse. But sometimes you have a predicate at hand, and filtering can be syntactically lighter. Compare
for i in some_list_of_strings:
if i.isdigit():
print(i)
with
for i in filter(str.isdigit, some_list_of_strings):
print(i)
I suppose that theoretically you could contrive to use a generator comprehension in order to avoid creating a large list in memory:
for _ in (print(i) for i in l if i > 0): pass
(maybe also using some function that does the consuming of values from the generator, so that any loop is hidden away inside that function).
However, not only is this less readable than the explicit for loop, the plain for loop is also quicker.
import time
l = [1, -1, 1, 0, 2]
# we don't really want lots of output for this timing test
def dont_really_print(i):
return i
t1 = time.time()
for x in range(1000000):
for i in l:
if i > 0:
dont_really_print(i)
t2 = time.time()
for x in range(1000000):
for _ in (dont_really_print(i) for i in l if i > 0):
pass
t3 = time.time()
print(f"generator comprehension {t3 - t2:.3f} "
f"explicit loop {t2 - t1:.3f}")
gives:
generator comprehension 0.629 explicit loop 0.423
Generally, whether Python or any other language, what you want to do is known as a "map."
Print is a weird function to map, so here's another function for better demonstration purposes.
def add_one(num):
return num + 1
foo = [1, 2, 3, 4]
new_list = map(add_one, foo)
print(list(new_list))
You can typically map in parallel, sometimes asynchronously, and a good number of parallel processing paradigms (including Python's multiprocessing) use map as a fundamental operation for using multiple cores to implement a function.
