Copying nested lists in Python

b = [x[:] for x in a]

Whis b = a[:] doesn't work for nested list(or say muti-dimension list)?

a = [[1, 2],[3, 4]]
b = a[:]

Answer: Though when we are copying the list a using slicing[:] operation but the inner sub-list still refers to the inner-sub list of list b

Note: We can check the reference using id() in python.
Let's understand using an example.

>>> a = [[1,2],[3,4]]
>>> id(a)
140191407209856    # unique id of a
>>> b=a
>>> id(b)
140191407209856
>>> b=a[:]        # Copying list a to b with slicing
>>> id(b)         
140191407209920   # id of list b changed & is not same as id of list a
>>> id(a[0])      
140191407188544
>>> id(b[0])
140191407188544
>>> id(a[0])==id(b[0])  # id of both a[0] & b[1] is same.
True

So, slicing won't change the reference for objects inside the list. You can notice from above that reference of a[0] is the same as b[0].
When you copy a 2D list to another, it adds a reference to it not the actual list.

Instead you can use:

• b = copy.deepcopy(a)
• b = [item[:] for item in a]
• b = [item.copy() for item in a]
• b = [list(item) for item in a]
• b = [copy.copy(item) for item in a]
• b = []; b.extens[a]

Below is the comparison of the time complexity of all available copy methods (source)

1. 10.59 sec (105.9us/itn) - copy.deepcopy(old_list)

2. 10.16 sec (101.6us/itn) - pure python Copy() method copying classes with deepcopy

3. 1.488 sec (14.88us/itn) - pure python Copy() method not copying classes (only dicts/lists/tuples)

4. 0.325 sec (3.25us/itn) - for item in old_list: new_list.append(item)

5. 0.217 sec (2.17us/itn) - [i for i in old_list] (a list comprehension)

6. 0.186 sec (1.86us/itn) - copy.copy(old_list)

7. 0.075 sec (0.75us/itn) - list(old_list)

8. 0.053 sec (0.53us/itn) - new_list = []; new_list.extend(old_list)

9. 0.039 sec (0.39us/itn) - old_list[:] (list slicing)

You can use the following for two-dimensional nested arrays: b = [[y for y in x] for x in a]

It is not working because when you do cloning or copy it will create shallow copy. So what is shallow copy and deep copy?

Consider, a is list , a = [1,2,3] now when you create new name b= a[:] or b = a.copy(). (Both will give same result. ) . You need to understand what happens at memory level. When we create copy, address reference for list a & b will be changed as in python everything is pass by reference. However, address of the items in the list will remain the same. Please see below snippet.

[Creating list and printing id's of element] 1

Now, we will create a copy and print id of elements inside copied object.

You can see after creating copy, id's of objects inside list has not changed.

However, id's of both the lists will be different as below:

[Id's are different] 3

This is called shallow copy , in which address of objects inside mutable data type will not changed. So, if you pass mutable data type inside of another mutable data type(which is nothing but 2D list) then address will be the same of inside mutable data type. Hence, change done by using name a, will also be reflected in b. Please see below code snippet.

[2-D list overview.] 4

If your requirement is there should not be any change then you can use deepcopy as below code snipped.

[Deep Copy] 5