Overview

Understanding the difference between shallow and deep copy is crucial in Python, as it affects how objects are duplicated and thus can impact the behavior of your programs. This concept is particularly important when working with mutable objects, such as lists or dictionaries, to avoid unintended side effects.

Key Concepts

1. Mutable vs Immutable Types: Understanding which objects can be changed in place and which cannot.
2. Shallow Copy: Creates a new object but does not create copies of nested objects.
3. Deep Copy: Creates a new object and recursively copies all nested objects.

Common Interview Questions

Basic Level

1. What is the difference between shallow and deep copy in Python?
2. How do you create a shallow copy of a list in Python?

Intermediate Level

3. How does deepcopy work with objects containing circular references?

Advanced Level

4. How can you implement a custom deep copy mechanism for a complex class?

Detailed Answers

1. What is the difference between shallow and deep copy in Python?

Answer: In Python, a shallow copy creates a new object but does not create copies of the objects contained within the original object. It only copies the references to those inner objects. On the other hand, a deep copy creates a new object and recursively copies all objects contained within the original object, creating duplicates of the nested objects.

Key Points:
- Shallow copy is faster and uses less memory but can lead to issues with nested mutable objects.
- Deep copy is slower and uses more memory but is safer for nested mutable objects.
- The copy module in Python provides the copy() function for shallow copying and the deepcopy() function for deep copying.

Example:

import copy

# Original list with nested list
original_list = [[1, 2, 3], [4, 5, 6]]

# Shallow copy
shallow_copied_list = copy.copy(original_list)
shallow_copied_list[0][0] = 'changed'

# Deep copy
deep_copied_list = copy.deepcopy(original_list)
deep_copied_list[1][1] = 'changed'

print(original_list)  # Output shows that the shallow copy affected the original list
print(shallow_copied_list)
print(deep_copied_list)

2. How do you create a shallow copy of a list in Python?

Answer: A shallow copy of a list in Python can be created using several methods, including the list constructor, the copy() method of a list, and slicing.

Key Points:
- These methods copy the list's elements but not the objects referenced by the elements.
- Any modification to mutable objects in the copied list will reflect in the original list.
- For immutable objects, changes will not affect the original list.

Example:

# Original list
original_list = [1, 2, 3, [4, 5, 6]]

# Using the list constructor
copied_list_constructor = list(original_list)

# Using the copy() method
copied_list_method = original_list.copy()

# Using slicing
copied_list_slicing = original_list[:]

# Modifying a nested list element
original_list[3][0] = 'changed'

print(original_list)  # Shows that the nested list was modified in all copies
print(copied_list_constructor)
print(copied_list_method)
print(copied_list_slicing)

3. How does deepcopy work with objects containing circular references?

Answer: Python's deepcopy() function from the copy module is designed to handle circular references gracefully. When deepcopy() encounters an object it has already copied, it uses a reference to the new copied object instead of continuing to copy the object again, thus preventing infinite recursion and stack overflow errors.

Key Points:
- deepcopy() maintains a memo dictionary of already copied objects to handle circular references.
- This mechanism ensures that the deep copy process is safe even for complex object graphs with circular references.
- Circular references are common in data structures like graphs and linked lists.

Example:

import copy

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None

# Creating a circular linked list
node1 = Node(1)
node2 = Node(2)
node1.next = node2
node2.next = node1  # Circular reference

# Deep copying the circular linked list
copied_node1 = copy.deepcopy(node1)

print(copied_node1 is node1)  # False, deep copy creates a new object
print(copied_node1.next is node2)  # False, deep copy also duplicates the linked node
print(copied_node1.next.next is copied_node1)  # True, maintaining the circular reference

4. How can you implement a custom deep copy mechanism for a complex class?

Answer: For complex classes, especially those with resources that deepcopy() cannot automatically handle (like file handles, database connections, or sockets), you can customize the deep copy behavior by overriding the __deepcopy__() method in your class.

Key Points:
- The __deepcopy__() method should return a new instance of the class that is a deep copy of the original instance.
- You can control exactly how and what attributes are copied, providing flexibility for complex cases.
- This method receives a memo dictionary argument which can be used to avoid duplicating objects with circular references.

Example:

import copy

class ComplexClass:
    def __init__(self, items):
        self.items = items
        # Assume 'items' is a list of objects that also need deep copying.

    def __deepcopy__(self, memo={}):
        # Creating a new instance without calling the __init__ method
        new_instance = self.__class__.__new__(self.__class__)
        memo[id(self)] = new_instance
        for k, v in self.__dict__.items():
            setattr(new_instance, k, copy.deepcopy(v, memo))
        return new_instance

# Creating an instance of ComplexClass
original = ComplexClass([1, 2, [3, 4]])

# Deep copying the instance
copied = copy.deepcopy(original)

print(original.items)  # Original items
print(copied.items)  # Copied items, showing that the deep copy was customized