add tests for func input to .agg to TestDataFrameAggregate and TestSeriesAggregate

Author: tp

doc/source/whatsnew/v0.23.1.txt

@@ -94,3 +94,4 @@ Numeric
 ^^^^^^^
 
 - :meth:`~DataFrame.agg` now correctly handles numpy NaN-aware methods like :meth:`numpy.nansum` (:issue:`19629`)
+- :meth:`~DataFrame.agg` now correctly handles built-in methods like ``sum`` when axis=1 (:issue:`19629`)

pandas/core/frame.py

@@ -5818,13 +5818,12 @@ def _gotitem(self,
     def aggregate(self, func, axis=0, *args, **kwargs):
         axis = self._get_axis_number(axis)
 
-        # TODO: flipped axis
         result = None
-        if axis == 0:
-            try:
-                result, how = self._aggregate(func, axis=0, *args, **kwargs)
-            except TypeError:
-                pass
+        df = self if not axis else self.T
+        try:
+            result, how = df._aggregate(func, axis=0, *args, **kwargs)
+        except TypeError:
+            pass
         if result is None:
             return self.apply(func, axis=axis, args=args, **kwargs)
         return result

pandas/tests/frame/test_apply.py

@@ -1056,3 +1056,37 @@ def test_non_callable_aggregates(self):
         expected = df.size
 
         assert result == expected
+
+    @pytest.mark.parametrize("test_input", [
+        # is either frame or tuple (frame, args, kwargs),
+        pd.DataFrame([[1, 2], [3, 4]]),
+        pd.DataFrame([[np.nan, 2], [3, 4]]),
+        pd.DataFrame(),
+    ])
+    @pytest.mark.parametrize(
+        "cython_table_items",
+        list(pd.core.base.SelectionMixin._cython_table.items()),
+        ids=lambda x: "({}-{!r})".format(x[0].__name__, x[1]),
+    )
+    def test_agg_function_input(self, cython_table_items, test_input):
+        # test whether the functions (keys) in
+        # pd.core.base.SelectionMixin._cython_table give the same result
+        # as the related strings (values) when used in df.agg. Examples:
+        # - ``df.agg(np.nansum)`` should give the same result as
+        #   ``df.agg('sum')``
+        # - ``df.agg(sum)`` should give the same result as ``df.agg('sum')``
+        # etc.
+        # GH21123
+        np_func, str_func = cython_table_items
+
+        if isinstance(test_input, pd.DataFrame):
+            df, args, kwargs = test_input, (), {}
+        else:
+            df, args, kwargs = test_input
+
+        tm.assert_almost_equal(df.agg(np_func, *args, **kwargs),
+                               df.agg(str_func, *args, **kwargs),
+                               check_exact=True)
+        tm.assert_almost_equal(df.agg(np_func, axis=1, *args, **kwargs),
+                               df.agg(str_func, axis=1, *args, **kwargs),
+                               check_exact=True)

pandas/tests/series/test_apply.py

@@ -587,3 +587,34 @@ def test_map_missing_mixed(self, vals, mapping, exp):
         result = s.map(mapping)
 
         tm.assert_series_equal(result, pd.Series(exp))
+
+    @pytest.mark.parametrize("test_input", [
+        # is either series or tuple  (series, args, kwargs),
+        pd.Series([1, 2, 3, 4]),
+        pd.Series([np.nan, 2, 3, 4]),
+        pd.Series(),
+    ])
+    @pytest.mark.parametrize(
+        "cython_table_items",
+        list(pd.core.base.SelectionMixin._cython_table.items()),
+        ids=lambda x: "({}-{!r})".format(x[0].__name__, x[1]),
+    )
+    def test_agg_function_input(self, cython_table_items, test_input):
+        # test whether the functions (keys) in
+        # pd.core.base.SelectionMixin._cython_table give the same result
+        # as the related strings (values), when used in ser.agg. Examples:
+        # - ``ser.agg(np.nansum)`` should give the same result as
+        #   ``ser.agg('sum')``
+        # - ``ser.agg(sum)`` should give the same result as ``ser.agg('sum')``
+        # etc.
+        # GH21123
+        np_func, str_func = cython_table_items
+
+        if isinstance(test_input, (pd.DataFrame, pd.Series)):
+            ser, args, kwargs = test_input, (), {}
+        else:
+            ser, args, kwargs = test_input
+
+        tm.assert_almost_equal(ser.agg(np_func, *args, **kwargs),
+                               ser.agg(str_func, *args, **kwargs),
+                               check_exact=True)

pandas/tests/test_nanops.py

@@ -13,8 +13,7 @@
 import pandas.core.nanops as nanops
 import pandas.util.testing as tm
 import pandas.util._test_decorators as td
-from pandas.compat.numpy import (_np_version_under1p13, _np_version_under1p10,
-                                 _np_version_under1p12)
+from pandas.compat.numpy import _np_version_under1p13
 
 use_bn = nanops._USE_BOTTLENECK
 
@@ -995,52 +994,6 @@ def prng(self):
         return np.random.RandomState(1234)
 
 
-@pytest.fixture(params=[
-    pd.Series([1, 2, 3, 4]),
-    pd.DataFrame([[1, 2], [3, 4]]),
-    pd.Series([np.nan, 2, 3, 4]),
-    pd.DataFrame([[np.nan, 2], [3, 4]]),
-    pd.Series(),
-    pd.DataFrame(),
-    pd.Series([np.nan]),
-    pd.DataFrame([[np.nan]]),
-])
-def series_or_frame(request):
-    return request.param
-
-
-@pytest.mark.parametrize("standard, nan_method", [
-    (np.sum, np.nansum),
-    (np.mean, np.nanmean),
-    (np.std, np.nanstd),
-    (np.var, np.nanvar),
-    (np.median, np.nanmedian),
-    (np.max, np.nanmax),
-    (np.min, np.nanmin),
-], ids=lambda x: x.__name__)
-def test_np_nan_functions(standard, nan_method, series_or_frame):
-    tm.assert_almost_equal(series_or_frame.agg(standard),
-                           series_or_frame.agg(nan_method),
-                           check_exact=True)
-
-
-@pytest.mark.skipif(_np_version_under1p10, reason="requires numpy>=1.10")
-def test_np_nanprod(series_or_frame):
-    tm.assert_almost_equal(series_or_frame.agg(np.prod),
-                           series_or_frame.agg(np.nanprod),
-                           check_exact=True)
-
-
-@pytest.mark.skipif(_np_version_under1p12, reason="requires numpy>=1.12")
-def test_np_nancumprod(series_or_frame):
-    funcs = [(np.cumprod, np.nancumprod),
-             (np.cumsum, np.nancumsum)]
-    for standard, nan_method in funcs:
-        tm.assert_almost_equal(series_or_frame.agg(standard),
-                               series_or_frame.agg(nan_method),
-                               check_exact=True)
-
-
 def test_use_bottleneck():
 
     if nanops._BOTTLENECK_INSTALLED: