What is the difference between deep copy and shallow copy in Python, and how can you create each type for a nested list?

In Python, a deep copy and a shallow copy are two different ways to duplicate a list (or any mutable object) with potentially different behaviors when it comes to nested objects. Here's the difference between them and how you can create each type for a nested list:

Shallow Copy:

A shallow copy creates a new object, but it doesn't create copies of the objects within the original object. Instead, it copies references to those objects. This means that changes made to objects inside the copied list will also affect the original list and vice versa if those objects are mutable.

You can create a shallow copy using the copy module's copy() function or by using the slicing [:] notation.

Example of creating a shallow copy:

import copy

original_list = [[1, 2, 3], [4, 5, 6]]

shallow_copied_list = copy.copy(original_list)

# Now, both original_list and shallow_copied_list share the same sublists.

shallow_copied_list[0][0] = 100

print(original_list)  # Output: [[100, 2, 3], [4, 5, 6]]

Deep Copy:

A deep copy, on the other hand, creates a completely independent copy of the original object and all objects contained within it, recursively. This means changes to objects within the copied list won't affect the original list and vice versa.

You can create a deep copy using the copy module's deepcopy() function.

Example of creating a deep copy:

import copy

original_list = [[1, 2, 3], [4, 5, 6]]

deep_copied_list = copy.deepcopy(original_list)

# Modifying the deep_copied_list won't affect the original_list.

deep_copied_list[0][0] = 100

print(original_list)  # Output: [[1, 2, 3], [4, 5, 6]]

In summary, the main difference between deep copy and shallow copy lies in their behavior with nested objects. A shallow copy shares references to nested objects, while a deep copy creates completely independent copies of the entire object hierarchy, ensuring that changes in one do not affect the other. The choice between them depends on your specific use case and whether you want shared or independent copies of nested objects.