3

I have a question that I haven't quite found a good solution to. I'm looking for a better way to append function output to two or more lists, without using temp variables. Example below:

def f():
  return 5,6

a,b = [], []
for i in range(10):
  tmp_a, tmp_b = f()
  a.append(tmp_a)
  b.append(temp_b)

I've tried playing around with something like zip(*f()), but haven't quite found a solution that way. Any way to remove those temp vars would be super helpful though, thanks!

Edit for additional info: In this situation, the number of outputs from the function will always equal the number of lists that are being appended to. The main reason I'm looking to get rid of temps is for the case where there are maybe 8-10 function outputs, and having that many temp variables would get messy (though I don't really even like having two).

halolord01
  • 173
  • 1
  • 3
  • 8
  • Do you need to call the function on each iteration of the for loop, or just once? – iafisher Apr 19 '17 at 15:32
  • Will the number of lists always be equal to the number of elements in the tuple returned by the function, or, if the function only returns a single thing, would you want to append that one item to all the lists? Your question is a little vague. – martineau Apr 19 '17 at 15:39
  • 1
    If you want to write "Pythonic" code, I suggest you read and follow [PEP 8 - Style Guide for Python Code](https://www.python.org/dev/peps/pep-0008/), which, among many other things, suggests indenting your with 4 spaces. – martineau Apr 19 '17 at 15:40
  • You say you want to do it without using temp variables. My question would be: why? Is there something inherently wrong with temp variables in general, or the solution in your example? – ilkkachu Apr 19 '17 at 15:44

4 Answers4

7
def f():
    return 5,6

a,b = zip(*[f() for i in range(10)])
# this will create two tuples of elements 5 and 6 you can change 
# them to list by type casting it like list(a), list(b)
Anand Tripathi
  • 14,556
  • 1
  • 47
  • 52
5

First solution: we make a list of all results, then transpose it

def f(i):
    return i, 2*i

# First make a list of all your results
l = [f(i) for i in range(5)]
# [(0, 0), (1, 2), (2, 4), (3, 6), (4, 8)]

# then transpose it using zip
a, b = zip(*l)

print(list(a))
print(list(b))
# [0, 1, 2, 3, 4]
# [0, 2, 4, 6, 8]

Or, all in one line:

a, b = zip(*[f(i) for i in range(5)])

A different solution, building the lists at each iteration, so that you can use them while they're being built:

def f(i):
    return 2*i, i**2, i**3

doubles = []
squares = []
cubes = []
results = [doubles, squares, cubes]

for i in range(1, 4):
    list(map(lambda res, val: res.append(val), results, f(i)))
    print(results)

# [[2], [1], [1]]
# [[2, 4], [1, 4], [1, 8]]
# [[2, 4, 6], [1, 4, 9], [1, 8, 27]]

print(cubes)
# [1, 8, 27]

Note about list(map(...)): in Python3, map returns a generator, so we must use it if we want the lambda to be executed.list does it.

Thierry Lathuille
  • 23,663
  • 10
  • 44
  • 50
3

For your specific case, the zip answers are great.

Using itertools.cycle and itertools.chain is a different approach from the existing answers that might come in handy if you have a lot of pre-existing lists that you want to append to in a round-robin fashion. It also works when your function returns more values than you have lists.

>>> from itertools import cycle, chain
>>> a, b = [], [] # new, empty lists only for demo purposes
>>> for l, v in zip(cycle([a, b]), (chain(*(f() for i in range(10))))):
...     l.append(v)
... 
>>> a
[5, 5, 5, 5, 5, 5, 5, 5, 5, 5]
>>> b
[6, 6, 6, 6, 6, 6, 6, 6, 6, 6]
timgeb
  • 76,762
  • 20
  • 123
  • 145
2

I'd do

tmp = f()
a.append(tmp[0])
b.append(tmp[1])

Not sure how pythonic it is for you though.

098799
  • 462
  • 1
  • 4
  • 17