implement+test mean for datetimelike EA/Index/Series

pandas/core/arrays/datetimelike.py

@@ -1435,6 +1435,41 @@ def max(self, axis=None, skipna=True, *args, **kwargs):
         # Don't have to worry about NA `result`, since no NA went in.
         return self._box_func(result)
 
+    def mean(self, axis=None, skipna=True):
+        """
+        Return the mean value of the Array or maximum along
+        an axis.
+
+        Parameters
+        ----------
+        axis : None
+            Dummy parameter to match NumPy signature
+        skipna : bool, default True
+            Whether to ignore any NaT elements
+
+        See Also
+        --------
+        numpy.ndarray.mean
+        Series.mean : Return the mean value in a Series.
+        """
+        nv.validate_minmax_axis(axis)
+
+        mask = self.isna()
+        if skipna:
+            values = self[~mask]
+        elif mask.any():
+            return NaT
+        else:
+            values = self
+
+        if not len(values):
+            # short-circut for empty max / min
+            return NaT
+
+        result = nanops.nanmean(values.view('i8'), skipna=skipna)
+        # Don't have to worry about NA `result`, since no NA went in.
+        return self._box_func(result)
+
 
 # -------------------------------------------------------------------
 # Shared Constructor Helpers

pandas/core/indexes/datetimelike.py

@@ -72,6 +72,7 @@ class DatetimeIndexOpsMixin(ExtensionOpsMixin):
     _maybe_mask_results = ea_passthrough(
         DatetimeLikeArrayMixin._maybe_mask_results)
     __iter__ = ea_passthrough(DatetimeLikeArrayMixin.__iter__)
+    mean = ea_passthrough(DatetimeLikeArrayMixin.mean)
 
     @property
     def freq(self):

pandas/core/series.py

@@ -3614,6 +3614,9 @@ def _reduce(self, op, name, axis=0, skipna=True, numeric_only=None,
         elif is_datetime64_dtype(delegate):
             # use DatetimeIndex implementation to handle skipna correctly
             delegate = DatetimeIndex(delegate)
+        elif is_timedelta64_dtype(delegate) and hasattr(TimedeltaIndex, name):
+            # use TimedeltaIndex to handle skipna correctly
+            delegate = TimedeltaIndex(delegate)
 
         # dispatch to numpy arrays
         elif isinstance(delegate, np.ndarray):

pandas/tests/frame/test_analytics.py

@@ -1304,6 +1304,39 @@ def test_mean_corner(self, float_frame, float_string_frame):
         means = float_frame.mean(0)
         assert means['bool'] == float_frame['bool'].values.mean()
 
+    def test_mean_datetimelike(self):
+        # GH#24757 check that datetimelike are excluded by default, handled
+        #  correctly with numeric_only=True
+
+        df = pd.DataFrame({
+            'A': np.arange(3),
+            'B': pd.date_range('2016-01-01', periods=3),
+            'C': pd.timedelta_range('1D', periods=3),
+            'D': pd.period_range('2016', periods=3, freq='A')
+        })
+        result = df.mean(numeric_only=True)
+        expected = pd.Series({'A': 1.})
+        tm.assert_series_equal(result, expected)
+
+        result = df.mean()
+        expected = pd.Series({
+            'A': 1.,
+            'B': df.loc[1, 'B'],
+            'C': df.loc[1, 'C']
+        })
+        tm.assert_series_equal(result, expected)
+
+        # FIXME: df.mean(numeric_only=False) raises TypeError because
+        #  it casts to object-dtype and tries to add Timestamps.
+        # result = df.mean(numeric_only=False)
+        # expected = pd.Series({
+        #    'A': 1,
+        #    'B': df.loc[1, 'B'],
+        #    'C': df.loc[1, 'C'],
+        #    'D': df.loc[1, 'D']
+        # })
+        # tm.assert_series_equal(result, expected)
+
     def test_stats_mixed_type(self, float_string_frame):
         # don't blow up
         float_string_frame.std(1)

pandas/tests/indexes/datetimes/test_ops.py

@@ -47,6 +47,27 @@ def test_ops_properties_basic(self):
         assert s.day == 10
         pytest.raises(AttributeError, lambda: s.weekday)
 
+    # TODO: figure out where in tests.reductions this belongs
+    def test_mean(self, tz_naive_fixture):
+        tz = tz_naive_fixture
+        idx1 = pd.DatetimeIndex(['2011-01-01', '2011-01-02',
+                                 '2011-01-03'], tz=tz)
+        assert idx1.mean() == pd.Timestamp('2011-01-02', tz=tz)
+        assert idx1._data.mean() == pd.Timestamp('2011-01-02', tz=tz)
+
+        idx2 = pd.DatetimeIndex(['2011-01-01', '2011-01-02', pd.NaT,
+                                 '2011-01-03'], tz=tz)
+        assert idx2.mean(skipna=False) is pd.NaT
+        assert idx2._data.mean(skipna=False) is pd.NaT
+        assert idx2.mean(skipna=True) == idx2[1]
+        assert idx2._data.mean(skipna=True) == idx2[1]
+
+        idx3 = pd.DatetimeIndex([])
+        assert idx3.mean() is pd.NaT
+        assert idx3._data.mean() is pd.NaT
+        assert idx3.mean(skipna=False) is pd.NaT
+        assert idx3._data.mean(skipna=False) is pd.NaT
+
     def test_minmax_tz(self, tz_naive_fixture):
         tz = tz_naive_fixture
         # monotonic

pandas/tests/reductions/test_stat_reductions.py

@@ -11,9 +11,74 @@
 
 import pandas as pd
 from pandas import DataFrame, Series, compat
+from pandas.core.arrays import DatetimeArray, PeriodArray, TimedeltaArray
 import pandas.util.testing as tm
 
 
+class TestDatetimeLikeStatReductions(object):
+    @pytest.mark.parametrize('box', [Series, pd.Index, DatetimeArray])
+    @pytest.mark.parametrize('tz', [None, 'US/Mountain'])
+    def test_dt64_mean(self, tz, box):
+        dti = pd.date_range('2001-01-01', periods=11, tz=tz)
+        # shuffle so that we are not just working with monotone-increasing
+        dti = dti.take([4, 1, 3, 10, 9, 7, 8, 5, 0, 2, 6])
+        dtarr = dti._data
+
+        obj = box(dtarr)
+        assert obj.mean() == pd.Timestamp('2001-01-06', tz=tz)
+        assert obj.mean(skipna=False) == pd.Timestamp('2001-01-06', tz=tz)
+
+        # dtarr[-2] will be the first date 2001-01-1
+        dtarr[-2] = pd.NaT
+
+        obj = box(dtarr)
+        assert obj.mean() == pd.Timestamp('2001-01-06 07:12:00', tz=tz)
+        assert obj.mean(skipna=False) is pd.NaT
+
+    @pytest.mark.parametrize('box', [Series, pd.Index, PeriodArray])
+    def test_period_mean(self, box):
+        dti = pd.date_range('2001-01-01', periods=11)
+        # shuffle so that we are not just working with monotone-increasing
+        dti = dti.take([4, 1, 3, 10, 9, 7, 8, 5, 0, 2, 6])
+
+        # use hourly frequency to avoid rounding errors in expected results
+        #  TODO: flesh this out with different frequencies
+        parr = dti._data.to_period('H')
+        obj = box(parr)
+        assert obj.mean() == pd.Period('2001-01-06', freq='H')
+        assert obj.mean(skipna=False) == pd.Period('2001-01-06', freq='H')
+
+        # parr[-2] will be the first date 2001-01-1
+        parr[-2] = pd.NaT
+
+        # with rounding, we get the period containing the result
+        #  for the dt64 case above
+        obj = box(parr)
+        assert obj.mean() == pd.Period('2001-01-06 07:00', freq='H')
+        assert obj.mean(skipna=False) is pd.NaT
+
+    @pytest.mark.parametrize('box', [Series, pd.Index, TimedeltaArray])
+    def test_td64_mean(self, box):
+        tdi = pd.TimedeltaIndex([0, 3, -2, -7, 1, 2, -1, 3, 5, -2, 4],
+                                unit='D')
+
+        tdarr = tdi._data
+        obj = box(tdarr)
+
+        result = obj.mean()
+        expected = np.array(tdarr).mean()
+        assert result == expected
+
+        tdarr[0] = pd.NaT
+        assert obj.mean(skipna=False) is pd.NaT
+
+        result2 = obj.mean(skipna=True)
+        assert result2 == tdi[1:].mean()
+
+        # exact equality fails by 1 nanosecond
+        assert result2.round('us') == (result * 11. / 10).round('us')
+
+
 class TestSeriesStatReductions(object):
     # Note: the name TestSeriesStatReductions indicates these tests
     #  were moved from a series-specific test file, _not_ that these tests are