# What is the difference between a shallow copy and a deep copy in Python?

In Python, a shallow copy creates a new object that references the original object’s elements. If the elements are mutable objects, changes made to them will be reflected in both the original and copied objects. On the other hand, a deep copy creates a new object with completely independent copies of the original object’s elements. Changes made to the elements of the deep copy will not affect the original object. The `copy` module provides functions like `copy()` and `deepcopy()` to create shallow and deep copies, respectively.

## Code Example

``````import copy

# Creating a nested list
original_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# Shallow copy
shallow_copy = original_list.copy()

# Deep copy
deep_copy = copy.deepcopy(original_list)

# Modifying the original list
original_list[0][0] = 10

# Printing the copies
print("Original List:", original_list)
print("Shallow Copy:", shallow_copy)
print("Deep Copy:", deep_copy)``````
##### Code Explanation

In this example, we start by creating a nested list called `original_list`. It consists of three inner lists.

Next, we make a shallow copy of `original_list` using the `copy()` method, and a deep copy using the `deepcopy()` function from the `copy` module.

After creating the copies, we modify the first element of the first inner list in the `original_list` by assigning it a new value of `10`.

Finally, we print the original list, the shallow copy, and the deep copy to observe the differences.

##### Output
``````Original List: [[10, 2, 3], [4, 5, 6], [7, 8, 9]]
Shallow Copy: [[10, 2, 3], [4, 5, 6], [7, 8, 9]]
Deep Copy: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]``````

Here’s the explanation of the results:

• The `original_list` has been modified, and the first element of the first inner list is now `10`.
• The shallow copy, `shallow_copy`, also reflects the change because it creates a new list, but the elements are still references to the original objects. Thus, modifying the nested object in the `original_list` affects the shallow copy as well.
• In contrast, the deep copy, `deep_copy`, creates a completely independent copy of the original list, including all the nested objects. As a result, the modification in the `original_list` does not impact the deep copy.

In summary, a shallow copy creates a new object but retains references to the original nested objects, whereas a deep copy creates a completely independent copy, including all nested objects.