ENH: Use lazy copy in infer objects

pandas/core/generic.py

@@ -6327,7 +6327,7 @@ def __deepcopy__(self: NDFrameT, memo=None) -> NDFrameT:
         return self.copy(deep=True)
 
     @final
-    def infer_objects(self: NDFrameT, copy: bool_t = True) -> NDFrameT:
+    def infer_objects(self: NDFrameT, copy: bool_t | None = None) -> NDFrameT:
         """
         Attempt to infer better dtypes for object columns.
 

pandas/core/internals/array_manager.py

@@ -371,10 +371,10 @@ def fillna(self: T, value, limit, inplace: bool, downcast) -> T:
             "fillna", value=value, limit=limit, inplace=inplace, downcast=downcast
         )
 
-    def astype(self: T, dtype, copy: bool = False, errors: str = "raise") -> T:
+    def astype(self: T, dtype, copy: bool | None = False, errors: str = "raise") -> T:
         return self.apply(astype_array_safe, dtype=dtype, copy=copy, errors=errors)
 
-    def convert(self: T, copy: bool) -> T:
+    def convert(self: T, copy: bool | None) -> T:
         def _convert(arr):
             if is_object_dtype(arr.dtype):
                 # extract PandasArray for tests that patch PandasArray._typ
@@ -386,11 +386,11 @@ def _convert(arr):
                     convert_period=True,
                     convert_interval=True,
                 )
-                if result is arr and copy:
+                if result is arr and (copy or copy is None):
                     return arr.copy()
                 return result
             else:
-                return arr.copy() if copy else arr
+                return arr.copy() if (copy or copy is None) else arr
 
         return self.apply(_convert)
 

pandas/core/internals/blocks.py

@@ -11,6 +11,7 @@
     cast,
     final,
 )
+import weakref
 
 import numpy as np
 
@@ -451,12 +452,20 @@ def convert(
         self,
         *,
         copy: bool = True,
+        using_copy_on_write: bool = False,
+        original_blocks: list[Block] = [],
     ) -> list[Block]:
         """
         attempt to coerce any object types to better types return a copy
         of the block (if copy = True) by definition we are not an ObjectBlock
         here!
         """
+        if not copy and using_copy_on_write:
+            result = self.copy(deep=False)
+            result._ref = weakref.ref(  # type: ignore[attr-defined]
+                original_blocks[self.mgr_locs.as_array[0]]
+            )
+            return [result]
         return [self.copy()] if copy else [self]
 
     # ---------------------------------------------------------------------
@@ -1963,6 +1972,8 @@ def convert(
         self,
         *,
         copy: bool = True,
+        using_copy_on_write: bool = False,
+        original_blocks: list[Block] = [],
     ) -> list[Block]:
         """
         attempt to cast any object types to better types return a copy of
@@ -1971,6 +1982,12 @@ def convert(
         if self.dtype != _dtype_obj:
             # GH#50067 this should be impossible in ObjectBlock, but until
             #  that is fixed, we short-circuit here.
+            if using_copy_on_write:
+                result = self.copy(deep=False)
+                result._ref = weakref.ref(  # type: ignore[attr-defined]
+                    original_blocks[self.mgr_locs.as_array[0]]
+                )
+                return [result]
             return [self]
 
         values = self.values
@@ -1986,10 +2003,16 @@ def convert(
             convert_period=True,
             convert_interval=True,
         )
+        ref = None
         if copy and res_values is values:
             res_values = values.copy()
+        elif res_values is values and using_copy_on_write:
+            ref = weakref.ref(original_blocks[self.mgr_locs.as_array[0]])
+
         res_values = ensure_block_shape(res_values, self.ndim)
-        return [self.make_block(res_values)]
+        result = self.make_block(res_values)
+        result._ref = ref  # type: ignore[attr-defined]
+        return [result]
 
 
 # -----------------------------------------------------------------

pandas/core/internals/managers.py

@@ -441,11 +441,27 @@ def fillna(self: T, value, limit, inplace: bool, downcast) -> T:
     def astype(self: T, dtype, copy: bool = False, errors: str = "raise") -> T:
         return self.apply("astype", dtype=dtype, copy=copy, errors=errors)
 
-    def convert(self: T, copy: bool) -> T:
-        return self.apply(
+    def convert(self: T, copy: bool | None) -> T:
+        if not copy and using_copy_on_write():
+            copy = False
+        elif copy is None:
+            copy = True
+
+        if self.is_single_block:
+            original_blocks = [self.blocks[0]] * self.shape[0]
+        else:
+            original_blocks = [self.blocks[i] for i in self.blknos]
+        mgr = self.apply(
             "convert",
             copy=copy,
+            using_copy_on_write=using_copy_on_write(),
+            original_blocks=original_blocks,
         )
+        refs = [getattr(blk, "_ref", None) for blk in mgr.blocks]
+        if any(ref is not None for ref in refs):
+            mgr.refs = refs
+            mgr.parent = self
+        return mgr
 
     def replace(self: T, to_replace, value, inplace: bool) -> T:
         inplace = validate_bool_kwarg(inplace, "inplace")

pandas/tests/copy_view/test_methods.py

@@ -439,6 +439,27 @@ def test_head_tail(method, using_copy_on_write):
     tm.assert_frame_equal(df, df_orig)
 
 
+def test_infer_objects(using_copy_on_write):
+    df = DataFrame({"a": [1, 2], "b": "c", "c": 1, "d": "x"})
+    df_orig = df.copy()
+    df2 = df.infer_objects()
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+        assert np.shares_memory(get_array(df2, "b"), get_array(df, "b"))
+
+    else:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+        assert not np.shares_memory(get_array(df2, "b"), get_array(df, "b"))
+
+    df2.iloc[0, 0] = 0
+    df2.iloc[0, 1] = "d"
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+        assert not np.shares_memory(get_array(df2, "b"), get_array(df, "b"))
+    tm.assert_frame_equal(df, df_orig)
+
+
 @pytest.mark.parametrize(
     "kwargs",
     [