updated for frames to operate pointwise

Author: sharkipelago

doc/source/whatsnew/v3.0.0.rst

@@ -210,7 +210,7 @@ Other enhancements
 - :meth:`Series.map` can now accept kwargs to pass on to func (:issue:`59814`)
 - :meth:`Series.map` now accepts an ``engine`` parameter to allow execution with a third-party execution engine (:issue:`61125`)
 - :meth:`Series.rank` and :meth:`DataFrame.rank` with numpy-nullable dtypes preserve ``NA`` values and return ``UInt64`` dtype where appropriate instead of casting ``NA`` to ``NaN`` with ``float64`` dtype (:issue:`62043`)
-- :meth:`Series.round` now operates pointwise on columns of object dtype (:issue:`62174`)
+- :meth:`Series.round` and :meth:`DataFrame.round` now operate pointwise on columns of object dtype (:issue:`62174`)
 - :meth:`Series.str.get_dummies` now accepts a  ``dtype`` parameter to specify the dtype of the resulting DataFrame (:issue:`47872`)
 - :meth:`pandas.concat` will raise a ``ValueError`` when ``ignore_index=True`` and ``keys`` is not ``None`` (:issue:`59274`)
 - :py:class:`frozenset` elements in pandas objects are now natively printed (:issue:`60690`)

pandas/core/frame.py

@@ -99,10 +99,8 @@
     is_dataclass,
     is_dict_like,
     is_float,
-    is_float_dtype,
     is_hashable,
     is_integer,
-    is_integer_dtype,
     is_iterator,
     is_list_like,
     is_scalar,
@@ -11308,15 +11306,10 @@ def round(
         def _dict_round(df: DataFrame, decimals) -> Iterator[Series]:
             for col, vals in df.items():
                 try:
-                    yield _series_round(vals, decimals[col])
+                    yield vals.round(decimals[col])
                 except KeyError:
                     yield vals
 
-        def _series_round(ser: Series, decimals: int) -> Series:
-            if is_integer_dtype(ser.dtype) or is_float_dtype(ser.dtype):
-                return ser.round(decimals)
-            return ser
-
         nv.validate_round(args, kwargs)
 
         if isinstance(decimals, (dict, Series)):

pandas/core/internals/blocks.py

@@ -262,7 +262,7 @@ def make_block_same_class(
 
     @final
     def __repr__(self) -> str:
-        # don't want to print out all of the items here
+        # don't want to      out all of the items here
         name = type(self).__name__
         if self.ndim == 1:
             result = f"{name}: {len(self)} dtype: {self.dtype}"
@@ -346,7 +346,6 @@ def apply(self, func, **kwargs) -> list[Block]:
         one
         """
         result = func(self.values, **kwargs)
-
         result = maybe_coerce_values(result)
         return self._split_op_result(result)
 
@@ -1515,8 +1514,12 @@ def round(self, decimals: int) -> Self:
         """
         if self.dtype == _dtype_obj:
             round_func = functools.partial(round, ndigits=decimals)
+            mapper = functools.partial(algos.map_array, mapper=round_func)
             try:
-                values = algos.map_array(self.values, round_func)
+                if self.values.ndim == 1:
+                    values = algos.map_array(self.values, round_func)
+                else:
+                    values = np.apply_along_axis(mapper, 0, self.values)
             except TypeError as err:
                 raise TypeError("Expected numeric entries for dtype object.") from err
 

pandas/tests/frame/methods/test_round.py

@@ -223,3 +223,41 @@ def test_round_empty_not_input(self):
         result = df.round()
         tm.assert_frame_equal(df, result)
         assert df is not result
+
+    def test_round_object_columns(self):
+        # GH#62174
+        df = DataFrame(
+            {
+                "a": Series([1.1111, 2.2222, 3.3333], dtype="object"),
+                "b": Series([4.4444, 5.5555, 6.6666]),
+                "c": Series([7.7777, 8.8888, 9.9999], dtype="object"),
+            }
+        )
+        result = df.round(2)
+        expected = DataFrame(
+            {
+                "a": Series([1.11, 2.22, 3.33]),
+                "b": Series([4.44, 5.56, 6.67]),
+                "c": Series([7.78, 8.89, 10.0]),
+            }
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_round_object_columns_with_dict(self):
+        # GH#62174
+        df = DataFrame(
+            {
+                "a": Series([1.1111, 2.2222, 3.3333], dtype="object"),
+                "b": Series([4.4444, 5.5555, 6.6666]),
+                "c": Series([7.7777, 8.8888, 9.9999], dtype="object"),
+            }
+        )
+        result = df.round({"a": 1, "b": 2, "c": 3})
+        expected = DataFrame(
+            {
+                "a": Series([1.1, 2.2, 3.3]),
+                "b": Series([4.44, 5.56, 6.67]),
+                "c": Series([7.778, 8.889, 10.0]),
+            }
+        )
+        tm.assert_frame_equal(result, expected)

pandas/tests/series/methods/test_round.py

@@ -73,12 +73,16 @@ def test_round_ea_boolean(self):
         result.iloc[0] = False
         tm.assert_series_equal(ser, expected)
 
-    def test_round_dtype_object(self):
+    def test_round_numeric_dtype_object(self):
         # GH#61206, GH#62174
         ser = Series([0.232], dtype="object")
         expected = Series([0.2])
-        tm.assert_series_equal(ser.round(1), expected)
-        ser2 = Series(["bar"], dtype="object")
+        result = ser.round(1)
+        tm.assert_series_equal(result, expected)
+
+    def test_round_non_numeric_dtype_object(self):
+        # GH#62174
+        ser = Series(["bar"], dtype="object")
         msg = "Expected numeric entries for dtype object."
         with pytest.raises(TypeError, match=msg):
-            ser2.round()
+            ser.round()