Deep Copy Implementation in Python

Understanding how to create deep copies of objects is crucial for avoiding unintended side effects when modifying data structures. This challenge asks you to implement a function that performs a deep copy of a given Python object, ensuring that nested objects are also copied independently. This is particularly important when dealing with mutable objects like lists and dictionaries within lists or dictionaries.

Problem Description

You are tasked with creating a function called deep_copy that takes any Python object as input and returns a completely independent copy of that object. A deep copy means that not only is the top-level object copied, but all nested objects (lists, dictionaries, sets, tuples containing mutable objects, etc.) are also recursively copied. Modifications to the copy should not affect the original object, and vice versa.

Key Requirements:

• The function must handle various data types, including lists, dictionaries, tuples, sets, and primitive types (integers, floats, strings, booleans).
• For mutable objects (lists, dictionaries, sets), the function must create new instances of these objects and copy their contents recursively.
• For immutable objects (tuples, strings, integers, floats, booleans), the function can simply return the original object as they are inherently immutable and cannot be modified.
• The function should handle nested objects of arbitrary depth.

Expected Behavior:

The deep_copy function should return a new object that is structurally identical to the original object but contains entirely new instances of all objects within it. Changes made to the copy should not affect the original, and changes to the original should not affect the copy.

Edge Cases to Consider:

• Circular references: The function should not attempt to handle circular references (e.g., a dictionary where a key points to itself directly or indirectly). Raising a RecursionError is acceptable in this case.
• Custom objects: The function should handle custom objects by creating new instances of the class and copying their attributes recursively. Assume that the custom objects have a __dict__ attribute that can be used to access their attributes.
• None: The function should return None if the input is None.

Examples

Example 1:

Input: original_list = [1, 2, [3, 4]]
Output: copied_list = deep_copy(original_list)
Explanation: A new list is created. The integers 1 and 2 are copied by value. A new list [3, 4] is created, and the integers 3 and 4 are copied by value. Modifying copied_list[2][0] should not affect original_list[2][0].

Example 2:

Input: original_dict = {'a': 1, 'b': [2, 3], 'c': {'d': 4}}
Output: copied_dict = deep_copy(original_dict)
Explanation: A new dictionary is created. The integer 1 is copied by value. A new list [2, 3] is created, and the integers 2 and 3 are copied by value. A new dictionary {'d': 4} is created, and the integer 4 is copied by value. Modifying copied_dict['b'][0] should not affect original_dict['b'][0].

Example 3:

Input: original_tuple = (1, 2, (3, 4))
Output: copied_tuple = deep_copy(original_tuple)
Explanation: A new tuple is created. The integers 1 and 2 are copied by value. A new tuple (3, 4) is created, and the integers 3 and 4 are copied by value.  While a new tuple is created, the integers are immutable and are effectively shared.

Constraints

• The input object can be of any valid Python type.
• The function must not modify the original object.
• The function should be reasonably efficient for typical Python data structures. While extreme performance optimization is not required, avoid unnecessary overhead.
• The function should not handle circular references. A RecursionError is acceptable if a circular reference is encountered.

Notes

• The copy module's deepcopy function is not allowed. You must implement the deep copy logic yourself.
• Consider using recursion to handle nested objects.
• Think about the difference between mutable and immutable objects and how to handle them appropriately.
• The __dict__ attribute of objects can be used to access their attributes. This is particularly useful for custom objects.