ENH: EA.fillna copy=True

pandas/core/arrays/_mixins.py

@@ -293,7 +293,9 @@ def _fill_mask_inplace(
         func(self._ndarray.T, limit=limit, mask=mask.T)
 
     @doc(ExtensionArray.fillna)
-    def fillna(self, value=None, method=None, limit: int | None = None) -> Self:
+    def fillna(
+        self, value=None, method=None, limit: int | None = None, copy: bool = True
+    ) -> Self:
         value, method = validate_fillna_kwargs(
             value, method, validate_scalar_dict_value=False
         )
@@ -310,22 +312,30 @@ def fillna(self, value=None, method=None, limit: int | None = None) -> Self:
                 # TODO: check value is None
                 # (for now) when self.ndim == 2, we assume axis=0
                 func = missing.get_fill_func(method, ndim=self.ndim)
-                npvalues = self._ndarray.T.copy()
+                npvalues = self._ndarray.T
+                if copy:
+                    npvalues = npvalues.copy()
                 func(npvalues, limit=limit, mask=mask.T)
                 npvalues = npvalues.T
 
                 # TODO: PandasArray didn't used to copy, need tests for this
                 new_values = self._from_backing_data(npvalues)
             else:
                 # fill with value
-                new_values = self.copy()
+                if copy:
+                    new_values = self.copy()
+                else:
+                    new_values = self[:]
                 new_values[mask] = value
         else:
             # We validate the fill_value even if there is nothing to fill
             if value is not None:
                 self._validate_setitem_value(value)
 
-            new_values = self.copy()
+            if not copy:
+                new_values = self[:]
+            else:
+                new_values = self.copy()
         return new_values
 
     # ------------------------------------------------------------------------

pandas/core/arrays/arrow/array.py

@@ -907,6 +907,7 @@ def fillna(
         value: object | ArrayLike | None = None,
         method: FillnaOptions | None = None,
         limit: int | None = None,
+        copy: bool = True,
     ) -> Self:
         value, method = validate_fillna_kwargs(value, method)
 
@@ -915,11 +916,11 @@ def fillna(
             return self.copy()
 
         if limit is not None:
-            return super().fillna(value=value, method=method, limit=limit)
+            return super().fillna(value=value, method=method, limit=limit, copy=copy)
 
         if method is not None:
             fallback_performancewarning()
-            return super().fillna(value=value, method=method, limit=limit)
+            return super().fillna(value=value, method=method, limit=limit, copy=copy)
 
         if isinstance(value, (np.ndarray, ExtensionArray)):
             # Similar to check_value_size, but we do not mask here since we may
@@ -962,7 +963,7 @@ def convert_fill_value(value, pa_type, dtype):
             #   a kernel for duration types.
             pass
 
-        return super().fillna(value=value, method=method, limit=limit)
+        return super().fillna(value=value, method=method, limit=limit, copy=copy)
 
     def isin(self, values) -> npt.NDArray[np.bool_]:
         # short-circuit to return all False array.

pandas/core/arrays/base.py

@@ -758,6 +758,7 @@ def fillna(
         value: object | ArrayLike | None = None,
         method: FillnaOptions | None = None,
         limit: int | None = None,
+        copy: bool = True,
     ) -> Self:
         """
         Fill NA/NaN values using the specified method.
@@ -782,6 +783,12 @@ def fillna(
             maximum number of entries along the entire axis where NaNs will be
             filled.
 
+        copy : bool, default True
+            Whether to make a copy of the data before filling. If False, then
+            the original should be modified and no new memory should be allocated.
+            For ExtensionArray subclasses that cannot do this, it is at the
+            author's discretion whether to ignore "copy=False" or to raise.
+
         Returns
         -------
         ExtensionArray
@@ -802,12 +809,20 @@ def fillna(
                 npvalues = self.astype(object)
                 func(npvalues, limit=limit, mask=mask)
                 new_values = self._from_sequence(npvalues, dtype=self.dtype)
+                if not copy:
+                    self[:] = new_values
             else:
                 # fill with value
-                new_values = self.copy()
+                if not copy:
+                    new_values = self[:]
+                else:
+                    new_values = self.copy()
                 new_values[mask] = value
         else:
-            new_values = self.copy()
+            if not copy:
+                new_values = self[:]
+            else:
+                new_values = self.copy()
         return new_values
 
     def dropna(self) -> Self:

pandas/core/arrays/interval.py

@@ -886,7 +886,9 @@ def max(self, *, axis: AxisInt | None = None, skipna: bool = True) -> IntervalOr
         indexer = obj.argsort()[-1]
         return obj[indexer]
 
-    def fillna(self, value=None, method=None, limit: int | None = None) -> Self:
+    def fillna(
+        self, value=None, method=None, limit: int | None = None, copy: bool = True
+    ) -> Self:
         """
         Fill NA/NaN values using the specified method.
 
@@ -908,6 +910,11 @@ def fillna(self, value=None, method=None, limit: int | None = None) -> Self:
             be partially filled. If method is not specified, this is the
             maximum number of entries along the entire axis where NaNs will be
             filled.
+        copy : bool, default True
+            Whether to make a copy of the data before filling. If False, then
+            the original should be modified and no new memory should be allocated.
+            For ExtensionArray subclasses that cannot do this, it is at the
+            author's discretion whether to ignore "copy=False" or to raise.
 
         Returns
         -------
@@ -917,6 +924,8 @@ def fillna(self, value=None, method=None, limit: int | None = None) -> Self:
             raise TypeError("Filling by method is not supported for IntervalArray.")
         if limit is not None:
             raise TypeError("limit is not supported for IntervalArray.")
+        if copy is False:
+            raise NotImplementedError
 
         value_left, value_right = self._validate_scalar(value)
 

pandas/core/arrays/masked.py

@@ -179,7 +179,9 @@ def __getitem__(self, item: PositionalIndexer) -> Self | Any:
         return self._simple_new(self._data[item], newmask)
 
     @doc(ExtensionArray.fillna)
-    def fillna(self, value=None, method=None, limit: int | None = None) -> Self:
+    def fillna(
+        self, value=None, method=None, limit: int | None = None, copy: bool = True
+    ) -> Self:
         value, method = validate_fillna_kwargs(value, method)
 
         mask = self._mask
@@ -189,16 +191,25 @@ def fillna(self, value=None, method=None, limit: int | None = None) -> Self:
         if mask.any():
             if method is not None:
                 func = missing.get_fill_func(method, ndim=self.ndim)
-                npvalues = self._data.copy().T
-                new_mask = mask.copy().T
+                npvalues = self._data.T
+                new_mask = mask.T
+                if copy:
+                    npvalues = npvalues.copy()
+                    new_mask = new_mask.copy()
                 func(npvalues, limit=limit, mask=new_mask)
                 return self._simple_new(npvalues.T, new_mask.T)
             else:
                 # fill with value
-                new_values = self.copy()
+                if copy:
+                    new_values = self.copy()
+                else:
+                    new_values = self[:]
                 new_values[mask] = value
         else:
-            new_values = self.copy()
+            if copy:
+                new_values = self.copy()
+            else:
+                new_values = self[:]
         return new_values
 
     @classmethod

pandas/core/arrays/period.py

@@ -781,16 +781,18 @@ def searchsorted(
         m8arr = self._ndarray.view("M8[ns]")
         return m8arr.searchsorted(npvalue, side=side, sorter=sorter)
 
-    def fillna(self, value=None, method=None, limit: int | None = None) -> Self:
+    def fillna(
+        self, value=None, method=None, limit: int | None = None, copy: bool = True
+    ) -> Self:
         if method is not None:
             # view as dt64 so we get treated as timelike in core.missing,
             #  similar to dtl._period_dispatch
             dta = self.view("M8[ns]")
-            result = dta.fillna(value=value, method=method, limit=limit)
+            result = dta.fillna(value=value, method=method, limit=limit, copy=copy)
             # error: Incompatible return value type (got "Union[ExtensionArray,
             # ndarray[Any, Any]]", expected "PeriodArray")
             return result.view(self.dtype)  # type: ignore[return-value]
-        return super().fillna(value=value, method=method, limit=limit)
+        return super().fillna(value=value, method=method, limit=limit, copy=copy)
 
     # ------------------------------------------------------------------
     # Arithmetic Methods

pandas/core/arrays/sparse/array.py

@@ -722,6 +722,7 @@ def fillna(
         value=None,
         method: FillnaOptions | None = None,
         limit: int | None = None,
+        copy: bool = True,
     ) -> Self:
         """
         Fill missing values with `value`.
@@ -739,6 +740,9 @@ def fillna(
 
         limit : int, optional
 
+        copy: bool, default True
+            Ignored for SparseArray.
+
         Returns
         -------
         SparseArray

pandas/core/internals/blocks.py

@@ -1850,12 +1850,24 @@ def interpolate(
         **kwargs,
     ):
         values = self.values
+        refs = None
+        copy = not inplace
+        if using_cow:
+            if inplace and not self.refs.has_reference():
+                refs = self.refs
+            else:
+                copy = True
+
         if values.ndim == 2 and axis == 0:
             # NDArrayBackedExtensionArray.fillna assumes axis=1
-            new_values = values.T.fillna(value=fill_value, method=method, limit=limit).T
+            new_values = values.T.fillna(
+                value=fill_value, method=method, limit=limit, copy=copy
+            ).T
         else:
-            new_values = values.fillna(value=fill_value, method=method, limit=limit)
-        return self.make_block_same_class(new_values)
+            new_values = values.fillna(
+                value=fill_value, method=method, limit=limit, copy=copy
+            )
+        return self.make_block_same_class(new_values, refs=refs)
 
 
 class ExtensionBlock(libinternals.Block, EABackedBlock):
@@ -1898,7 +1910,16 @@ def fillna(
             new_values = self.values
         else:
             refs = None
-            new_values = self.values.fillna(value=value, method=None, limit=limit)
+            copy = not inplace
+            if using_cow:
+                if inplace and not self.refs.has_reference():
+                    refs = self.refs
+                else:
+                    copy = True
+
+            new_values = self.values.fillna(
+                value=value, method=None, limit=limit, copy=copy
+            )
         nb = self.make_block_same_class(new_values, refs=refs)
         return nb._maybe_downcast([nb], downcast, using_cow=using_cow)
 
@@ -2285,13 +2306,25 @@ def interpolate(
                 **kwargs,
             )
             return self.make_block_same_class(new_values, refs=refs)
-
-        elif values.ndim == 2 and axis == 0:
-            # NDArrayBackedExtensionArray.fillna assumes axis=1
-            new_values = values.T.fillna(value=fill_value, method=method, limit=limit).T
         else:
-            new_values = values.fillna(value=fill_value, method=method, limit=limit)
-        return self.make_block_same_class(new_values)
+            copy = not inplace
+            refs = None
+            if using_cow:
+                if inplace and not self.refs.has_reference():
+                    refs = self.refs
+                else:
+                    copy = True
+
+            if values.ndim == 2 and axis == 0:
+                # NDArrayBackedExtensionArray.fillna assumes axis=1
+                new_values = values.T.fillna(
+                    value=fill_value, method=method, limit=limit, copy=copy
+                ).T
+            else:
+                new_values = values.fillna(
+                    value=fill_value, method=method, limit=limit, copy=copy
+                )
+        return self.make_block_same_class(new_values, refs=refs)
 
 
 class DatetimeTZBlock(DatetimeLikeBlock):

pandas/tests/copy_view/test_interp_fillna.py

@@ -326,7 +326,11 @@ def test_fillna_inplace_ea_noop_shares_memory(
     view = df[:]
     df.fillna(100, inplace=True)
 
-    assert not np.shares_memory(get_array(df, "a"), get_array(view, "a"))
+    if isinstance(df["a"].dtype, ArrowDtype) or using_copy_on_write:
+        assert not np.shares_memory(get_array(df, "a"), get_array(view, "a"))
+    else:
+        # MaskedArray can actually respect inplace=True
+        assert np.shares_memory(get_array(df, "a"), get_array(view, "a"))
 
     if using_copy_on_write:
         assert np.shares_memory(get_array(df, "b"), get_array(view, "b"))
@@ -336,6 +340,11 @@ def test_fillna_inplace_ea_noop_shares_memory(
         # arrow is immutable, so no-ops do not need to copy underlying array
         assert np.shares_memory(get_array(df, "b"), get_array(view, "b"))
     else:
-        assert not np.shares_memory(get_array(df, "b"), get_array(view, "b"))
+        # MaskedArray can actually respect inplace=True
+        assert np.shares_memory(get_array(df, "b"), get_array(view, "b"))
     df.iloc[0, 1] = 100
-    tm.assert_frame_equal(df_orig, view)
+    if isinstance(df["a"].dtype, ArrowDtype) or using_copy_on_write:
+        tm.assert_frame_equal(df_orig, view)
+    else:
+        # we actually have a view
+        tm.assert_frame_equal(df, view)