One-step multiples list generation?

[Efrat Regev]

Hello,

Suppose I have some non-numerical Foo and would like to create a list
of 20 Foo-s. Is there a one-step method (not a loop) of doing so? E.g.,
something like [Foo * 20] (which is obviously not the right way) that
would create [Foo, Foo, Foo, ...,Foo].
I tried looking through the docs, FAQs and help, but couldn't find
anything (the closest is range, but it seems it's only for numerics) - I
very much appreciate your time in answering. Also, please excuse me if I
used some wrong terminology.

Thanks,

Efrat

[Damien Wyart]

* Efrat Regev <ef*********@yahoo.com> in comp.lang.python:

Suppose I have some non-numerical Foo and would like to create a list
of 20 Foo-s. Is there a one-step method (not a loop) of doing so?

Maybe :

[ Foo ] * 20

or, more verbose,

[ Foo for _ in range(20) ]

?

--
DW

[Rocco Moretti]

Damien Wyart wrote:

* Efrat Regev <ef*********@yahoo.com> in comp.lang.python:

Suppose I have some non-numerical Foo and would like to create a list
of 20 Foo-s. Is there a one-step method (not a loop) of doing so?

Maybe :

[ Foo ] * 20

or, more verbose,

[ Foo for _ in range(20) ]

If Foo is mutable, keep this in mind:

a = [ [] ]*20 # A list of 20 empty lists
print id(a[0]) == id(a[1]) True a[0].append(1)
print a [[1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1],
[1], [1], [1], [1], [1], [1]]
b = [ [] for _ in range(20) ] # A list of 20 empty lists
print id(b[0]) == id(b[1]) False b[0].append(1)
print b

[[1], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [],
[], [], []]

[Rocco Moretti]

Rocco Moretti wrote:

Damien Wyart wrote:

* Efrat Regev <ef*********@yahoo.com> in comp.lang.python:

Suppose I have some non-numerical Foo and would like to create a list
of 20 Foo-s. Is there a one-step method (not a loop) of doing so?

Maybe :

[ Foo ] * 20

or, more verbose,

[ Foo for _ in range(20) ]

If Foo is mutable, keep this in mind:

>>> a = [ [] ]*20 # A list of 20 empty lists
>>> print id(a[0]) == id(a[1]) True >>> a[0].append(1)
>>> print a [[1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1],
[1], [1], [1], [1], [1], [1]] >>>
>>> b = [ [] for _ in range(20) ] # A list of 20 empty lists
>>> print id(b[0]) == id(b[1]) False >>> b[0].append(1)
>>> print b [[1], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [],
[], [], []]

Oh, but also:

Foo = []
c = [ Foo for _ in range(20) ] # A list of 20 empty lists
print id(c[0]) == id(c[1]) True c[0].append(1)
print c

[[1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1], [1],
[1], [1], [1], [1], [1], [1]]

(The difference with the 'b' case is that a new list is created each
"time around", in the other cases, the same list is reused.

[Damien Wyart]

Thanks for these important and useful additions, they are very welcome !

In writing my answer I had immutables in mind, but mutables are a bit
more dangerous, here...

--
DW

[Efrat Regev]

Damien Wyart wrote:

* Efrat Regev <ef*********@yahoo.com> in comp.lang.python:

Suppose I have some non-numerical Foo and would like to create a list
of 20 Foo-s. Is there a one-step method (not a loop) of doing so?

Maybe :

[ Foo ] * 20

or, more verbose,

[ Foo for _ in range(20) ]

?

Great. Thanks!

[Steven D'Aprano]

On Tue, 03 Jan 2006 19:21:32 +0100, Damien Wyart wrote:

Thanks for these important and useful additions, they are very welcome !

In writing my answer I had immutables in mind, but mutables are a bit
more dangerous, here...

Mutables are easy to deal with using the copy module and list
comprehensions:

foo = []
import copy
multi_foo = [copy.copy(foo) for _ in range(10)]
multi_foo [[], [], [], [], [], [], [], [], [], []] multi_foo[5].append(None)
multi_foo

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

Or use copy.deepcopy if you need to.

--
Steven.

[Xavier Morel]

Damien Wyart wrote:

Thanks for these important and useful additions, they are very welcome !

In writing my answer I had immutables in mind, but mutables are a bit
more dangerous, here...

Not *that* much though.

The first construct can't be used, but he can use

[copy.copy(Foo) for _ in range(20)]

And he should be ok.