PERF: perform reductions block-wise

pandas/core/frame.py

@@ -7623,6 +7623,31 @@ def _get_data(axis_matters):
                 raise NotImplementedError(msg)
             return data
 
+        if self.size == 0:
+            pass
+
+        elif numeric_only is False:
+            res = self._data.reduce(op)
+            assert isinstance(res, dict)
+            assert len(res) == max(list(res.keys())) + 1, res.keys()
+            out = self._constructor_sliced(res, index=range(len(res)))
+            out.index = self.columns
+            return out
+
+        elif numeric_only is True and axis in [0, 1]:
+            data = _get_data(axis_matters=True)
+            if axis == 1:
+                data = data.T
+            return data._reduce(
+                op,
+                name,
+                axis=0,
+                skipna=skipna,
+                numeric_only=False,
+                filter_type=filter_type,
+                **kwds,
+            )
+
         if numeric_only is None:
             values = self.values
             try:

pandas/core/internals/managers.py

@@ -345,6 +345,37 @@ def _verify_integrity(self):
                 "tot_items: {1}".format(len(self.items), tot_items)
             )
 
+    def reduce(self, func, *args, **kwargs):
+        # If 2D, we assume that we're operating column-wise
+        if self.ndim == 1:
+            # we'll be returning a scalar
+            blk = self.blocks[0]
+            return func(blk.values, *args, **kwargs)
+
+        res = {}
+        for blk in self.blocks:
+            bres = func(blk.values, *args, **kwargs)
+            if np.ndim(bres) == 0 and blk.shape[0] != 1:
+                # i.e. we reduced over all axes and not just one; re-do column-wise
+                new_res = {
+                    blk.mgr_locs.as_array[i]: func(blk.values[i], *args, **kwargs)
+                    for i in range(len(blk.values))
+                }
+            elif np.ndim(bres) == 0:
+                # EA
+                assert blk.shape[0] == 1
+                new_res = zip(blk.mgr_locs.as_array, [bres])
+            else:
+                assert bres.ndim == 1, bres.shape
+                assert blk.shape[0] == len(bres)
+                new_res = zip(blk.mgr_locs.as_array, bres)
+
+            nr = dict(new_res)
+            assert not any(key in res for key in nr)
+            res.update(nr)
+
+        return res
+
     def apply(
         self,
         f,

pandas/tests/groupby/test_groupby.py

@@ -772,7 +772,7 @@ def test_omit_nuisance(df):
 
     # won't work with axis = 1
     grouped = df.groupby({"A": 0, "C": 0, "D": 1, "E": 1}, axis=1)
-    msg = r"unsupported operand type\(s\) for \+: 'Timestamp'"
+    msg = "reduction operation 'sum' not allowed for this dtype"
     with pytest.raises(TypeError, match=msg):
         grouped.agg(lambda x: x.sum(0, numeric_only=False))