I’m using python 3.4.1.
For a single list a=[1,2], if I make a copy of it, b = a.copy() when I change items in b, it won’t change items in a.
However, when I define a list of lists (actually a matrix) a = [[1,2],[3,4]], when I assign b = a.copy(). What I do to list b actually affects a.
I checked their addresses, they are different.
Can anyone tell me why?
ps: What I did is b[0][0] = x, and the item in a was also changed.
Answers:
Thank you for visiting the Q&A section on Magenaut. Please note that all the answers may not help you solve the issue immediately. So please treat them as advisements. If you found the post helpful (or not), leave a comment & I’ll get back to you as soon as possible.
Method 1
From the docs for the copy module:
The difference between shallow and deep copying is only relevant for compound objects (objects that contain other objects, like lists or class instances):
- A shallow copy constructs a new compound object and then (to the extent possible) inserts references into it to the objects found in the original.
- A deep copy constructs a new compound object and then, recursively, inserts copies into it of the objects found in the original.
When you call regular copy.copy() you are performing a shallow copy. This means that in a case of a list-of-lists, you will get a new copy of the outer list, but it will contain the original inner lists as its elements. Instead you should use copy.deepcopy(), which will create a new copy of both the outer and inner lists.
The reason that you didn’t notice this with your first example of using copy([1,2]) is that the primitives like int are immutable, and thus it is impossible to change their value without creating a new instance. If the contents of the list had instead been mutable objects (like lists, or any user-defined object with mutable members), any mutation of those objects would have been seen in both copies of the list.
Method 2
Perhaps a list comprehension as such:
new_list = [x[:] for x in old_list]
…though if your matrices are deeper than one layer, list comprehension is probably less elegant than just using deepcopy.
edit – a shallow copy, as stated, will still contain references to the objects inside the list. So for example…
>>> this = [1, 2] >>> that = [33, 44] >>> stuff = [this, that] >>> other = stuff[:] >>> other [[1, 2], [33, 44]] >>> other[0][0] = False >>> stuff [[False, 2], [33, 44]] #the same problem as before >>> this [False, 2] #original list also changed >>> other = [x[:] for x in stuff] >>> other [[False, 2], [33, 44]] >>> other[0][0] = True >>> other [[True, 2], [33, 44]] >>> stuff [[False, 2], [33, 44]] #copied matrix is different >>> this [False, 2] #original was unchanged by this assignment
Method 3
It’s very simply, just do that:
b = a
Exemple:
>>> a = [1, 2, 3] >>> b = a >>> b.append(4) >>> b [1, 2, 3, 4] >>> a [1, 2, 3, 4]
All methods was sourced from stackoverflow.com or stackexchange.com, is licensed under cc by-sa 2.5, cc by-sa 3.0 and cc by-sa 4.0