Shallow vs deep copy.
How deep do you need to go?

The three levels:

Assignment (b = a):
  → New name, same object
  → a and b are aliases
  → Modifying one modifies the other
  → id(a) == id(b)

Shallow copy (b = copy.copy(a)):
  → New outer container
  → Same inner items (references shared)
  → Modifying b's items via the container
    may affect a (if items are mutable)
  → id(a) != id(b)
  → id(a[0]) == id(b[0])  — same inner object

Deep copy (b = copy.deepcopy(a)):
  → New outer container
  → New inner items, recursively
  → Modifying b never affects a
  → id(a) != id(b)
  → id(a[0]) != id(b[0])  — different inner objects

Memory model:

  original = [[1, 2], [3, 4]]

  Assignment:
    original ──┐
               ├──→ [ [1, 2], [3, 4] ]
    assigned ──┘
    (both point to the same list object)

  Shallow copy:
    original ──→ [ A, B ]    where A = [1, 2], B = [3, 4]
    shallow  ──→ [ A, B ]    (new list, same A and B)

  Deep copy:
    original ──→ [ A, B ]
    deep     ──→ [ A', B' ]   (new list, new A' and B')

Why "shallow" vs "deep":
  Shallow goes one level — the outer container is new.
  Deep goes all the way — every nested object is new.

What gets deep-copied:
  → Lists
  → Dicts
  → Sets
  → Custom objects (via __deepcopy__ or __dict__)
  → Tuples (if they contain mutable items)
  → Everything, recursively

What doesn't:
  → Immutable objects (int, str, tuple of immutables)
    — deepcopy returns the same object
  → Modules, functions, classes
    — deepcopy has no concept of "copy a module"
  → File handles, sockets, locks
    — deepcopy raises TypeError

For a flat list of ints or strings:
  shallow copy is enough.
  deep copy works but is slower.
  Use shallow.

For a nested list, or a list of dicts, or
a dict of lists:
  shallow copy is usually NOT enough.
  Use deepcopy.

The rule:
  If your structure has any mutable container
  inside another container, you probably need
  deepcopy.
  If everything is immutable (ints, strings,
  tuples of immutables), shallow copy is safe.

The four bugs:

Bug 1: Not copying at all
  original = [1, 2, 3]
  copy = original    # same object
  copy.append(4)     # modifies both

  Fix: list(original), original[:], or original.copy()

Bug 2: Shallow copy of nested list
  original = [[1, 2], [3, 4]]
  copy = list(original)   # new outer, same inner
  copy[0].append(99)      # modifies original[0]

  Fix: copy.deepcopy(original)

Bug 3: Shallow copy of dict with list values
  original = {'a': [1, 2]}
  copy = dict(original)   # new dict, same list value
  copy['a'].append(99)    # modifies original['a']

  Fix: copy.deepcopy(original)

Bug 4: Shallow copy of list of dicts
  original = [{'name': 'Alice'}]
  copy = list(original)   # new outer, same dict
  copy[0]['name'] = 'X'   # modifies original[0]

  Fix: copy.deepcopy(original)

The pattern:

  All four bugs are variations of the same mistake:
  a mutable object is shared between the original
  and the "copy."

  Rule:
    If your structure contains any mutable object
    at any depth, use deepcopy.
    If everything is immutable, shallow copy is safe.

When shallow is enough:

  ✅ List of ints: [1, 2, 3]
  ✅ List of strings: ['a', 'b', 'c']
  ✅ List of tuples of immutables: [(1, 2), (3, 4)]
  ✅ Dict with string values: {'a': 'x', 'b': 'y'}
  ✅ Dict with int values: {'a': 1, 'b': 2}
  ✅ Set of strings: {'a', 'b'}

  These are safe because:
    - The items are immutable
    - You can't mutate them through the copy
    - The only mutations are to the outer container
    - Shallow copy gives you a new outer container

When shallow is NOT enough:

  ❌ List of lists: [[1, 2], [3, 4]]
  ❌ List of dicts: [{'a': 1}, {'b': 2}]
  ❌ Dict of lists: {'a': [1, 2]}
  ❌ Dict of dicts: {'a': {'x': 1}}
  ❌ List of custom objects with mutable attrs
  ❌ Any nested mutable structure

The deepcopy cost:

  deepcopy is slower than shallow.
  It recurses through everything.
  For a list of 1000 ints: shallow is microseconds,
  deepcopy is milliseconds.
  For deeply nested data: deepcopy can be much
  slower.

  Optimization: shallow copy when you can.
  Use deepcopy only when the structure requires it.
  If you're copying the same structure many times,
  consider whether you need copies at all — often
  a functional approach (don't mutate) is better.

The functional alternative:

  Instead of copying-then-mutating:
    copy = deepcopy(original)
    copy[0].append(99)
  
  Build a new structure:
    new = [row + [99] if i == 0 else row
           for i, row in enumerate(original)]
  
  This creates a new structure without modifying
  the original. No deepcopy needed. The downside:
  more code for complex transformations.

  For simple cases (adding to one inner list),
  deepcopy is clearer. For complex transformations,
  the comprehension is better. Choose based on
  readability, not on avoiding deepcopy at all costs.

Built-in copy methods:

Lists:  .copy()  list()  [:]  copy.copy()
Dicts:  .copy()  dict()      copy.copy()
Sets:   .copy()  set()       copy.copy()

All create SHALLOW copies.
All are roughly equal in speed.
Choose for readability:
  lst.copy()     — clearest intent
  list(lst)      — most explicit
  lst[:]         — shortest
  copy.copy(lst) — generic

Tuples:
  Immutable, so "copy" is usually the same object.
  copy.copy(t) is t  — True
  copy.deepcopy(t)   — creates a new tuple only if
                        contents are mutable

Strings, ints, floats, booleans, None:
  Immutable. copy returns the same object.
  copy.copy(x) is x  — True

Custom classes:
  copy.copy(obj)   — shallow copy of __dict__
                     calls __copy__ if defined
  copy.deepcopy(obj) — deep copy of __dict__
                        calls __deepcopy__ if defined

Implementing __copy__ and __deepcopy__:

  class MyClass:
      def __init__(self, data):
          self.data = data
      
      def __copy__(self):
          # Return a new instance
          # Shallow: share nested objects
          return MyClass(self.data)
      
      def __deepcopy__(self, memo):
          # Return a new instance
          # Deep: recursively copy
          return MyClass(copy.deepcopy(self.data, memo))

  The memo dict is for tracking already-copied
  objects (handles circular references).
  Pass it to any deepcopy call inside __deepcopy__.

When to implement __deepcopy__:

  → Your object has resources that shouldn't be
    duplicated (file handles, sockets)
  → Your object has custom internal state that
    can't be copied by __dict__ alone
  → Your object is expensive to copy and you want
    to optimize
  → Your object has circular references that
    deepcopy needs help with

When NOT to implement:

  → Default behavior is correct (most cases)
  → You don't have nested mutable state
  → Performance isn't a concern

The default is usually fine.
Implement custom copy methods only when
you have a specific reason.

Special cases:

  ❌ File handles: deepcopy raises TypeError
     (can't copy an open file)
  
  ❌ Sockets: deepcopy raises TypeError
  
  ❌ Locks (threading.Lock): can't be deep-copied
  
  ❌ Modules: deepcopy returns the same module

  These are resource objects.
  Copying doesn't make sense — you'd get two
  handles to the same resource, with undefined
  behavior.
  
  If your object holds these, implement
  __deepcopy__ to control what gets copied.
  Or refactor to keep resources outside the
  copied structure.

The cleanest pattern:

  Keep mutable state separate from immutable
  state when possible.
  
  ❌ class Config:
         def __init__(self):
             self.file = open('config.txt')  # resource
             self.values = {}                 # state
  
  ✅ class Config:
         def __init__(self, values=None):
             self.values = values or {}
         # File opened per-operation, not stored
  
  Then deepcopy(config) works — it copies values
  (a dict, deep-copyable) and nothing else.
  
  The bug is often "I want to copy my object,"
  when the real answer is "my object shouldn't hold
  that resource."