Using Copy Module

Python
import copy

# Shallow copy: new outer object, but nested objects are shared references
shallow = copy.copy(original)

# Deep copy: new outer object AND recursively copies all nested objects
deep = copy.deepcopy(original)

1. Identify the problem: Are you seeing unexpected mutations propagate between two variables that should be independent? This is an aliasing bug — assignment (b = a) does not copy, it just binds a new name to the same object.

2. Decide copy depth needed:

   • Flat structure (no nested mutables) → copy.copy() is sufficient and cheaper.
   • Nested structures (list of lists, dict of objects, etc.) → use copy.deepcopy().

3. Check for built-in shortcuts first (often faster/clearer than importing copy):

   • list(original) or original[:] for shallow list copy
   • dict(original) for shallow dict copy
   • original.copy() — most built-in containers have this method

4. For custom classes, decide if default behavior is enough:

   • Default copy.copy()/copy.deepcopy() copies the __dict__ (shallow/deep respectively).
   • Override __copy__(self) and/or __deepcopy__(self, memo) when the class manages external resources (file handles, locks, sockets) that shouldn't be blindly duplicated.

5. Handle circular references: deepcopy automatically tracks already-copied objects via the memo dict to avoid infinite recursion — no extra work needed unless implementing __deepcopy__ yourself, in which case pass memo through to recursive copy.deepcopy(x, memo) calls.

6. Test the copy: mutate the original after copying and confirm the copy is unaffected (for deepcopy) or that only top-level independence holds (for shallow copy).

Example 1: Shallow copy pitfall Input:

Python
import copy
original = [[1, 2], [3, 4]]
shallow = copy.copy(original)
shallow[0].append(99)
print(original)

Output:

Python
[[1, 2, 99], [3, 4]]  # inner list mutated because it's shared by reference

Example 2: Deep copy fixes it Input:

Python
import copy
original = [[1, 2], [3, 4]]
deep = copy.deepcopy(original)
deep[0].append(99)
print(original)

Output:

Python
[[1, 2], [3, 4]]  # unaffected, inner lists were fully duplicated

Example 3: Custom __deepcopy__ Input:

Python
import copy

class Connection:
    def __init__(self, socket):
        self.socket = socket  # unpicklable/unshareable resource

    def __deepcopy__(self, memo):
        # Don't duplicate the actual socket; share the reference
        new = Connection.__new__(Connection)
        memo[id(self)] = new
        new.socket = self.socket
        return new

conn2 = copy.deepcopy(conn1)

Output:

Python
# conn2 is a new Connection object, but conn2.socket is conn1.socket (same object)