gh-150815: Speed up copy.deepcopy() of containers with atomic elements

gaborbernat · gaborbernat · commit aeab6f712667 · 2026-06-02T15:44:55.000-07:00
The dict, list and tuple deep-copiers send every element back through
deepcopy(), paying a function call even for atomic immutable elements that
deepcopy() returns unchanged. Inline the atomic-type check into the three
copiers so those elements are returned as-is. Behavior is identical, including
shared references, recursion and int/tuple subclasses.
diff --git a/Lib/copy.py b/Lib/copy.py
@@ -169,17 +169,20 @@ def deepcopy(x, memo=None):
 _deepcopy_dispatch = d = {}
 
 
-def _deepcopy_list(x, memo, deepcopy=deepcopy):
+def _deepcopy_list(x, memo, deepcopy=deepcopy, _atomic=_atomic_types):
     y = []
     memo[id(x)] = y
     append = y.append
     for a in x:
-        append(deepcopy(a, memo))
+        # Inline the atomic-type check so atomic elements (int, str, None, ...)
+        # skip the deepcopy() call overhead entirely; deepcopy() would just
+        # return them unchanged after the same check.
+        append(a if type(a) in _atomic else deepcopy(a, memo))
     return y
 d[list] = _deepcopy_list
 
-def _deepcopy_tuple(x, memo, deepcopy=deepcopy):
-    y = [deepcopy(a, memo) for a in x]
+def _deepcopy_tuple(x, memo, deepcopy=deepcopy, _atomic=_atomic_types):
+    y = [a if type(a) in _atomic else deepcopy(a, memo) for a in x]
     # We're not going to put the tuple in the memo, but it's still important we
     # check for it, in case the tuple contains recursive mutable structures.
     try:
@@ -195,11 +198,15 @@ def _deepcopy_tuple(x, memo, deepcopy=deepcopy):
     return y
 d[tuple] = _deepcopy_tuple
 
-def _deepcopy_dict(x, memo, deepcopy=deepcopy):
+def _deepcopy_dict(x, memo, deepcopy=deepcopy, _atomic=_atomic_types):
     y = {}
     memo[id(x)] = y
     for key, value in x.items():
-        y[deepcopy(key, memo)] = deepcopy(value, memo)
+        # Inline the atomic-type check for keys and values: atomic objects
+        # (str keys, int/str/None values, ...) are returned as-is by
+        # deepcopy(), so skip the per-item call in that common case.
+        y[key if type(key) in _atomic else deepcopy(key, memo)] = (
+            value if type(value) in _atomic else deepcopy(value, memo))
     return y
 d[dict] = _deepcopy_dict
 
diff --git a/Misc/NEWS.d/next/Library/2026-06-02-15-44-55.gh-issue-150815.LLaYtD.rst b/Misc/NEWS.d/next/Library/2026-06-02-15-44-55.gh-issue-150815.LLaYtD.rst
@@ -0,0 +1,4 @@
+Speed up :func:`copy.deepcopy` of :class:`dict`, :class:`list` and
+:class:`tuple` containers whose elements are atomic immutable objects, by
+skipping the per-element recursive call for those elements. Patch by Bernát
+Gábor.
