multiple actions in list comprehension python

1. List comprehensions are only for generating data in list form, not for executing statements (or any other side effect, like writing to a file) multiple times. Use a for look for that.

2. Assuming you want to generate a list ['bla1', 'bla2', 'bla1', ...]: You can’t do it in general, each iteration puts a single result value into the list. That value may be a list itself, but then you have a list of lists.

3. In specific cases like your example, it’s possible though: Use ['bla' + str(i + 1) for x in list for i in range(2)], which iterates over range(2) for every x in list, and thus generates two values per item in list. (list is a bad name for a variable though, as it’s already taken by the builtin.)

If “I need two commands” means that there are two functions, they must be related in some way.

def f( element ):
    return intermediate

def g( intermediate ):
    return final

new_list = [ g(f(x)) for  x in old_list ]

If that’s not appropriate, you’ll have to provide definitions of functions which (a) cannot be composed and yet also (b) create a single result for the new sequence.

Use list comprehension only for creating lists. Your example doesn’t use the values of your list at all.

According to the docs:
“List comprehensions provide a concise way to create lists from sequences.”

for i in range(len(your_list)):
  print "blah1"
  print "blah2"

In the above program, we didn’t even care about the values in the list. If you were looking for a different application of list comprehension than what you stated in your problem, then do post.

For what it worth it is possible to use list.append in the list comprehension to produce a new list while ignoring the primary output of the list comprehension. The OP mentions a list of lists. Take for example:

>>> master = [range(x,x+2) for x in range(10)]
>>> master
[[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7], [7, 8], [8, 9], [9, 10]]

Then create a new list by manipulating each sublist (as the OP described in the edit)

>>> new_list = []
>>> [[new_list.append(l[0]*l[1]),new_list.append(l[0]+l[1])] for l in master]

[[None, None], [None, None], [None, None], [None, None], [None, None], [None, None], [None, None], [None, None], [None, None], [None, None]]

>>> new_list

[0, 1, 2, 3, 6, 5, 12, 7, 20, 9, 30, 11, 42, 13, 56, 15, 72, 17, 90, 19]   

This does spit out a redundant list of lists with Nones, but also fills the variable new_list with the product and sum of the sublists.

You can use tuple for doing that job like this:

[(print("bla1"), print("bla2")) for i in list]

it’s work correctly.

In some cases, it may be acceptable to call a function with the two statements in it.

def f():
   print("bla1")
   print("bla2")

[f() for i in l]

Can also send an argument to the function.

def f(i):
   print("bla1 %d" % i)
   print("bla2")

l = [5,6,7]

[f(i) for i in l]

Output:

bla1 5
bla2
bla1 6
bla2
bla1 7
bla2

A list comprehension, and relations ( set comprehenson, dictionary comprehension, generator expression ) are all syntax that enables expression of a loop within a single command. Pedantics who fail to recognise that fact are limiting Python needlessly, and those who preach the gospel of ‘best practice’ hobble their followers with pointless dogma. It isn’t just for sequences anymore! Execute commands all you want, if that is the cleanest solution. Not using the output of the expression ( often a list like [None, None] ) isn’t any worse than a temporary ‘variable’ going out of scope after a method / function is completed.