Shallow Copy and Deep Copy in Python
Shallow Copy and Deep Copy in Python
In this section, we will learn about the Shallow Copy and Deep Copy in the Python program. But before going through the topic, we need to understand how the copy works in Python.
Like other programming languages, the assignment operator (=) in Python is used to copy or assign one variable to another. When we use the assignment (=) symbol to assign values, the assignment operator does not copy the actual values of the first variable. Instead, it passes the reference address of the original variable or object assigned by another variable in the program. Therefore we can say it does not create a new data copy for a new object/variable; instead, they provide the same address for copying elements that are referenced by old variables or objects.
Let’s create a program to copy or assign the first variable’s value to another variable in Python.
Copy.py
first_var = "Welcome to the JavaTpoint."
sec_var = first_var # assign the first_var to the sec_var for referencing the address.
print(" ID/ Address of the first variable is: ", id(first_var) )
print(" The value of the first variable: " + first_var)
print(" ID/ Referencing address of the second variable is: ", id(sec_var) ) # print the referencing address of the first variable
print(" The value of the Second variable: " + sec_var)
Output
ID/ Address of the first variable is: 1970811644864 The value of the first variable: Welcome to the JavaTpoint. ID/ Referencing address of the second variable is: 1970811644864 The value of the Second variable: Welcome to the JavaTpoint.
In the above example, the same string or Id is referenced by the Second variables. Therefore, we can say that an assignment operator (=) does not create a separate copy for a new variable. Instead, it passes the reference address of the old variable to get the same value in programming.
Copy Module
Python Copy Module is an inbuilt function that keeps the original values unchanged and performs modification only in copied variables or vice versa. We can perform the copy operation in the following ways:
- Deep Copy
- Shallow Copy
The Copy Module is used in Shallow Copy and Deep Copy operations of Python. Let’s understand these topics with an example.
What is the Python Deep Copy?
Python Deep Copy is a recursive process for copying the items of the object. It is used to create a copy for a new object that stores or copies references of old objects or variables to access original values. In other words, it creates a separate copy for the new object that recursively adds the copies of items or values presented in the original list. If we made any changes to the copy object, it does not reflect any change in the original objects.
Syntax
copy.deepcopy(x)
A deepcopy(x) function available in the copy module to perform the copy operation. To use the deepcopy() function, we need to import the copy module in the Python program. A deepcopy() function contains an x parameter that holds the reference of the original object.
Let’s create a program to demonstrate the deepcopy() function in Python.
Copydeep.py
# import the copy module to use the deepcopy() function
import copy
# initialize the elements of List1
lt1 = [4, 5, [1, 7], 8]
# Use deepcopy() function to perform the Deep Copy
lt2 = copy.deepcopy (lt1) # pass the reference of the List1 in deepcopy() function
# Display the original elements of the list 1
print (" Display the original list before using the Deep Copying ")
for i in range (0, len(lt1)):
print (lt1 [i], end = " ")
print( "\r")
# Display the copied elements in List2
print ("Display the copied elements in List2", lt2)
# Update the List2 index at lt2[2][0] position
lt2[2] [0] = 7
# Display the changes into the list lt2
print (" Display the modification in copied list (lt2) ")
for i in range(0, len (lt1)):
print (lt2 [i], end = " ")
# ir does not affect the original list
print ("\n Display the original list (lt1) after modification in List2 ")
for i in range (0, len(lt1)):
print (lt1[i], end = " ")
Output
Display the original List before using the Deep Copying 4 5 [1, 7] 8 Display the copied elements in List2 [4, 5, [1, 7], 8] Display the modification in copied list (lt2) 4 5 [7, 7] 8 Display the original list (lt1) after modification in List2 4 5 [1, 7] 8
In the above program, we use the deepcopy() function to create a separate copy of the original list/ object as lt2. If we made any changes to the copied object (lt2), it does not reflect any modification to the original object (lt1).
Update the nested object using the deepcopy() function
Deepcopy2.py
import copy
lt1 = [ [5, 5, 5 ], [4, 4, 4], [10, 10, 10] ]
# use deepcopy() function to pass the reference of the lt1 object.
new_lt = copy.deepcopy(lt1)
# display the original elements of the list 1
print (" Display the original list before performing the Deep Copying ")
for i in range (0, len(lt1)):
print (lt1 [i], end = " ")
print( "\r")
print(" Display the copied elements of the New List", new_lt)
lt1[0][2] = 'AA' # pass the modifying parameter at the location [0][2]
print("Display the updated old list (lt1)", lt1) # print the updated old list
print("Display the copied list (new_lt)", new_lt) # print the new list
Output
Display the original list before performing the Deep Copying [5, 5, 5] [4, 4, 4] [10, 10, 10] Display the copied elements of the New List [[5, 5, 5], [4, 4, 4], [10, 10, 10]] Display the updated old list (lt1) [[5, 5, 'AA'], [4, 4, 4], [10, 10, 10]] Display the copied list (new_lt) [[5, 5, 5], [4, 4, 4], [10, 10, 10]]
What is the Shallow Copy in Python?
A Shallow Copy is similar to the Deep Copy for creating the copy of new variables/objects. It contains the same reference address for new objects that pointing the original object’s values. It does not create a separate copy for a new object or copied object in memory. Suppose we made any changes to the copied object; it will reflect the changes on the original object’s values because both variables are pointing to the same address in the computer memory. Hence, we can say it works like the normal copy function in Python.
Syntax
copy. copy(x)
A copy() function available in the copy module, and to use the Shallow Copy operation, we need to import the copy module in the Python program. A copy() function contains an x parameter that holds the reference of the original object.
Let’s create a program to demonstrate the Shallow Copy in Python.
shallow.py
# import the copy module to use the copy() function
import copy
# initialize the list 1 elements in Python
lt1 = [4, 5, [1, 7], 8]
# Use copy() function to perform the shallow copy
lt2 = copy.copy (lt1) # pass the list 1 in copy() function
# Display the original elements of the list 1
print (" Display the original lists before performing the Shallow Copying ")
for i in range (0, len(lt1)):
print (lt1 [i], end = " ")
print("\n Display the copied elements of the list ", lt2)
# update the copied elements at position lt2[2][0]
lt2[2] [0] = 7
# Display the changes into the list lt2
print (" Display the changes in the copied list after using the Shallow Copying ")
for i in range(0, len (lt1)):
print (lt2 [i], end = " ")
# Display the changes not affected in the original list
print ("\n Display the original elements list (lt1) after changing the copied list's elements (lt2) ")
for i in range (0, len(lt1)):
print (lt1[i], end = " ")
Output
Display the original lists before performing the Shallow Copying 4 5 [1, 7] 8 Display the copied elements of the list [4, 5, [1, 7], 8] Display the changes in the copied list after using the Shallow Copying 4 5 [7, 7] 8 Display the original elements list (lt1) after changing the copied list's elements (lt2) 4 5 [7, 7] 8
In the above program, we use the copy() function to copy the new object/ list as lt2. Now lt2 stores the same content or data that the original object or list lt1 occupies. And when we perform some changes to the copied object lt2, it displays the changes in both the copied and original object of the list because both objects point to the same address in memory.
Add nested object using the copy() function
nestedCopy.py
# write a program to add [8, 8, 8] items to an old list using the Shallow Copy in Python.
import copy # import the copy module in Python
old_lt = [ [1, 1, 1], [2, 2, 2], [3, 3, 3] ]
print (" Display the old list before adding the new items in list 1", old_lt)
new_lt = copy.copy (old_lt) # use copy() function to copy the reference of the old_lt
print (" Display the copied list ", new_lt)
old_lt.append( [8, 8, 8]) # add the items into the old list
# print the old and new list after adding the items.
print ("Display the old list after adding the elements ", old_lt)
print ("Display the copied list after adding the element into the list 1", new_lt)
Output
Display the old list before adding the new items in list 1 [[1, 1, 1], [2, 2, 2], [3, 3, 3]] Display the copied list [[1, 1, 1], [2, 2, 2], [3, 3, 3]] Display the old list after adding the elements [[1, 1, 1], [2, 2, 2], [3, 3, 3], [8, 8, 8]] Display the copied list after adding the element into the list 1 [[1, 1, 1], [2, 2, 2], [3, 3, 3]]