REF: ignore_failures in BlockManager.reduce

pandas/core/frame.py

@@ -8598,6 +8598,8 @@ def _reduce(
             cols = self.columns[~dtype_is_dt]
             self = self[cols]
 
+        any_object = self.dtypes.apply(is_object_dtype).any()
+
         if axis is None and filter_type == "bool":
             labels = None
             constructor = None
@@ -8630,7 +8632,9 @@ def _get_data(axis_matters):
                 raise NotImplementedError(msg)
             return data
 
-        if numeric_only is not None and axis in [0, 1]:
+        if (numeric_only is not None and axis in [0, 1]) or (
+            numeric_only is None and axis == 0 and not any_object
+        ):
             df = self
             if numeric_only is True:
                 df = _get_data(axis_matters=True)
@@ -8639,6 +8643,7 @@ def _get_data(axis_matters):
                 axis = 0
 
             out_dtype = "bool" if filter_type == "bool" else None
+            ignore_failures = numeric_only is None
 
             def blk_func(values):
                 if isinstance(values, ExtensionArray):
@@ -8648,12 +8653,14 @@ def blk_func(values):
 
             # After possibly _get_data and transposing, we are now in the
             #  simple case where we can use BlockManager.reduce
-            res = df._mgr.reduce(blk_func)
-            out = df._constructor(res,).iloc[0].rename(None)
+            res, indexer = df._mgr.reduce(blk_func, ignore_failures=ignore_failures)
+            out = df._constructor(res).iloc[0].rename(None)
             if out_dtype is not None:
                 out = out.astype(out_dtype)
             if axis == 0 and is_object_dtype(out.dtype):
-                out[:] = coerce_to_dtypes(out.values, df.dtypes)
+                # GH#35865 careful to cast explicitly to object
+                nvs = coerce_to_dtypes(out.values, df.dtypes.iloc[np.sort(indexer)])
+                out[:] = np.array(nvs, dtype=object)
             return out
 
         if not self._is_homogeneous_type or self._mgr.any_extension_types:

pandas/core/internals/managers.py

@@ -330,18 +330,31 @@ def _verify_integrity(self) -> None:
                 f"tot_items: {tot_items}"
             )
 
-    def reduce(self: T, func) -> T:
+    def reduce(self: T, func, ignore_failures: bool = False) -> Tuple[T, np.ndarray]:
         # If 2D, we assume that we're operating column-wise
         assert self.ndim == 2
 
-        res_blocks = []
-        for blk in self.blocks:
-            nbs = blk.reduce(func)
+        res_blocks: List[Block] = []
+        skipped: List[int] = []
+        for i, blk in enumerate(self.blocks):
+            try:
+                nbs = blk.reduce(func)
+            except TypeError:
+                if ignore_failures:
+                    skipped.append(i)
+                    continue
+                raise
             res_blocks.extend(nbs)
 
+        if res_blocks:
+            indexer = np.concatenate([blk.mgr_locs.as_array for blk in res_blocks])
+        else:
+            indexer = []
+
+        new_items = self.reset_dropped_locs(res_blocks, skipped)
         index = Index([0])  # placeholder
-        new_mgr = BlockManager.from_blocks(res_blocks, [self.items, index])
-        return new_mgr
+        new_mgr = BlockManager.from_blocks(res_blocks, [new_items, index])
+        return new_mgr, indexer
 
     def operate_blockwise(self, other: "BlockManager", array_op) -> "BlockManager":
         """
@@ -1499,6 +1512,12 @@ def reset_dropped_locs(self, blocks: List[Block], skipped: List[int]) -> Index:
         -----
         Alters each block's mgr_locs inplace.
         """
+        if not skipped:
+            return self.items.copy()
+        elif not blocks:
+            # empty index with same dtype and name
+            return self.items[:0]
+
         ncols = len(self)
 
         new_locs = [blk.mgr_locs.as_array for blk in blocks]