Producing multiple items in a list comprehension

[Joel Koltner]

Is there an easy way to get a list comprehension to produce a flat list of,
say, [x,2*x] for each input argument?

E.g., I'd like to do something like:

[ [x,2*x] for x in range(4) ]

....and receive

[ 0,0,1,2,2,4,3,6]

....but of course you really get a list of lists:

[[0, 0], [1, 2], [2, 4], [3, 6]]

I'm aware I can use any of the standard "flatten" bits of code to turn this
back into what I want, but I was hoping there's some way to avoid the "lists
of lists" generation in the first place?

A slightly similar problem: If I want to "merge," say, list1=[1,2,3] with
list2=[4,5,6] to obtain [1,4,2,5,3,6], is there some clever way with "zip" to
do so?

Thanks,
---Joel

[Gerard flanagan]

Joel Koltner wrote:

Is there an easy way to get a list comprehension to produce a flat list of,
say, [x,2*x] for each input argument?

E.g., I'd like to do something like:

[ [x,2*x] for x in range(4) ]

...and receive

[ 0,0,1,2,2,4,3,6]

...but of course you really get a list of lists:

[[0, 0], [1, 2], [2, 4], [3, 6]]

I'm aware I can use any of the standard "flatten" bits of code to turn this
back into what I want, but I was hoping there's some way to avoid the "lists
of lists" generation in the first place?

A slightly similar problem: If I want to "merge," say, list1=[1,2,3] with
list2=[4,5,6] to obtain [1,4,2,5,3,6], is there some clever way with "zip" to
do so?

Thanks,
---Joel
--
http://mail.python.org/mailman/listinfo/python-list

For the first part:

def gen(n):
for i in xrange(n):
yield i
yield 2*i

print list(gen(4))

[0, 0, 1, 2, 2, 4, 3, 6]

gerard

[Peter Otten]

Joel Koltner wrote:

Is there an easy way to get a list comprehension to produce a flat list
of, say, [x,2*x] for each input argument?

E.g., I'd like to do something like:

[ [x,2*x] for x in range(4) ]

...and receive

[ 0,0,1,2,2,4,3,6]

...but of course you really get a list of lists:

[[0, 0], [1, 2], [2, 4], [3, 6]]

I'm aware I can use any of the standard "flatten" bits of code to turn
this back into what I want, but I was hoping there's some way to avoid the
"lists of lists" generation in the first place?

>>[x*y for x in range(4) for y in 1,2]

[0, 0, 1, 2, 2, 4, 3, 6]

A slightly similar problem: If I want to "merge," say, list1=[1,2,3] with
list2=[4,5,6] to obtain [1,4,2,5,3,6], is there some clever way with "zip"
to do so?

>>items = [None] * 6
items[::2] = 1,2,3
items[1::2] = 4,5,6
items

[1, 4, 2, 5, 3, 6]

Peter

[Gerard flanagan]

Joel Koltner wrote:

Is there an easy way to get a list comprehension to produce a flat list of,
say, [x,2*x] for each input argument?

E.g., I'd like to do something like:

[ [x,2*x] for x in range(4) ]

...and receive

[ 0,0,1,2,2,4,3,6]

...but of course you really get a list of lists:

[[0, 0], [1, 2], [2, 4], [3, 6]]

I'm aware I can use any of the standard "flatten" bits of code to turn this
back into what I want, but I was hoping there's some way to avoid the "lists
of lists" generation in the first place?

A slightly similar problem: If I want to "merge," say, list1=[1,2,3] with
list2=[4,5,6] to obtain [1,4,2,5,3,6], is there some clever way with "zip" to
do so?

Thanks,
---Joel
--
http://mail.python.org/mailman/listinfo/python-list

For the first part:

def gen(n):
for i in xrange(n):
yield i
yield 2*i

print list(gen(4))

[0, 0, 1, 2, 2, 4, 3, 6]

gerard

[inhahe]

"Joel Koltner" <za***************@yahoo.comwrote in message
news:5R*********************@en-nntp-05.dc1.easynews.com...

Is there an easy way to get a list comprehension to produce a flat list
of, say, [x,2*x] for each input argument?

E.g., I'd like to do something like:

[ [x,2*x] for x in range(4) ]

...and receive

[ 0,0,1,2,2,4,3,6]

...but of course you really get a list of lists:

[[0, 0], [1, 2], [2, 4], [3, 6]]

I'm aware I can use any of the standard "flatten" bits of code to turn
this back into what I want, but I was hoping there's some way to avoid the
"lists of lists" generation in the first place?

A slightly similar problem: If I want to "merge," say, list1=[1,2,3] with
list2=[4,5,6] to obtain [1,4,2,5,3,6], is there some clever way with "zip"
to do so?

Thanks,
---Joel

i figured out a solution

sum([x,2*x] for x in range(4)],[]) #not tested
sum(zip(list1,list2),()) #not tested

(you did say you knew of ways to flatten, but i dunno if you knew of that
way or not)

as an aside, i wish that sum didn't have to take the second parameter. it's
kind of superfluous. it can just use the first item as the initial value
instead of 0 when no initial value is specified. it would be a little
complex to do without putting a conditional in your main loop and slowing it
down, but it could be done.

[Ivan Illarionov]

On Thu, 22 May 2008 15:29:42 -0400, inhahe wrote:

"Joel Koltner" <za***************@yahoo.comwrote in message
news:5R*********************@en-nntp-05.dc1.easynews.com...

>Is there an easy way to get a list comprehension to produce a flat list
of, say, [x,2*x] for each input argument?

E.g., I'd like to do something like:

[ [x,2*x] for x in range(4) ]

...and receive

[ 0,0,1,2,2,4,3,6]

...but of course you really get a list of lists:

[[0, 0], [1, 2], [2, 4], [3, 6]]

I'm aware I can use any of the standard "flatten" bits of code to turn
this back into what I want, but I was hoping there's some way to avoid
the "lists of lists" generation in the first place?

A slightly similar problem: If I want to "merge," say, list1=[1,2,3]
with list2=[4,5,6] to obtain [1,4,2,5,3,6], is there some clever way
with "zip" to do so?

Thanks,
---Joel

i figured out a solution

sum([x,2*x] for x in range(4)],[]) #not tested sum(zip(list1,list2),())
#not tested

(you did say you knew of ways to flatten, but i dunno if you knew of
that way or not)

as an aside, i wish that sum didn't have to take the second parameter.
it's kind of superfluous. it can just use the first item as the initial
value instead of 0 when no initial value is specified. it would be a
little complex to do without putting a conditional in your main loop and
slowing it down, but it could be done.

If you don't want the second parameter use reduce():

>>reduce(operator.add, ([x, x*2] for x in xrange(4)))

[0, 0, 1, 2, 2, 4, 3, 6]

>>reduce(operator.add, zip([1,2,3],[4,5,6]))

(1, 4, 2, 5, 3, 6)

or:

>>reduce(lambda x, y: x.extend(y) or x, ([x, x*2] for x in xrange(4)))

[0, 0, 1, 2, 2, 4, 3, 6]

-- Ivan

[Marc Christiansen]

Joel Koltner <za***************@yahoo.comwrote:

Is there an easy way to get a list comprehension to produce a flat
list of, say, [x,2*x] for each input argument?

E.g., I'd like to do something like:

[ [x,2*x] for x in range(4) ]

...and receive

[ 0,0,1,2,2,4,3,6]

...but of course you really get a list of lists:

[[0, 0], [1, 2], [2, 4], [3, 6]]

I'm not sure I would recommend it, but try:

[v for x in range(4) for v in (x, 2 * x)]

A slightly similar problem: If I want to "merge," say, list1=[1,2,3]
with list2=[4,5,6] to obtain [1,4,2,5,3,6], is there some clever way
with "zip" to do so?

A similar solution as above should work.

Marc

[Joel Koltner]

"Peter Otten" <__*******@web.dewrote in message
news:g1*************@news.t-online.com...

>A slightly similar problem: If I want to "merge," say, list1=[1,2,3] ...

>>>items = [None] * 6
items[::2] = 1,2,3
items[1::2] = 4,5,6
items

[1, 4, 2, 5, 3, 6]

Thanks Peter, that's pretty clean -- I like it!

[Joel Koltner]

"inhahe" <in****@gmail.comwrote in message
news:5P*******************@bignews7.bellsouth.net. ..

i figured out a solution

sum([x,2*x] for x in range(4)],[]) #not tested

Nice... thanks; I probably had seen code using 'sum' to flatten but hadn't
actually understood how it worked. After playing around some it's now
clear...

(Add one more opening bracket to your solution to make the interpreter
happy -- I know you know this and it was missed only due to not actually
trying it ought)

---Joel

[Joel Koltner]

Hi Marc,

"Marc Christiansen" <us****@solar-empire.dewrote in message
news:39************@pluto.solar-empire.de...

I'm not sure I would recommend it, but try:
[v for x in range(4) for v in (x, 2 * x)]

That certainly works... and it almost seems like a bit less of a hack (if
perhaps somewhat harder to read) than the "sum" approach to flattening?

A similar solution as above should work.

This is what I came up with:

>>list1=[1,2,3]
list2=[4,5,6]
[j for (i,m) in enumerate(list1) for j in (m,list2[i])]

[1, 4, 2, 5, 3, 6]

Not exactly "clean" due to having to enumerate list1 to get the index for
list2. There may be a better method, of course -- so far I like Petter
Otten's approach.

Thanks for the help,
---Joel

[Yves Dorfsman]

Peter Otten <__*******@web.dewrote:

A slightly similar problem: If I want to "merge," say, list1=[1,2,3] with
list2=[4,5,6] to obtain [1,4,2,5,3,6], is there some clever way with "zip"
to do so?

>items = [None] * 6
items[::2] = 1,2,3
items[1::2] = 4,5,6
items

[1, 4, 2, 5, 3, 6]

My problem with this solution is that you depend on knowing how many
elements you have in each list ahead of time. Assuming that both list
are of the same length, then, I find the following more elegant:

list1=[1,2,3]
list2=[4,5,6]

reduce(lambda x, y: x+y, zip(list1, list2))

of course, zip creates tuples, so you end up with a tuple, therefore if
you need for your solution to be a list:
list(reduce(lambda x, y: x+y, zip(list1, list2)))
of
reduce(lambda x, y: x+y, list(zip(list1, list2)) )
Yves.
http://www.SollerS.ca

[Peter Otten]

Yves Dorfsman wrote:

Peter Otten <__*******@web.dewrote:

A slightly similar problem: If I want to "merge," say, list1=[1,2,3]
with list2=[4,5,6] to obtain [1,4,2,5,3,6], is there some clever way
with "zip" to do so?

>>items = [None] * 6
items[::2] = 1,2,3
items[1::2] = 4,5,6
items

[1, 4, 2, 5, 3, 6]

My problem with this solution is that you depend on knowing how many
elements you have in each list ahead of time.

$ python -m timeit -s"a = [1,2,3]*100; b = [4,5,6]*100; from operator import
add" "list(reduce(add, zip(a, b)))"
1000 loops, best of 3: 637 usec per loop

$ python -m timeit -s"a = [1,2,3]*100; b =
[4,5,6]*100" "items=[None]*(2*len(a)); items[::2] = a; items[1::2] = b"
10000 loops, best of 3: 23.4 usec per loop

The speed gain is significant. Why should I throw away useful information if
I have it? I'd even be willing to convert one arbitrary iterable to a list
to get the length information.

$ python -m timeit -s"a = [1,2,3]*100; b = [4,5,6]*100" "aa = list(a);
items=[None]*(2*len(aa)); items[::2] = aa; items[1::2] = b"
10000 loops, best of 3: 29.5 usec per loop

Assuming that both list
are of the same length, then, I find the following more elegant:

list1=[1,2,3]
list2=[4,5,6]

reduce(lambda x, y: x+y, zip(list1, list2))

of course, zip creates tuples, so you end up with a tuple, therefore if
you need for your solution to be a list:
list(reduce(lambda x, y: x+y, zip(list1, list2)))

I'd rather use a plain old for-loop:

>>from itertools import izip
a = [1,2,3]
b = [4,5,6]
items = []
for chunk in izip(a, b):

.... items.extend(chunk)
....

>>items

[1, 4, 2, 5, 3, 6]

$ python -m timeit -s"a = [1,2,3]*100; b = [4,5,6]*100; from itertools
import izip" "items = []

for chunk in izip(a, b): items.extend(chunk)"

1000 loops, best of 3: 242 usec per loop

$ python -m timeit -s"a = [1,2,3]*100; b = [4,5,6]*100; from itertools
import izip" "items = []; extend = items.extend
for chunk in izip(a, b): extend(chunk)"
10000 loops, best of 3: 70.9 usec per loop

reduce(lambda x, y: x+y, list(zip(list1, list2)) )

list(zip(...)) has no effect here. Possible fixes

>>reduce(lambda x, y: x + list(y), zip(list1, list2), [])

[1, 4, 2, 5, 3, 6]

>>reduce(lambda x, y: x.extend(y) or x, zip(list1, list2), [])

[1, 4, 2, 5, 3, 6]

$ python -m timeit -s"a = [1,2,3]*100; b = [4,5,6]*100" "reduce(lambda x, y:
x.extend(y) or x, zip(a, b), [])"
1000 loops, best of 3: 368 usec per loop

are more complicated than elegant. Not recommended.

Peter

[Yves Dorfsman]

Peter Otten <__*******@web.dewrote:

The speed gain is significant. Why should I throw away useful information if
I have it?

My thinking was that it wasn't generic enough, and I was looking for a
solution that would work for more generic problem. I agree, I shouldn't
have used the world "elegant" here, more generic would have been better.

I'd even be willing to convert one arbitrary iterable to a list
to get the length information.

$ python -m timeit -s"a = [1,2,3]*100; b = [4,5,6]*100" "aa = list(a);
items=[None]*(2*len(aa)); items[::2] = aa; items[1::2] = b"
10000 loops, best of 3: 29.5 usec per loop

Yes, I like that, it is as generic as the reduce one.

are more complicated than elegant. Not recommended.

You proved your point. Every book and webpage out there says that
functional solutions are faster than loops, that's why I tried hard not
to use a loop, and "reduce" is considered functional - I should have
timed it.
Yves.
http://www.SollerS.ca

[Paul Hankin]

On May 22, 7:21 pm, "Joel Koltner" <[e-mail]>
wrote:

Is there an easy way to get a list comprehension to produce a flat list of,
say, [x,2*x] for each input argument?

E.g., I'd like to do something like:

[ [x,2*x] for x in range(4) ]

[x * i for x in xrange(4) for i in xrange(1, 3)]

--
Paul Hankin