ENH: Implement Keyword Aggregation for DataFrame.agg and Series.agg

pandas/core/frame.py

@@ -6588,16 +6588,51 @@ def _gotitem(
         **_shared_doc_kwargs
     )
     @Appender(_shared_docs["aggregate"])
-    def aggregate(self, func, axis=0, *args, **kwargs):
+    def aggregate(self, func=None, axis=0, *args, **kwargs):
+        from pandas.core.groupby.generic import (
+            _is_multi_agg_with_relabel,
+            _maybe_mangle_lambdas,
+            _normalize_keyword_aggregation,
+        )
+
         axis = self._get_axis_number(axis)
 
+        relabeling = func is None and _is_multi_agg_with_relabel(**kwargs)
+        if relabeling:
+            func, indexes, order = _normalize_keyword_aggregation(kwargs)
+            reordered_indexes = [
+                pair[0] for pair in sorted(zip(indexes, order), key=lambda t: t[1])
+            ]
+            kwargs = {}
+        elif func is None:
+            # nicer error message
+            raise TypeError("Must provide 'func' or tuples of '(column, aggfunc).")
+
+        func = _maybe_mangle_lambdas(func)
+
         result = None
         try:
             result, how = self._aggregate(func, axis=axis, *args, **kwargs)
         except TypeError:
             pass
         if result is None:
             return self.apply(func, axis=axis, args=args, **kwargs)
+
+        if relabeling:
+
+            # when there are more than one column being used in aggregate, the order
+            # of result will be reversed, and in case the func is not used by other
+            # columns, there might be NaN values, so separate these two cases
+            reordered_result = DataFrame(index=indexes)
+            idx = 0
+            for col, funcs in func.items():
+                v = reordered_indexes[idx : idx + len(funcs)]
+                if len(func) > 1:
+                    reordered_result.loc[v, col] = result[col][::-1].dropna().values
+                else:
+                    reordered_result.loc[v, col] = result[col].values
+                idx = idx + len(funcs)
+            result = reordered_result
         return result
 
     def _aggregate(self, arg, axis=0, *args, **kwargs):

pandas/core/series.py

@@ -3800,9 +3800,17 @@ def _gotitem(self, key, ndim, subset=None):
         **_shared_doc_kwargs
     )
     @Appender(generic._shared_docs["aggregate"])
-    def aggregate(self, func, axis=0, *args, **kwargs):
+    def aggregate(self, func=None, axis=0, *args, **kwargs):
         # Validate the axis parameter
         self._get_axis_number(axis)
+
+        if func is None:
+            # This is due to order issue of dictionary in PY35, e.g. if {"foo"
+            # : "sum", "bar": "min"}, then it will take "bar" first because it
+            # b is before f
+            func = OrderedDict(kwargs.items())
+            kwargs = {}
+
         result, how = self._aggregate(func, *args, **kwargs)
         if result is None:
 

pandas/tests/frame/test_apply.py

@@ -1367,3 +1367,96 @@ def test_consistency_of_aggregates_of_columns_with_missing_values(self, df, meth
         tm.assert_series_equal(
             none_in_first_column_result, none_in_second_column_result
         )
+
+
+class TestDataFrameNamedAggregate:
+
+    # GH 26513
+    def test_agg_relabel(self):
+        df = pd.DataFrame({"A": [1, 2, 1, 2], "B": [1, 2, 3, 4], "C": [3, 4, 5, 6]})
+
+        # simplest case with one column, one func
+        result = df.agg(foo=("B", "sum"))
+        expected = pd.DataFrame({"B": [10]}, index=pd.Index(["foo"]))
+        tm.assert_frame_equal(result, expected)
+
+        # test on same column with different methods
+        result = df.agg(foo=("B", "sum"), bar=("B", "min"))
+        expected = pd.DataFrame({"B": [10, 1]}, index=pd.Index(["foo", "bar"]))
+
+        tm.assert_frame_equal(result, expected)
+
+        # test on multiple columns with multiple methods
+        result = df.agg(
+            foo=("A", "sum"),
+            bar=("B", "mean"),
+            cat=("A", "min"),
+            dat=("B", "max"),
+            f=("A", "max"),
+            g=("C", "min"),
+        )
+        expected = pd.DataFrame(
+            {
+                "A": [6.0, np.nan, 1.0, np.nan, 2.0, np.nan],
+                "B": [np.nan, 2.5, np.nan, 4.0, np.nan, np.nan],
+                "C": [np.nan, np.nan, np.nan, np.nan, np.nan, 3.0],
+            },
+            index=pd.Index(["foo", "bar", "cat", "dat", "f", "g"]),
+        )
+        tm.assert_frame_equal(result, expected)
+
+        # test on partial, functools or more complex cases
+        result = df.agg(foo=("A", np.mean), bar=("A", "mean"), cat=("A", min))
+        expected = pd.DataFrame(
+            {"A": [1.5, 1.5, 1.0]}, index=pd.Index(["foo", "bar", "cat"])
+        )
+        tm.assert_frame_equal(result, expected)
+
+        result = df.agg(
+            foo=("A", min),
+            bar=("A", np.min),
+            cat=("B", max),
+            dat=("C", "min"),
+            f=("B", np.sum),
+        )
+        expected = pd.DataFrame(
+            {
+                "A": [1.0, 1.0, np.nan, np.nan, np.nan],
+                "B": [np.nan, np.nan, 10.0, np.nan, 4.0],
+                "C": [np.nan, np.nan, np.nan, 3.0, np.nan],
+            },
+            index=pd.Index(["foo", "bar", "cat", "dat", "f"]),
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_agg_namedtuple(self):
+        df = pd.DataFrame({"A": [0, 1], "B": [1, 2]})
+        result = df.agg(
+            foo=pd.NamedAgg("B", "sum"),
+            bar=pd.NamedAgg("B", min),
+            cat=pd.NamedAgg(column="B", aggfunc="count"),
+            fft=pd.NamedAgg("B", aggfunc="max"),
+        )
+
+        expected = pd.DataFrame(
+            {"B": [3, 1, 2, 2]}, index=pd.Index(["foo", "bar", "cat", "fft"])
+        )
+        tm.assert_frame_equal(result, expected)
+
+        result = df.agg(
+            foo=pd.NamedAgg("A", "min"),
+            bar=pd.NamedAgg(column="B", aggfunc="max"),
+            cat=pd.NamedAgg(column="A", aggfunc="max"),
+        )
+        expected = pd.DataFrame(
+            {"A": [0.0, np.nan, 1.0], "B": [np.nan, 2.0, np.nan]},
+            index=pd.Index(["foo", "bar", "cat"]),
+        )
+        tm.assert_frame_equal(result, expected)
+
+    def test_agg_raises(self):
+        df = pd.DataFrame({"A": [0, 1], "B": [1, 2]})
+        msg = "Must provide"
+
+        with pytest.raises(TypeError, match=msg):
+            df.agg()

pandas/tests/series/test_apply.py

@@ -750,3 +750,34 @@ def test_apply_scaler_on_date_time_index_aware_series(self):
         series = tm.makeTimeSeries(nper=30).tz_localize("UTC")
         result = pd.Series(series.index).apply(lambda x: 1)
         tm.assert_series_equal(result, pd.Series(np.ones(30), dtype="int64"))
+
+
+class TestNamedAggregation:
+    def test_relabel_no_duplicated_method(self):
+        # this is to test there is no duplicated method used in agg
+        df = pd.DataFrame({"A": [1, 2, 1, 2], "B": [1, 2, 3, 4]})
+
+        result = df["A"].agg(foo="sum")
+        expected = df["A"].agg({"foo": "sum"})
+        tm.assert_series_equal(result, expected)
+
+        result = df.B.agg(foo="min", bar="max")
+        expected = df.B.agg({"foo": "min", "bar": "max"})
+        tm.assert_series_equal(result, expected)
+
+        result = df.B.agg(foo=sum, bar=min, cat="max")
+        expected = df.B.agg({"foo": sum, "bar": min, "cat": "max"})
+        tm.assert_series_equal(result, expected)
+
+    def test_relabel_duplicated_method(self):
+        # this is to test with nested renaming, duplicated method can be used
+        # if they are assigned with different new names
+        df = pd.DataFrame({"A": [1, 2, 1, 2], "B": [1, 2, 3, 4]})
+
+        result = df.A.agg(foo="sum", bar="sum")
+        expected = pd.Series([6, 6], index=["foo", "bar"], name="A")
+        tm.assert_series_equal(result, expected)
+
+        result = df.B.agg(foo=min, bar="min")
+        expected = pd.Series([1, 1], index=["foo", "bar"], name="B")
+        tm.assert_series_equal(result, expected)