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.comwr ote in message
news:5R******** *************@e n-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,l ist2),()) #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.comwr ote in message
news:5R******** *************@e n-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,l ist2),())
#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(operat or.add, ([x, x*2] for x in xrange(4)))

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

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

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

or:

>>reduce(lamb da 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.comwr ote:

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.c omwrote in message
news:5P******** ***********@big news7.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.sola r-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