Question

Can one-line loops in Python only be used to build lists? (i.e. list comprehensions), or can they use for more general computing?

For example, I am aware that list comprehensions (~single-line loop) in Python, e.g.

my_list = [ 2*i for i in range(10)]

can also be built with a multi-line loop:

my_list = []
for i in range(10):
    my_list.append(2*i)

But can we always transform general multi-line loops into one-line loops?

For example, say we have the following multi-line for loop:

my_array = np.ones(10*10)

for x in range(10):
     my_array[x,:] = 0

can we convert it into a single-line loop? More generally:

Q1. Are the two forms functionally equivalent? (i.e. they support the same set of manipulations/operations)

Q2. I think I have read before that one-line loops in Python are vectorized. Is this true? And does this mean that they can iterate faster than multi-line loops?

Answer 1

But can we we always transform general multi-line loops in Python into one-line loops?

The short answer is no.

List comprehensions are good for projections (mapping) and/or filtering.

For example, if you have code like this:

result = []
for x in seq:
    if bar(x):
        result.append(foo(x))

Then, as you point out, it can benefit from being rewritten as a list comprehension:

result = [foo(x) for f in seq if bar(x)]

However list comprehensions are generally not so good for operations that don’t fit into this projection or filtering pattern.

For example if you need to mutate the elements but don’t need the result then a list comprehension wouldn’t be suitable. The following code would be inconvenient to write as a list comprehension (assuming that both methods return None):

for x in seq:
    x.foo()    # Modify x
    x.bar()    # Modify x again

Some operations are not allowed inside a comprehension. An example is breaking out of the loop early if a condition is met:

for x in seq:
    if x.foo():
        break
    else:
        x.bar()