update tests

Author: jorisvandenbossche

pandas/core/generic.py

@@ -7112,6 +7112,9 @@ def fillna(
                         f"{value} not a suitable type to fill into {frame_dtype}"
                     )
                 result = result.T.fillna(value=value).T
+                if inplace:
+                    self._update_inplace(result)
+                    result = self
             else:
                 for k, v in value.items():
                     if k not in result:

pandas/tests/frame/indexing/test_mask.py

@@ -45,14 +45,14 @@ def test_mask_inplace(self):
 
         rdf = df.copy()
 
-        return_value = rdf.where(cond, inplace=True)
-        assert return_value is None
+        result = rdf.where(cond, inplace=True)
+        assert result is rdf
         tm.assert_frame_equal(rdf, df.where(cond))
         tm.assert_frame_equal(rdf, df.mask(~cond))
 
         rdf = df.copy()
-        return_value = rdf.where(cond, -df, inplace=True)
-        assert return_value is None
+        result = rdf.where(cond, -df, inplace=True)
+        assert result is rdf
         tm.assert_frame_equal(rdf, df.where(cond, -df))
         tm.assert_frame_equal(rdf, df.mask(~cond, -df))
 

pandas/tests/frame/indexing/test_where.py

@@ -184,8 +184,8 @@ def _check_set(df, cond, check_dtypes=True):
             econd = cond.reindex_like(df).fillna(True).infer_objects()
             expected = dfi.mask(~econd)
 
-            return_value = dfi.where(cond, np.nan, inplace=True)
-            assert return_value is None
+            result = dfi.where(cond, np.nan, inplace=True)
+            assert result is dfi
             tm.assert_frame_equal(dfi, expected)
 
             # dtypes (and confirm upcasts)x
@@ -320,24 +320,27 @@ def test_where_ndframe_align(self):
 
     def test_where_bug(self):
         # see gh-2793
-        df = DataFrame(
+        df_orig = DataFrame(
             {"a": [1.0, 2.0, 3.0, 4.0], "b": [4.0, 3.0, 2.0, 1.0]}, dtype="float64"
         )
         expected = DataFrame(
             {"a": [np.nan, np.nan, 3.0, 4.0], "b": [4.0, 3.0, np.nan, np.nan]},
             dtype="float64",
         )
+
+        df = df_orig.copy()
         result = df.where(df > 2, np.nan)
         tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(df, df_orig)
 
-        result = df.copy()
-        return_value = result.where(result > 2, np.nan, inplace=True)
-        assert return_value is None
-        tm.assert_frame_equal(result, expected)
+        df = df_orig.copy()
+        result = df.where(df > 2, np.nan, inplace=True)
+        assert result is df
+        tm.assert_frame_equal(df, expected)
 
     def test_where_bug_mixed(self, any_signed_int_numpy_dtype):
         # see gh-2793
-        df = DataFrame(
+        df_orig = DataFrame(
             {
                 "a": np.array([1, 2, 3, 4], dtype=any_signed_int_numpy_dtype),
                 "b": np.array([4.0, 3.0, 2.0, 1.0], dtype="float64"),
@@ -348,13 +351,15 @@ def test_where_bug_mixed(self, any_signed_int_numpy_dtype):
             {"a": [-1, -1, 3, 4], "b": [4.0, 3.0, -1, -1]},
         ).astype({"a": any_signed_int_numpy_dtype, "b": "float64"})
 
+        df = df_orig.copy()
         result = df.where(df > 2, -1)
         tm.assert_frame_equal(result, expected)
+        tm.assert_frame_equal(df, df_orig)
 
-        result = df.copy()
-        return_value = result.where(result > 2, -1, inplace=True)
-        assert return_value is None
-        tm.assert_frame_equal(result, expected)
+        df = df_orig.copy()
+        result = df.where(df > 2, -1, inplace=True)
+        assert result is df
+        tm.assert_frame_equal(df, expected)
 
     def test_where_bug_transposition(self):
         # see gh-7506
@@ -461,8 +466,8 @@ def create():
         result = df.where(pd.notna(df), df.mean(), axis="columns")
         tm.assert_frame_equal(result, expected)
 
-        return_value = df.where(pd.notna(df), df.mean(), inplace=True, axis="columns")
-        assert return_value is None
+        result = df.where(pd.notna(df), df.mean(), inplace=True, axis="columns")
+        assert result is df
         tm.assert_frame_equal(df, expected)
 
         df = create().fillna(0)
@@ -489,27 +494,30 @@ def test_where_complex(self):
 
     def test_where_axis(self):
         # GH 9736
-        df = DataFrame(np.random.default_rng(2).standard_normal((2, 2)))
+        df_orig = DataFrame(np.random.default_rng(2).standard_normal((2, 2)))
         mask = DataFrame([[False, False], [False, False]])
         ser = Series([0, 1])
 
+        df = df_orig.copy()
         expected = DataFrame([[0, 0], [1, 1]], dtype="float64")
         result = df.where(mask, ser, axis="index")
         tm.assert_frame_equal(result, expected)
 
-        result = df.copy()
-        return_value = result.where(mask, ser, axis="index", inplace=True)
-        assert return_value is None
+        df = df_orig.copy()
+        result = df.where(mask, ser, axis="index", inplace=True)
+        assert result is df
         tm.assert_frame_equal(result, expected)
 
+        df = df_orig.copy()
         expected = DataFrame([[0, 1], [0, 1]], dtype="float64")
         result = df.where(mask, ser, axis="columns")
         tm.assert_frame_equal(result, expected)
 
+        df = df_orig.copy()
         result = df.copy()
-        return_value = result.where(mask, ser, axis="columns", inplace=True)
-        assert return_value is None
-        tm.assert_frame_equal(result, expected)
+        result = df.where(mask, ser, axis="columns", inplace=True)
+        assert result is df
+        tm.assert_frame_equal(df, expected)
 
     def test_where_axis_with_upcast(self):
         # Upcast needed
@@ -534,7 +542,7 @@ def test_where_axis_with_upcast(self):
 
     def test_where_axis_multiple_dtypes(self):
         # Multiple dtypes (=> multiple Blocks)
-        df = pd.concat(
+        df_orig = pd.concat(
             [
                 DataFrame(np.random.default_rng(2).standard_normal((10, 2))),
                 DataFrame(
@@ -545,64 +553,68 @@ def test_where_axis_multiple_dtypes(self):
             ignore_index=True,
             axis=1,
         )
-        mask = DataFrame(False, columns=df.columns, index=df.index)
-        s1 = Series(1, index=df.columns)
-        s2 = Series(2, index=df.index)
+        mask = DataFrame(False, columns=df_orig.columns, index=df_orig.index)
+        s1 = Series(1, index=df_orig.columns)
+        s2 = Series(2, index=df_orig.index)
 
+        df = df_orig.copy()
         result = df.where(mask, s1, axis="columns")
-        expected = DataFrame(1.0, columns=df.columns, index=df.index)
+        expected = DataFrame(1.0, columns=df_orig.columns, index=df_orig.index)
         expected[2] = expected[2].astype("int64")
         expected[3] = expected[3].astype("int64")
         tm.assert_frame_equal(result, expected)
 
-        result = df.copy()
-        return_value = result.where(mask, s1, axis="columns", inplace=True)
-        assert return_value is None
-        tm.assert_frame_equal(result, expected)
+        df = df_orig.copy()
+        result = df.where(mask, s1, axis="columns", inplace=True)
+        assert result is df
+        tm.assert_frame_equal(df, expected)
 
+        df = df_orig.copy()
         result = df.where(mask, s2, axis="index")
-        expected = DataFrame(2.0, columns=df.columns, index=df.index)
+        expected = DataFrame(2.0, columns=df_orig.columns, index=df_orig.index)
         expected[2] = expected[2].astype("int64")
         expected[3] = expected[3].astype("int64")
         tm.assert_frame_equal(result, expected)
 
-        result = df.copy()
-        return_value = result.where(mask, s2, axis="index", inplace=True)
-        assert return_value is None
-        tm.assert_frame_equal(result, expected)
+        df = df_orig.copy()
+        result = df.where(mask, s2, axis="index", inplace=True)
+        assert result is df
+        tm.assert_frame_equal(df, expected)
 
         # DataFrame vs DataFrame
-        d1 = df.copy().drop(1, axis=0)
+        d1 = df_orig.copy().drop(1, axis=0)
         # Explicit cast to avoid implicit cast when setting value to np.nan
-        expected = df.copy().astype("float")
+        expected = df_orig.copy().astype("float")
         expected.loc[1, :] = np.nan
 
+        df = df_orig.copy()
         result = df.where(mask, d1)
         tm.assert_frame_equal(result, expected)
         result = df.where(mask, d1, axis="index")
         tm.assert_frame_equal(result, expected)
-        result = df.copy()
+        df = df_orig.copy()
         with pytest.raises(TypeError, match="Invalid value"):
-            result.where(mask, d1, inplace=True)
+            df.where(mask, d1, inplace=True)
         with pytest.raises(TypeError, match="Invalid value"):
-            return_value = result.where(mask, d1, inplace=True, axis="index")
+            df.where(mask, d1, inplace=True, axis="index")
 
-        d2 = df.copy().drop(1, axis=1)
-        expected = df.copy()
+        d2 = df_orig.copy().drop(1, axis=1)
+        expected = df_orig.copy()
         expected.loc[:, 1] = np.nan
 
+        df = df_orig.copy()
         result = df.where(mask, d2)
         tm.assert_frame_equal(result, expected)
         result = df.where(mask, d2, axis="columns")
         tm.assert_frame_equal(result, expected)
-        result = df.copy()
-        return_value = result.where(mask, d2, inplace=True)
-        assert return_value is None
-        tm.assert_frame_equal(result, expected)
-        result = df.copy()
-        return_value = result.where(mask, d2, inplace=True, axis="columns")
-        assert return_value is None
-        tm.assert_frame_equal(result, expected)
+        df = df_orig.copy()
+        result = df.where(mask, d2, inplace=True)
+        assert result is df
+        tm.assert_frame_equal(df, expected)
+        df = df_orig.copy()
+        result = df.where(mask, d2, inplace=True, axis="columns")
+        assert result is df
+        tm.assert_frame_equal(df, expected)
 
     def test_where_callable(self):
         # GH 12533
@@ -1047,6 +1059,7 @@ def test_where_inplace_no_other():
     # GH#51685
     df = DataFrame({"a": [1.0, 2.0], "b": ["x", "y"]})
     cond = DataFrame({"a": [True, False], "b": [False, True]})
-    df.where(cond, inplace=True)
+    result = df.where(cond, inplace=True)
+    assert result is df
     expected = DataFrame({"a": [1, np.nan], "b": [np.nan, "y"]})
     tm.assert_frame_equal(df, expected)

pandas/tests/frame/methods/test_clip.py

@@ -24,8 +24,8 @@ def test_inplace_clip(self, float_frame):
         median = float_frame.median().median()
         frame_copy = float_frame.copy()
 
-        return_value = frame_copy.clip(upper=median, lower=median, inplace=True)
-        assert return_value is None
+        result = frame_copy.clip(upper=median, lower=median, inplace=True)
+        assert result is frame_copy
         assert not (frame_copy.values != median).any()
 
     def test_dataframe_clip(self):
@@ -68,7 +68,7 @@ def test_clip_against_series(self, inplace):
         clipped_df = df.clip(lb, ub, axis=0, inplace=inplace)
 
         if inplace:
-            clipped_df = df
+            assert clipped_df is df
 
         for i in range(2):
             lb_mask = original.iloc[:, i] <= lb
@@ -106,7 +106,7 @@ def test_clip_against_list_like(self, inplace, lower, axis, res):
 
         expected = DataFrame(res, columns=original.columns, index=original.index)
         if inplace:
-            result = original
+            assert result is original
         tm.assert_frame_equal(result, expected, check_exact=True)
 
     @pytest.mark.parametrize("axis", [0, 1, None])

pandas/tests/frame/methods/test_fillna.py

@@ -103,9 +103,9 @@ def test_fillna_different_dtype(self):
         expected[2] = expected[2].astype("object")
         tm.assert_frame_equal(result, expected)
 
-        return_value = df.fillna({2: "foo"}, inplace=True)
+        result = df.fillna({2: "foo"}, inplace=True)
+        assert result is df
         tm.assert_frame_equal(df, expected)
-        assert return_value is None
 
     def test_fillna_limit_and_value(self):
         # limit and value
@@ -423,11 +423,12 @@ def test_fillna_inplace(self):
         expected = df.fillna(value=0)
         assert expected is not df
 
-        df.fillna(value=0, inplace=True)
+        result = df.fillna(value=0, inplace=True)
+        assert result is df
         tm.assert_frame_equal(df, expected)
 
-        expected = df.fillna(value={0: 0}, inplace=True)
-        assert expected is None
+        result = df.fillna(value={0: 0}, inplace=True)
+        assert result is df
 
         df.loc[:4, 1] = np.nan
         df.loc[-4:, 3] = np.nan
@@ -470,7 +471,8 @@ def test_fillna_dict_series_axis_1(self):
             }
         )
         result = df.fillna(df.max(axis=1), axis=1)
-        df.fillna(df.max(axis=1), axis=1, inplace=True)
+        result = df.fillna(df.max(axis=1), axis=1, inplace=True)
+        assert result is df
         expected = DataFrame(
             {
                 "a": [1.0, 1.0, 2.0, 3.0, 4.0],
@@ -643,7 +645,8 @@ def test_fillna_inplace_with_columns_limit_and_value(self):
         expected = df.fillna(axis=1, value=100, limit=1)
         assert expected is not df
 
-        df.fillna(axis=1, value=100, limit=1, inplace=True)
+        result = df.fillna(axis=1, value=100, limit=1, inplace=True)
+        assert result is df
         tm.assert_frame_equal(df, expected)
 
     @pytest.mark.parametrize("val", [-1, {"x": -1, "y": -1}])
@@ -730,7 +733,8 @@ def test_fillna_nones_inplace():
         [[None, None], [None, None]],
         columns=["A", "B"],
     )
-    df.fillna(value={"A": 1, "B": 2}, inplace=True)
+    result = df.fillna(value={"A": 1, "B": 2}, inplace=True)
+    assert result is df
 
     expected = DataFrame([[1, 2], [1, 2]], columns=["A", "B"], dtype=object)
     tm.assert_frame_equal(df, expected)