Python Shallow Copy Dict: How It Works and When to Use It

In Python, a shallow copy of a dictionary creates a new dictionary object but does not recursively copy the values. The new dict shares references to the same objects as the original. This behavior is often surprising when the values are mutable, like lists or other dicts. Understanding python shallow copy dict semantics is essential for avoiding subtle bugs when passing dictionaries around in your code.

What a Shallow Copy Actually Does

A shallow copy duplicates the top-level dictionary structure: the new dict has the same keys and values as the original, but the values themselves are not duplicated. Instead, both dictionaries point to the same objects in memory. For immutable values like integers, strings, or tuples, this distinction is invisible because those objects cannot be modified in place. For mutable values, however, the shared reference means that mutating the value through one dictionary affects the other.

Consider this example:

original = {"items": [1, 2, 3]}
shallow = original.copy()

shallow["items"].append(4)
print(original["items"])  # [1, 2, 3, 4]

The append operation modifies the same list object that both dictionaries reference. The dictionary itself was copied, but its values were not.

Using dict.copy() for a Shallow Copy

The most direct way to create a shallow copy of a dictionary is the copy() method. It returns a new dict with the same key-value pairs. This method is available on all dict instances and is the standard approach for simple shallow copies.

config = {"host": "localhost", "port": 8080}
config_copy = config.copy()
config_copy["port"] = 9090

print(config["port"])       # 8080
print(config_copy["port"]) # 9090

Changing a top-level key in the copy does not affect the original because the copy has its own key-value mapping. The copy() method is sufficient when all values are immutable or when you only need to reassign top-level keys.

The copy Module: copy.copy() vs copy.deepcopy()

Python's copy module provides two functions: copy.copy() and copy.deepcopy(). The former performs a shallow copy, similar to dict.copy(), but it works on any object, not just dicts. The latter recursively copies all nested objects, creating fully independent copies.

import copy

original = {"data": [1, 2, {"nested": True}]}
shallow = copy.copy(original)
deep = copy.deepcopy(original)

shallow["data"][2]["nested"] = False
print(original["data"][2]["nested"])  # False (shared)

deep["data"][2]["nested"] = True
print(original["data"][2]["nested"])  # False (independent)

copy.copy() is functionally equivalent to dict.copy() for dictionaries, but it is more general. copy.deepcopy() is the only way to get a truly independent copy when the dictionary contains nested mutable objects.

How Nested Values Behave in a Shallow Copy

The key distinction is how nested structures are handled. A shallow copy shares references to the values at the top level. If a value is itself a list, set, or dict, the copy and the original both point to that same object. This means that in-place modifications to the nested object are visible from both dictionaries.

a = {"nested": {"count": 1}}
b = a.copy()
b["nested"]["count"] += 1

print(a["nested"]["count"])  # 2

This behavior is often the source of bugs when developers assume that copying a dictionary also copies its contents. The shallow copy only protects the top-level structure, not the nested data.

Performance and Memory Implications

Shallow copying a dictionary is generally fast and memory-efficient because it only allocates space for the new dict and copies the references to the values. The time complexity is O(n), where n is the number of keys. Deep copying, by contrast, traverses the entire object graph and can be significantly slower and more memory-intensive, especially if the dictionary contains large nested structures or cyclic references.

In practice, you should prefer a shallow copy when you only need to modify the top-level keys or when the values are immutable. Use a deep copy only when you need to modify nested values without affecting the original. The performance difference can be substantial for large dictionaries, so it's worth choosing the right tool for the job.

When to Use a Shallow Copy vs a Deep Copy

A common pattern is to use a shallow copy when you want to pass a dictionary to a function that might reassign keys but should not mutate nested structures. If you need to ensure complete isolation, copy.deepcopy() is the safer choice, but it comes with a runtime cost.

Common Pitfalls with Shallow Copies

One frequent mistake is assuming that dict.copy() creates an independent copy of nested data. This leads to unexpected behavior when the original or the copy is modified later. Another pitfall is using a shallow copy when you actually need a deep copy, especially when working with configuration dictionaries that contain nested settings.

Another subtle issue arises with the copy module when the dictionary contains custom objects. copy.copy() will not invoke the __deepcopy__ method, and copy.deepcopy() may not work correctly if objects have non-copyable resources. Always test the behavior with your specific data structures.

Finally, remember that a shallow copy does not protect against modifications to mutable values that are shared. If you need to guarantee that the original dictionary remains unchanged, you must use a deep copy or manually copy the mutable values yourself.