return MI series

Author: jreback

doc/source/basics.rst

@@ -890,7 +890,7 @@ Multiple functions yield multiple rows.
 
    tsdf.agg(['sum', 'mean'])
 
-On a Series, multiple functions return a Series.
+On a Series, multiple functions return a Series, indexed by the function names.
 
 .. ipython:: python
 
@@ -914,7 +914,8 @@ of all of the aggregators; some may be missing values.
 
    tsdf.agg({'A': ['mean', 'min'], 'B': 'sum'})
 
-For a Series, you can pass a dict; the keys will set the name of the column
+For a Series, you can pass a dict. You will get back a MultiIndex Series; The outer level will
+be the keys, the inner the name of the functions.
 
 .. ipython:: python
 
@@ -924,9 +925,10 @@ Alternatively, using multiple dictionaries, you can have renamed elements with t
 
 .. ipython:: python
 
-    tsdf.A.agg({'foo' : 'sum', 'bar':'mean'})
+    tsdf.A.agg({'foo' : 'sum', 'bar': 'mean'})
 
-Multiple keys will yield multiple columns.
+Multiple keys will yield a MultiIndex Series. The outer level will be the keys, the inner
+the names of the functions.
 
 .. ipython:: python
 

doc/source/whatsnew/v0.20.0.txt

@@ -64,7 +64,8 @@ Dictionaries to provide the ability to selective calculation.
    df.agg({'A' : ['sum', 'min'], 'B' : ['min', 'max']})
 
 When operating on a Series, passing a dictionry allows one to rename multiple
-function aggregates; this will return a DataFrame.
+function aggregates; this will return a MultiIndexed Series. The outer level
+are the keys, the inner are the names of the functions.
 
 .. ipython:: python
 

pandas/core/base.py

@@ -581,18 +581,53 @@ def _agg(arg, func):
                     result = _agg(arg, _agg_2dim)
 
             # combine results
+
+            def is_any_series():
+                # return a boolean if we have *any* nested series
+                return any([isinstance(r, ABCSeries)
+                            for r in compat.itervalues(result)])
+
+            def is_any_frame():
+                # return a boolean if we have *any* nested series
+                return any([isinstance(r, ABCDataFrame)
+                            for r in compat.itervalues(result)])
+
             if isinstance(result, list):
-                result = concat(result, keys=keys, axis=1)
-            elif isinstance(list(compat.itervalues(result))[0],
-                            ABCDataFrame):
-                result = concat([result[k] for k in keys], keys=keys, axis=1)
-            else:
-                from pandas import DataFrame, Series
+                return concat(result, keys=keys, axis=1), True
+
+            elif is_any_frame():
+                # we have a dict of DataFrames
+                # return a MI DataFrame
+
+                return concat([result[k] for k in keys],
+                              keys=keys, axis=1), True
+
+            elif isinstance(self, ABCSeries) and is_any_series():
+
+                # we have a dict of Series
+                # return a MI Series
                 try:
-                    result = DataFrame(result)
-                except ValueError:
-                    # we have a dict of scalars
-                    result = Series(result, name=getattr(self, 'name', None))
+                    result = concat(result)
+                except TypeError:
+                    # we want to give a nice error here if
+                    # we have non-same sized objects, so
+                    # we don't automatically broadcast
+
+                    raise ValueError("cannot perform both aggregation "
+                                     "and transformation operations "
+                                     "simultaneously")
+
+                return result, True
+
+            # fall thru
+            from pandas import DataFrame, Series
+            try:
+                result = DataFrame(result)
+            except ValueError:
+
+                # we have a dict of scalars
+                result = Series(result,
+                                name=getattr(self, 'name', None))
 
             return result, True
         elif is_list_like(arg) and arg not in compat.string_types:
@@ -651,10 +686,17 @@ def _aggregate_multiple_funcs(self, arg, _level, _axis):
                 except SpecificationError:
                     raise
 
+        # if we are empty
+        if not len(results):
+            raise ValueError("no results")
+
         try:
             return concat(results, keys=keys, axis=1)
-        except (TypeError, ValueError):
-            # shape change
+        except TypeError:
+
+            # we are concatting non-NDFrame objects,
+            # e.g. a list of scalars
+
             from pandas.types.cast import _is_nested_object
             from pandas import Series
             result = Series(results, index=keys, name=self.name)

pandas/tests/series/test_apply.py

@@ -189,8 +189,10 @@ def test_transform(self):
             # dict, provide renaming
             expected = pd.concat([f_sqrt, f_abs], axis=1)
             expected.columns = ['foo', 'bar']
+            expected = expected.unstack().rename('series')
+
             result = self.series.apply({'foo': np.sqrt, 'bar': np.abs})
-            assert_frame_equal(result.reindex_like(expected), expected)
+            assert_series_equal(result.reindex_like(expected), expected)
 
     def test_transform_and_agg_error(self):
         # we are trying to transform with an aggregator
@@ -208,43 +210,41 @@ def f():
                 self.series.transform(['sqrt', 'max'])
         self.assertRaises(ValueError, f)
 
-    def test_todo(self):
-        # TODO
-        # This should raise, column selection is not possible here
-        # and renaming doesn't make sense
-        # result = self.series.apply({'foo': ['sqrt', 'log']})
-
-        # TODO
-        # difference in apply / agg semantics when passing a
-        # row-wise aggregator
-        pass
+        def f():
+            with np.errstate(all='ignore'):
+                self.series.agg({'foo': np.sqrt, 'bar': 'sum'})
+        self.assertRaises(ValueError, f)
 
     def test_demo(self):
         # demonstration tests
-        s = Series(range(6), dtype='int64')
+        s = Series(range(6), dtype='int64', name='series')
 
         result = s.agg(['min', 'max'])
-        expected = Series([0, 5], index=['min', 'max'])
+        expected = Series([0, 5], index=['min', 'max'], name='series')
         tm.assert_series_equal(result, expected)
 
         result = s.agg({'foo': 'min'})
-        expected = Series([0], index=['foo'])
+        expected = Series([0], index=['foo'], name='series')
         tm.assert_series_equal(result, expected)
 
         result = s.agg({'foo': ['min', 'max']})
-        expected = DataFrame({'foo': [0, 5]}, index=['min', 'max'])
-        tm.assert_frame_equal(result, expected)
+        expected = DataFrame(
+            {'foo': [0, 5]},
+            index=['min', 'max']).unstack().rename('series')
+        tm.assert_series_equal(result, expected)
 
     def test_multiple_aggregators_with_dict_api(self):
 
-        s = Series(range(6), dtype='int64')
+        s = Series(range(6), dtype='int64', name='series')
         result = s.agg({'foo': ['min', 'max'], 'bar': ['sum', 'mean']})
 
-        expected = DataFrame({'foo': [5.0, np.nan, 0.0, np.nan],
-                              'bar': [np.nan, 2.5, np.nan, 15.0]},
-                             columns=['foo', 'bar'],
-                             index=['max', 'mean', 'min', 'sum'])
-        tm.assert_frame_equal(result.reindex_like(expected), expected)
+        expected = DataFrame(
+            {'foo': [5.0, np.nan, 0.0, np.nan],
+             'bar': [np.nan, 2.5, np.nan, 15.0]},
+            columns=['foo', 'bar'],
+            index=['max', 'mean',
+                   'min', 'sum']).unstack().rename('series')
+        tm.assert_series_equal(result.reindex_like(expected), expected)
 
     def test_agg_apply_evaluate_lambdas_the_same(self):
         # test that we are evaluating row-by-row first

pandas/tseries/tests/test_resample.py

@@ -1777,10 +1777,12 @@ def test_how_lambda_functions(self):
         tm.assert_series_equal(result['foo'], foo_exp)
         tm.assert_series_equal(result['bar'], bar_exp)
 
+        # this is a MI Series, so comparing the names of the results
+        # doesn't make sense
         result = ts.resample('M').aggregate({'foo': lambda x: x.mean(),
                                              'bar': lambda x: x.std(ddof=1)})
-        tm.assert_series_equal(result['foo'], foo_exp)
-        tm.assert_series_equal(result['bar'], bar_exp)
+        tm.assert_series_equal(result['foo'], foo_exp, check_names=False)
+        tm.assert_series_equal(result['bar'], bar_exp, check_names=False)
 
     def test_resample_unequal_times(self):
         # #1772