Appending a list's elements to another list using a list comprehension

[Debajit Adhikary]

I have two lists:

a = [1, 2, 3]
b = [4, 5, 6]

What I'd like to do is append all of the elements of b at the end of
a, so that a looks like:

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

I can do this using

map(a.append, b)

How do I do this using a list comprehension?

(In general, is using a list comprehension preferable (or more
"pythonic") as opposed to using map / filter etc.?)

[Marc 'BlackJack' Rintsch]

On Wed, 17 Oct 2007 20:27:14 +0000, Debajit Adhikary wrote:

I have two lists:

a = [1, 2, 3]
b = [4, 5, 6]

What I'd like to do is append all of the elements of b at the end of
a, so that a looks like:

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

I can do this using

map(a.append, b)

This is a bad idea as it creates a useless list of `None`\s, one for each
element in `b`.

How do I do this using a list comprehension?

Not at all. The obvious solution here is ``a.extend(b)``.

(In general, is using a list comprehension preferable (or more
"pythonic") as opposed to using map / filter etc.?)

Some say yes.

Ciao,
Marc 'BlackJack' Rintsch

[Carsten Haese]

On Wed, 2007-10-17 at 20:27 +0000, Debajit Adhikary wrote:

I have two lists:

a = [1, 2, 3]
b = [4, 5, 6]

What I'd like to do is append all of the elements of b at the end of
a, so that a looks like:

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

I can do this using

map(a.append, b)

How do I do this using a list comprehension?

You don't.

(In general, is using a list comprehension preferable (or more
"pythonic") as opposed to using map / filter etc.?)

In general, a list comprehension is more Pythonic nowadays, but in your
particular case the answer is neither map nor a list comprehension, it's
this:

a += b

HTH,

--
Carsten Haese
http://informixdb.sourceforge.net

[Paul Hankin]

On Oct 17, 9:27 pm, Debajit Adhikary <[e-mail]:

I have two lists:

a = [1, 2, 3]
b = [4, 5, 6]

What I'd like to do is append all of the elements of b at the end of
a, so that a looks like:

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

I can do this using

map(a.append, b)

How do I do this using a list comprehension?

(In general, is using a list comprehension preferable (or more
"pythonic") as opposed to using map / filter etc.?)

Yes, using a list comprehension is usually more pythonic than using
map/filter. But here, the right answer is:
a.extend(b). The first thing you should always do is check the python
libraries for a function or method that does what you want. Even if
you think you know the library quite well it's still worth checking:
I've lost count of the number of times I've discovered a library
function that does exactly what I wanted.

Anyway, if extend didn't exist, the pythonic version of map(a.append,
b) would be
for x in b:
a.append(x)

Rather than
[a.append(x) for x in b]
List comprehensions and map produce a new list. That's not what you
want here: you're using the side-effect of the append method - which
modifies a. This makes using regular iteration the right idea, because
by using map or a comprehension, you're also constructing a list of
the return values of append (which is always None). You can see this
in the interpreter:

>>map(a.append, b)

[None, None, None]

>>a

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

HTH

--
Paul Hankin

[Paul Hankin]

On Oct 17, 10:03 pm, Debajit Adhikary <[e-mail]:

How does "a.extend(b)" compare with "a += b" when it comes to
performance? Does a + b create a completely new list that it assigns
back to a? If so, a.extend(b) would seem to be faster. How could I
verify things like these?

Use a += b rather than a.extend(b): I'm not sure what I was thinking.
Anyway, look at 'timeit' to see how to measure things like this, but
my advice would be not to worry and to write the most readable code -
and only optimise if your code's runnign too slowly.

To answer your question though: a += b is *not* the same as a = a + b.
The latter would create a new list and assign it to a, whereas a += b
updates a in-place.

--
Paul Hankin

[Steven D'Aprano]

On Wed, 17 Oct 2007 21:40:40 +0000, Paul Hankin wrote:

On Oct 17, 10:03 pm, Debajit Adhikary <[e-mail]:

>How does "a.extend(b)" compare with "a += b" when it comes to
performance? Does a + b create a completely new list that it assigns
back to a? If so, a.extend(b) would seem to be faster. How could I
verify things like these?

Use a += b rather than a.extend(b): I'm not sure what I was thinking.

Neither am I. Why do you say that?

Anyway, look at 'timeit' to see how to measure things like this, but my
advice would be not to worry and to write the most readable code - and
only optimise if your code's runnign too slowly.

Always good advice, but of course what a person considers "the most
readable code" changes with their experience.

To answer your question though: a += b is *not* the same as a = a + b.

It might be. It depends on what a and b are.

--
Steven

[Hrvoje Niksic]

Paul Hankin <pa*********@gmail.comwrites:

On Oct 17, 10:03 pm, Debajit Adhikary <[e-mail]:

>How does "a.extend(b)" compare with "a += b" when it comes to
performance? Does a + b create a completely new list that it assigns
back to a? If so, a.extend(b) would seem to be faster. How could I
verify things like these?

Use a += b rather than a.extend(b): I'm not sure what I was
thinking.

Why? a.extend(b) is at least as readable, and is guaranteed to extend
the same list. In general, "a += b" can fall back to the slower "a =
a + b" for sequences that don't support +=.

[Paul Hankin]

On Oct 18, 10:21 am, Hrvoje Niksic <[e-mail]:

Paul Hankin <[e-mail]:

On Oct 17, 10:03 pm, Debajit Adhikary <[e-mail]:

How does "a.extend(b)" compare with "a += b" when it comes to
performance? Does a + b create a completely new list that it assigns
back to a? If so, a.extend(b) would seem to be faster. How could I
verify things like these?

Use a += b rather than a.extend(b): I'm not sure what I was
thinking.

Why? a.extend(b) is at least as readable, and is guaranteed to extend
the same list. In general, "a += b" can fall back to the slower "a =
a + b" for sequences that don't support +=.

Not to me: I can never remember which of a.append and a.extend is
which. Falling back to a = a + b is exactly what you want. For
instance:

a = (1, 2, 3)
a += (4, 5, 6)

works, whereas:

a = (1, 2, 3)
a.extend((4, 5, 6))

doesn't. So using += makes your code more general. There's no standard
sequence type that has extend and not +=, so worrying that += is
slower isn't a concern unless you're using a user-defined class. Even
then, it's probably a mistake that should be fixed in the class rather
than requiring .extend() to be used instead of +=.

--
Paul Hankin

[Bruno Desthuilliers]

Debajit Adhikary a écrit :

I have two lists:

a = [1, 2, 3]
b = [4, 5, 6]

What I'd like to do is append all of the elements of b at the end of
a, so that a looks like:

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

I can do this using

map(a.append, b)

And what about a.extend(b) ?

How do I do this using a list comprehension?

Why would you want a list comp here ???

(In general, is using a list comprehension preferable (or more
"pythonic") as opposed to using map / filter etc.?)

Depends. Anyway, the pythonic solution here is to use the appropriate
list method !-)

[Hrvoje Niksic]

Paul Hankin <pa*********@gmail.comwrites:

Not to me: I can never remember which of a.append and a.extend is
which.

Interesting, with me it's the other way around. Maybe it's because I
used Python before extend was available.

Falling back to a = a + b is exactly what you want.

Not if you want to mutate the original object, possibly referenced
from elsewhere.

[J. Clifford Dyer]

On Thu, Oct 18, 2007 at 11:57:10AM -0000, Paul Hankin wrote regarding Re: Appending a list's elements to another list using a list comprehension:

>
Not to me: I can never remember which of a.append and a.extend is
which. Falling back to a = a + b is exactly what you want. For
instance:

a = (1, 2, 3)
a += (4, 5, 6)

works, whereas:

a = (1, 2, 3)
a.extend((4, 5, 6))

doesn't. So using += makes your code more general. There's no standard
sequence type that has extend and not +=, so worrying that += is
slower isn't a concern unless you're using a user-defined class. Even
then, it's probably a mistake that should be fixed in the class rather
than requiring .extend() to be used instead of +=.

I was going to argue that in fact += is not more general, it just covers a different set of use cases, but then I tested my hypothesis...

>>a = [1,2,3]
b = a
c = [4,5,6]
d = c
e = [7,8,9]
a.extend(e)
b

[1, 2, 3, 7, 8, 9]

>>c += e
d # I expected [4, 5, 6]

[4, 5, 6, 7, 8, 9]

>>c = c + e # But += doesn't do the same as this
c

[4, 5, 6, 7, 8, 9, 7, 8, 9]

>>d

[4, 5, 6, 7, 8, 9]

So I learned something new.

Cheers,
Cliff