Added new example: deep copy list #225
Conversation
There was a problem hiding this comment.
This isn't what shallow or deep-copying actually means, copying in any sense returns a different (new) object while assignments use references to the same object. A shallow copy just doesn't recursively copy while a deep copy does. See the following example:
inner = [1,2]
ex_list = [inner, 3, 4]
ex_list_ref = ex_list
ex_list_ref.append(5)
>>> ex_list_ref, ex_list
([[1, 2], 3, 4, 5], [[1, 2], 3, 4, 5])
# both lists were affected
shallow_copy = ex_list[:]
shallow_copy.append(8)
>>> shallow_copy
[[1, 2], 3, 4, 5, 8]
>>> ex_list
[[1, 2], 3, 4, 5]
# however, the `inner` object was not copied, meaning it will change in both
inner.append('t')
>>> shallow_copy
[[1, 2, 't'], 3, 4, 5, 8]
>>> ex_list
[[1, 2, 't'], 3, 4, 5]
# let's look at a deepcopy now
from copy import deepcopy
deep_copy = deepcopy(ex_list)
>>> deep_copy
[[1, 2, 't'], 3, 4, 5]
>>> ex_list
[[1, 2, 't'], 3, 4, 5]
inner.append('f')
>>> deep_copy # inner should not be affected
[[1, 2, 't'], 3, 4, 5]
>>> ex_list
[[1, 2, 't', 'f'], 3, 4, 5]
# only the original ex_list was affected by updating `inner` as the `inner` object in the deepcopy is copied itself and therefore uniqueWe could add something like this to clear up confusion about shallow/deep if not already mentioned somewhere but I found the explanation in the docs sufficient.
| #### 💡 Explanation: | ||
|
|
||
| In Python, we have concept of [deep copy](https://docs.python.org/3/library/copy.html) and [shallow copy](https://docs.python.org/3/library/copy.html). | ||
| In the first example, `new_list` is the original list and `new_list_copy` is the shallow copy of the original list. As a result changes made to the copied list has reflected back to the original list. |
There was a problem hiding this comment.
This isn't quite right, new_list_copy is not a copy of new_list at all. It is simply a reference to it, a simple assignment in Python never creates a copy. You can compare the two lists with is to test.
| The second example shows that `new_list_dcopy` is a deep copy of the original list `new_list`, where changes made in the deep copied list doesn't reflect back to the original list. | ||
|
|
||
| One can easily deep copy a list without using the *copy.deepcopy(new_list)* just by using `slicing` , where any changes made to the copied list won't reflect back to the original list. Trick!! |
There was a problem hiding this comment.
Actually, slicing a list using an empty slice will result in a shallow copy of the list, meaning other mutable objects in the new list are not copies of themselves.
No description provided.