Makes changes based on feedback from @jreback

Author: nateyoder

Diff for: pandas/core/series.py

@@ -40,8 +40,7 @@
                                 _try_sort,
                                 _maybe_match_name,
                                 SettingWithCopyError,
-                                _maybe_box_datetimelike,
-                                _dict_compat)
+                                _maybe_box_datetimelike)
 from pandas.core.index import (Index, MultiIndex, InvalidIndexError,
                                Float64Index, _ensure_index)
 from pandas.core.indexing import check_bool_indexer, maybe_convert_indices
@@ -186,7 +185,7 @@ def __init__(self, data=None, index=None, dtype=None, name=None,
                         index = Index(_try_sort(data))
 
                 try:
-                    data = index.get_values_from_dict(data)
+                    data = index._get_values_from_dict(data)
                 except TypeError:
                     data = ([data.get(i, nan) for i in index]
                             if data else np.nan)

Diff for: pandas/indexes/base.py

@@ -2448,23 +2448,25 @@ def get_indexer_for(self, target, **kwargs):
         indexer, _ = self.get_indexer_non_unique(target, **kwargs)
         return indexer
 
-    def get_values_from_dict(self, input_dict):
-        """Return the values of the input dictionary in the order the keys are
+    _index_shared_docs['_get_values_from_dict'] = """
+        Return the values of the input dictionary in the order the keys are
         in the index. np.nan is returned for index values not in the
         dictionary.
 
         Parameters
         ----------
-        input_dict : dict
+        data : dict
             The dictionary from which to extract the values
 
         Returns
         -------
-        Union[np.array, list]
+        np.array
 
         """
 
-        return lib.fast_multiget(input_dict, self.values,
+    @Appender(_index_shared_docs['_get_values_from_dict'])
+    def _get_values_from_dict(self, data):
+        return lib.fast_multiget(data, self.values,
                                  default=np.nan)
 
     def _possibly_promote(self, other):
@@ -2510,8 +2512,9 @@ def map(self, mapper):
 
         Parameters
         ----------
-        mapper : Union[function, dict, Series]
+        mapper : {callable, dict, Series}
             Function to be applied or input correspondence object.
+            dict and Series support new in 0.20.0.
 
         Returns
         -------
@@ -2528,7 +2531,7 @@ def map(self, mapper):
             mapped_values = algos.take_1d(mapper.values, indexer)
         elif isinstance(mapper, dict):
             idx = Index(mapper.keys())
-            data = idx.get_values_from_dict(mapper)
+            data = idx._get_values_from_dict(mapper)
             indexer = idx.get_indexer(self.values)
             mapped_values = algos.take_1d(data, indexer)
         else:

Diff for: pandas/tests/indexes/test_base.py

@@ -812,60 +812,32 @@ def test_map_tseries_indices_return_index(self):
         tm.assert_index_equal(exp, date_index.map(lambda x: x.hour))
 
     def test_map_with_dict_and_series(self):
+        # GH 12756
         expected = Index(['foo', 'bar', 'baz'])
         mapper = Series(expected.values, index=[0, 1, 2])
-        tm.assert_index_equal(tm.makeIntIndex(3).map(mapper), expected)
-
-        # GH 12766
-        # special = []
-        special = ['catIndex']
-
-        for name in special:
-            orig_values = ['a', 'B', 1, 'a']
-            new_values = ['one', 2, 3.0, 'one']
-            cur_index = CategoricalIndex(orig_values, name='XXX')
-            expected = CategoricalIndex(new_values,
-                                        name='XXX', categories=[3.0, 2, 'one'])
-
-            mapper = pd.Series(new_values[:-1], index=orig_values[:-1])
-            output = cur_index.map(mapper)
-            # Order of categories in output can be different
-            tm.assert_index_equal(expected, output)
+        result = tm.makeIntIndex(3).map(mapper)
+        tm.assert_index_equal(result, expected)
 
-            mapper = {o: n for o, n in
-                      zip(orig_values[:-1], new_values[:-1])}
-            output = cur_index.map(mapper)
-            # Order of categories in output can be different
-            tm.assert_index_equal(expected, output)
+        for name in self.indices.keys():
+            if name == 'catIndex':
+                # Tested in test_categorical
+                continue
 
-        for name in list(set(self.indices.keys()) - set(special)):
             cur_index = self.indices[name]
             expected = Index(np.arange(len(cur_index), 0, -1))
             mapper = pd.Series(expected, index=cur_index)
             tm.assert_index_equal(expected, cur_index.map(mapper))
 
             mapper = {o: n for o, n in
                       zip(cur_index, expected)}
+            # If the mapper is empty the expected index type is Int64Index
+            # but the output defaults to Float64 so I treat it independently
             if mapper:
                 tm.assert_index_equal(expected, cur_index.map(mapper))
             else:
-                # The expected index type is Int64Index
-                # but the output defaults to Float64
                 tm.assert_index_equal(Float64Index([]),
                                       cur_index.map(mapper))
 
-    def test_map_with_categorical_series(self):
-        # GH 12756
-        a = Index([1, 2, 3, 4])
-        b = Series(["even", "odd", "even", "odd"],
-                   dtype="category")
-        c = Series(["even", "odd", "even", "odd"])
-
-        exp = CategoricalIndex(["odd", "even", "odd", np.nan])
-        tm.assert_index_equal(a.map(b), exp)
-        exp = Index(["odd", "even", "odd", np.nan])
-        tm.assert_index_equal(a.map(c), exp)
-
     def test_map_with_non_function_missing_values(self):
         # GH 12756
         expected = Index([2., np.nan, 'foo'])

Diff for: pandas/tests/indexes/test_category.py

@@ -239,6 +239,18 @@ def f(x):
         result = ci.map({'A': 10, 'B': 20, 'C': 30})
         tm.assert_index_equal(result, exp)
 
+    def test_map_with_categorical_series(self):
+        # GH 12756
+        a = pd.Index([1, 2, 3, 4])
+        b = pd.Series(["even", "odd", "even", "odd"],
+                      dtype="category")
+        c = pd.Series(["even", "odd", "even", "odd"])
+
+        exp = CategoricalIndex(["odd", "even", "odd", np.nan])
+        tm.assert_index_equal(a.map(b), exp)
+        exp = pd.Index(["odd", "even", "odd", np.nan])
+        tm.assert_index_equal(a.map(c), exp)
+
     def test_where(self):
         i = self.create_index()
         result = i.where(notnull(i))

Diff for: pandas/tests/indexes/test_datetimelike.py

@@ -52,6 +52,42 @@ def test_view(self):
         result = self._holder(i)
         tm.assert_index_equal(result, i_view)
 
+    def test_map(self):
+        # GH 12756
+        idx = self.create_index()
+        idx.name = 'foo'
+        result = idx.map(lambda x: x + 1)
+        expected = idx + 1
+        tm.assert_index_equal(result, expected)
+
+        series_map = pd.Series(expected, idx)
+        result = idx.map(series_map)
+        tm.assert_index_equal(result, expected)
+
+        dict_map = {i: e for e, i in zip(expected, idx)}
+        result = idx.map(dict_map)
+        tm.assert_index_equal(result, expected)
+
+        # All empty maps to Float64Index
+        empty_idx = Float64Index([np.nan for _ in range(len(idx))], name='foo')
+        result = idx.map(pd.Series())
+        tm.assert_index_equal(result, empty_idx)
+        result = idx.map({})
+        tm.assert_index_equal(result, empty_idx)
+
+        nat_expected = Index([pd.NaT] + [e for e in expected[1:]], name='foo')
+        old_value = expected[0]
+
+        series_map.iloc[0] = pd.NaT
+        series_map = pd.Series(old_value, [pd.NaT]).append(series_map)
+        result = idx.map(series_map)
+        tm.assert_index_equal(result, nat_expected)
+
+        dict_map.update({pd.NaT: old_value})
+        dict_map[idx[0]] = pd.NaT
+        result = idx.map(dict_map)
+        tm.assert_index_equal(result, nat_expected)
+
 
 class TestDatetimeIndex(DatetimeLike, tm.TestCase):
     _holder = DatetimeIndex

Diff for: pandas/tests/indexing/test_categorical.py

@@ -405,3 +405,21 @@ def test_indexing_with_category(self):
 
         res = (cat[['A']] == 'foo')
         tm.assert_frame_equal(res, exp)
+
+    def test_map_with_dict_or_series(self):
+        orig_values = ['a', 'B', 1, 'a']
+        new_values = ['one', 2, 3.0, 'one']
+        cur_index = pd.CategoricalIndex(orig_values, name='XXX')
+        expected = pd.CategoricalIndex(new_values,
+                                       name='XXX', categories=[3.0, 2, 'one'])
+
+        mapper = pd.Series(new_values[:-1], index=orig_values[:-1])
+        output = cur_index.map(mapper)
+        # Order of categories in output can be different
+        tm.assert_index_equal(expected, output)
+
+        mapper = {o: n for o, n in
+                  zip(orig_values[:-1], new_values[:-1])}
+        output = cur_index.map(mapper)
+        # Order of categories in output can be different
+        tm.assert_index_equal(expected, output)

Diff for: pandas/tseries/base.py

@@ -685,6 +685,14 @@ def __rsub__(self, other):
     def _add_delta(self, other):
         return NotImplemented
 
+    @Appender(_index_shared_docs['_get_values_from_dict'])
+    def _get_values_from_dict(self, data):
+        if len(data):
+            return np.array([data.get(i, np.nan)
+                             for i in self.asobject.values])
+
+        return np.array([np.nan])
+
     def _add_delta_td(self, other):
         # add a delta of a timedeltalike
         # return the i8 result view

Diff for: pandas/tseries/index.py

@@ -1380,29 +1380,16 @@ def get_value_maybe_box(self, series, key):
                                         key, tz=self.tz)
         return _maybe_box(self, values, series, key)
 
-    def get_values_from_dict(self, input_dict):
-        """Return the values of the input dictionary in the order the keys are
-        in the index. np.nan is returned for index values not in the
-        dictionary.
-
-        Parameters
-        ----------
-        input_dict : dict
-            The dictionary from which to extract the values
-
-        Returns
-        -------
-        Union[np.array, list]
-
-        """
-        if len(input_dict):
+    @Appender(_index_shared_docs['_get_values_from_dict'])
+    def _get_values_from_dict(self, data):
+        if len(data):
             # coerce back to datetime objects for lookup
-            input_dict = com._dict_compat(input_dict)
-            return lib.fast_multiget(input_dict,
+            data = com._dict_compat(data)
+            return lib.fast_multiget(data,
                                      self.asobject.values,
                                      default=np.nan)
-        else:
-            return np.nan
+
+        return np.array([np.nan])
 
     def get_loc(self, key, method=None, tolerance=None):
         """

Diff for: pandas/tseries/period.py

@@ -783,25 +783,6 @@ def _get_unique_index(self, dropna=False):
             res = res.dropna()
         return res
 
-    def get_values_from_dict(self, input_dict):
-        """Return the values of the input dictionary in the order the keys are
-        in the index. np.nan is returned for index values not in the
-        dictionary.
-
-        Parameters
-        ----------
-        input_dict : dict
-            The dictionary from which to extract the values
-
-        Returns
-        -------
-        Union[np.array, list]
-
-        """
-
-        return np.array([input_dict.get(i, np.nan) for i in self.values]
-                        if input_dict else [np.nan])
-
     def get_loc(self, key, method=None, tolerance=None):
         """
         Get integer location for requested label

Diff for: pandas/tseries/tdi.py

@@ -665,26 +665,6 @@ def get_value_maybe_box(self, series, key):
         values = self._engine.get_value(_values_from_object(series), key)
         return _maybe_box(self, values, series, key)
 
-    def get_values_from_dict(self, input_dict):
-        """Return the values of the input dictionary in the order the keys are
-        in the index. np.nan is returned for index values not in the
-        dictionary.
-
-        Parameters
-        ----------
-        input_dict : dict
-            The dictionary from which to extract the values
-
-        Returns
-        -------
-        Union[np.array, list]
-
-        """
-
-        return np.array([input_dict.get(i, np.nan)
-                         for i in self.asobject.values]
-                        if input_dict else [np.nan])
-
     def get_loc(self, key, method=None, tolerance=None):
         """
         Get integer location for requested label