fix nuiscance column / string aggs

closes pandas-dev#15015

Author: jreback

doc/source/basics.rst

@@ -934,7 +934,27 @@ the names of the functions.
 
     tsdf.A.agg({'foo' : ['sum', 'mean'], 'bar': ['min', 'max', lambda x: x.sum()+1]})
 
-.. _basics.custom_describe:
+.. _basics.aggregation.mixed_dtypes:
+
+Mixed Dtypes
+++++++++++++
+
+When presented with mixed dtypes that cannot aggregate, ``.agg`` will only take the valid
+aggregations. This is similiar to how groupby ``.agg`` works.
+
+.. ipython:: python
+
+   mdf = pd.DataFrame({'A': [1, 2, 3],
+                       'B': [1., 2., 3.],
+                       'C': ['foo', 'bar', 'baz'],
+                       'D': pd.date_range('20130101', periods=3)})
+   mdf.dtypes
+
+.. ipython:: python
+
+   mdf.agg(['min', 'sum'])
+
+.. _basics.aggregation.custom_describe:
 
 Custom describe
 +++++++++++++++

doc/source/whatsnew/v0.20.0.txt

@@ -77,6 +77,20 @@ The API also supports a ``.transform()`` function to provide for broadcasting re
 
    df.transform(['abs', lambda x: x-x.min()])
 
+When presented with mixed dtypes that cannot aggregate, ``.agg`` will only take the valid
+aggregations. This is similiar to how groupby ``.agg`` works. (:issue:`15015`)
+
+.. ipython:: python
+
+   df = pd.DataFrame({'A': [1, 2, 3],
+                      'B': [1., 2., 3.],
+                      'C': ['foo', 'bar', 'baz'],
+                      'D': pd.date_range('20130101', periods=3)})
+   df.dtypes
+
+.. ipython:: python
+
+   df.agg(['min', 'sum'])
 
 .. _whatsnew_0200.enhancements.dataio_dtype:
 

pandas/core/base.py

@@ -683,6 +683,9 @@ def _aggregate_multiple_funcs(self, arg, _level, _axis):
                     keys.append(col)
                 except (TypeError, DataError):
                     pass
+                except ValueError:
+                    # cannot aggregate
+                    continue
                 except SpecificationError:
                     raise
 

pandas/core/frame.py

@@ -4128,6 +4128,7 @@ def apply(self, func, axis=0, broadcast=False, raw=False, reduce=None,
         applied : Series or DataFrame
         """
         axis = self._get_axis_number(axis)
+        ignore_failures = kwds.pop('ignore_failures', False)
 
         # dispatch to agg
         if axis == 0 and isinstance(func, (list, dict)):
@@ -4164,7 +4165,9 @@ def f(x):
                 else:
                     if reduce is None:
                         reduce = True
-                    return self._apply_standard(f, axis, reduce=reduce)
+                    return self._apply_standard(f, axis,
+                                                reduce=reduce,
+                                                ignore_failures=ignore_failures)
             else:
                 return self._apply_broadcast(f, axis)
 
@@ -4968,7 +4971,11 @@ def f(x):
                         # this can end up with a non-reduction
                         # but not always. if the types are mixed
                         # with datelike then need to make sure a series
-                        result = self.apply(f, reduce=False)
+
+                        # we only end up here if we have not specified numeric_only
+                        # and yet we have tried a column-by-column reduction, where
+                        # we have mixed type. So let's just do what we can
+                        result = self.apply(f, reduce=False, ignore_failures=True)
                         if result.ndim == self.ndim:
                             result = result.iloc[0]
                         return result

pandas/tests/frame/test_apply.py

@@ -533,26 +533,10 @@ def f():
                 self.frame.transform(['max', 'sqrt'])
         self.assertRaises(ValueError, f)
 
-    def test_agg_todo(self):
-        # if we have a transforming function & a reducer
-        # we have to resolve
-        # TODO
-        # result = self.frame.apply([np.sqrt, np.mean])
-
-        # TODO
-        # difference in apply / agg semantics when passing a
-        # row-wise aggregator
-        pass
-
-    def test_broken(self):
-        # TODO
-        # df = pd.DataFrame({'A': range(5), 'B': 5})
-        # result = df.agg({'A':['abs', 'sum'], 'B':['mean','max']})
-        # expected = DataFrame({'A': [0, 4], 'B': [5, 5]},
-        #                     columns=['A', 'B'],
-        #                     index=['min', 'max'])
-        # tm.assert_frame_equal(result, expected)
-        pass
+        df = pd.DataFrame({'A': range(5), 'B': 5})
+        def f():
+            with np.errstate(all='ignore'):
+                df.agg({'A':['abs', 'sum'], 'B':['mean','max']})
 
     def test_demo(self):
         # demonstration tests
@@ -604,3 +588,31 @@ def test_agg_reduce(self):
                                            self.frame.B.max()],
                                           index=['sum', 'max'])})
         assert_frame_equal(result.reindex_like(expected), expected)
+
+    def test_nuiscance_columns(self):
+
+        # GH 15015
+        df = DataFrame({'A': [1, 2, 3],
+                        'B': [1., 2., 3.],
+                        'C': ['foo', 'bar', 'baz'],
+                        'D': pd.date_range('20130101', periods=3)})
+
+        result = df.agg('min')
+        expected = Series([1, 1., 'bar', pd.Timestamp('20130101')],
+                          index=df.columns)
+        assert_series_equal(result, expected)
+
+        result = df.agg(['min'])
+        expected = DataFrame([[1, 1., 'bar', pd.Timestamp('20130101')]],
+                             index=['min'], columns=df.columns)
+        assert_frame_equal(result, expected)
+
+        result = df.agg('sum')
+        expected = Series([6, 6., 'foobarbaz'],
+                          index=['A', 'B', 'C'])
+        assert_series_equal(result, expected)
+
+        result = df.agg(['sum'])
+        expected = DataFrame([[6, 6., 'foobarbaz']],
+                             index=['sum'], columns=['A', 'B', 'C'])
+        assert_frame_equal(result, expected)