I have different nested lists:
a = [[] for e in range(6)]
b = [[] for e in range(6)]
c = [[] for e in range(6)]
Given those lists have similar structure, is it possible to assign them simultaneously (in one line) ? I was thinking about something begining like this:
a, b, c = [[] for e in range(6)] ...?...
I'm using Python 3
Python has a mechanism to let multiple variables refer to the same object, with:
a = b = c = [[] for e in range(6)]
But you probably do not want that, since now a, b and c refer to the very same list. So if we append to a, then that change is also reflected in b and c.
We can however use iterable unpacking with:
a, b, c = [[[] for e in range(6)] for _ in range(3)]So here we construct a list that contains three lists, and we then unpack that list in three variables, such that each variable obtains its own sublist.
Or in general, if you have a certain expression that needs to be evaluated n times, and then assigned to n variables, you can use:
x1, x2, xn = [<expr> for _ in range(n)]Here <expr> should of course be replaced with a real expression, and variables xi with real variables.
n is not a runtime property (as we must match number of iterables/tuple members with the typed variables to unpack to), is this a plausible argument?a, b = ('a', 'b') vs a, b = ['a', 'b'], where I would see the former preferred over the latter ((string, string) 2-tuple vs variable-sized list that happens to have only two string members).You can abuse generators and tuple unpacking:
a, b, c = ([[] for e in range(6)] for _ in range(3))
Let's make sure that a, b and c don't reference the same list:
a[0].append(1)
b[0].append(2)
c[0].append(3)
print(a)
print(b)
print(c)
# [[1], [], [], [], [], []]
# [[2], [], [], [], [], []]
# [[3], [], [], [], [], []]
a, b, c = *([[] for e in range(6)] for _ in range(3)), would be tuple unpacking, but possible with a wasteful middle step (generator to tuple? or true tuple comprehension?). For the latter, I can't say.Try deepcopy :
from copy import deepcopy
a = [[] for e in range(6)]
b=deepcopy(a)
c=deepcopy(a)
Why deep copy why not copy:
Here is reason:
if you do with simple copy then if you modify original it will modify the copied nested list because its shallow copy
from copy import deepcopy
a = [[] for e in range(6)]
b=a[:]
c=a[:]
for i in a:
i.append(22)
print(a)
print(b,c)
output:
[[22], [22], [22], [22], [22], [22]]
[[22], [22], [22], [22], [22], [22]] [[22], [22], [22], [22], [22], [22]]
But with deepcopy :
from copy import deepcopy
a = [[] for e in range(6)]
b=deepcopy(a)
c=deepcopy(a)
for i in a:
i.append(22)
print(a)
print(b,c)
output:
[[22], [22], [22], [22], [22], [22]]
[[], [], [], [], [], []] [[], [], [], [], [], []]
What about copying the lists? Not very symmetrical, but it works...
a = [[] for e in range(6)]
b, c = a[:], a[:]
assert a == b and a == c and b == c
As @vaultah noted this is not a deep copy: the nested lists are shared:
a[2].append(1)
assert a == b and a == c and b == c
import copy
b, c = copy.deepcopy(a), copy.deepcopy(a)
a[2].append(1)
assert a != b and a != c and b == c
a = b = c = [[] for e in range(6)]you would leta,bandcrefer to the same list.