Merge branch 'BUG-allow-map-with-abc-mapping' of https://github.com/ohad83/pandas into ohad83-BUG-allow-map-with-abc-mapping

Author: jreback

doc/source/whatsnew/v1.0.0.rst

@@ -216,13 +216,15 @@ Other enhancements
   (:meth:`~DataFrame.to_parquet` / :func:`read_parquet`) using the `'pyarrow'` engine
   now preserve those data types with pyarrow >= 1.0.0 (:issue:`20612`).
 - The ``partition_cols`` argument in :meth:`DataFrame.to_parquet` now accepts a string (:issue:`27117`)
+<<<<<<< HEAD
 - The ``pandas.np`` submodule is now deprecated. Import numpy directly instead (:issue:`30296`)
 - :func:`to_parquet` now appropriately handles the ``schema`` argument for user defined schemas in the pyarrow engine. (:issue: `30270`)
 - DataFrame constructor preserve `ExtensionArray` dtype with `ExtensionArray` (:issue:`11363`)
 - :meth:`DataFrame.sort_values` and :meth:`Series.sort_values` have gained ``ignore_index`` keyword to be able to reset index after sorting (:issue:`30114`)
 - :meth:`DataFrame.to_markdown` and :meth:`Series.to_markdown` added (:issue:`11052`)
 - :meth:`DataFrame.drop_duplicates` has gained ``ignore_index`` keyword to reset index (:issue:`30114`)
 - Added new writer for exporting Stata dta files in version 118, ``StataWriter118``.  This format supports exporting strings containing Unicode characters (:issue:`23573`)
+- :meth:`Series.map` now accepts ``collections.abc.Mapping`` subclasses as a mapper (:issue:`29733`)
 
 Build Changes
 ^^^^^^^^^^^^^

pandas/core/base.py

@@ -19,6 +19,7 @@
     is_categorical_dtype,
     is_datetime64_ns_dtype,
     is_datetime64tz_dtype,
+    is_dict_like,
     is_extension_array_dtype,
     is_list_like,
     is_object_dtype,
@@ -1107,8 +1108,8 @@ def _map_values(self, mapper, na_action=None):
         # we can fastpath dict/Series to an efficient map
         # as we know that we are not going to have to yield
         # python types
-        if isinstance(mapper, dict):
-            if hasattr(mapper, "__missing__"):
+        if is_dict_like(mapper):
+            if isinstance(mapper, dict) and hasattr(mapper, "__missing__"):
                 # If a dictionary subclass defines a default value method,
                 # convert mapper to a lookup function (GH #15999).
                 dict_with_default = mapper

pandas/core/series.py

@@ -182,6 +182,7 @@ class Series(base.IndexOpsMixin, generic.NDFrame):
     def __init__(
         self, data=None, index=None, dtype=None, name=None, copy=False, fastpath=False
     ):
+
         # we are called internally, so short-circuit
         if fastpath:
 
@@ -250,7 +251,7 @@ def __init__(
                 else:
                     data = data.reindex(index, copy=copy)
                 data = data._data
-            elif isinstance(data, dict):
+            elif is_dict_like(data):
                 data, index = self._init_dict(data, index, dtype)
                 dtype = None
                 copy = False
@@ -3513,7 +3514,7 @@ def map(self, arg, na_action=None):
 
         Parameters
         ----------
-        arg : function, dict, or Series
+        arg : function, collections.abc.Mapping subclass or Series
             Mapping correspondence.
         na_action : {None, 'ignore'}, default None
             If 'ignore', propagate NaN values, without passing them to the

pandas/tests/series/test_apply.py

@@ -627,6 +627,30 @@ class DictWithoutMissing(dict):
         expected = Series([np.nan, np.nan, "three"])
         tm.assert_series_equal(result, expected)
 
+    def test_map_abc_mapping(self):
+        # https://github.com/pandas-dev/pandas/issues/29733
+        # Check collections.abc.Mapping support as mapper for Series.map
+        s = Series([1, 2, 3])
+        not_a_dictionary = tm.TestNonDictMapping({3: "three"})
+        result = s.map(not_a_dictionary)
+        expected = Series([np.nan, np.nan, "three"])
+        tm.assert_series_equal(result, expected)
+
+    def test_map_abc_mapping_with_missing(self):
+        # https://github.com/pandas-dev/pandas/issues/29733
+        # Check collections.abc.Mapping support as mapper for Series.map
+        class NonDictMappingWithMissing(tm.TestNonDictMapping):
+            def __missing__(self, key):
+                return "missing"
+
+        s = Series([1, 2, 3])
+        not_a_dictionary = NonDictMappingWithMissing({3: "three"})
+        result = s.map(not_a_dictionary)
+        # __missing__ is a dict concept, not a Mapping concept,
+        # so it should not change the result!
+        expected = Series([np.nan, np.nan, "three"])
+        tm.assert_series_equal(result, expected)
+
     def test_map_box(self):
         vals = [pd.Timestamp("2011-01-01"), pd.Timestamp("2011-01-02")]
         s = pd.Series(vals)

pandas/tests/series/test_constructors.py

@@ -1089,6 +1089,14 @@ def create_data(constructor):
         tm.assert_series_equal(result_datetime, expected)
         tm.assert_series_equal(result_Timestamp, expected)
 
+    def test_constructor_mapping(self):
+        # GH 29788
+        ndm = tm.TestNonDictMapping({3: "three"})
+        result = Series(ndm)
+        expected = Series(["three"], index=[3])
+
+        tm.assert_series_equal(result, expected)
+
     def test_constructor_list_of_tuples(self):
         data = [(1, 1), (2, 2), (2, 3)]
         s = Series(data)

pandas/util/testing.py

@@ -1,5 +1,5 @@
 import bz2
-from collections import Counter
+from collections import Counter, abc
 from contextlib import contextmanager
 from datetime import datetime
 from functools import wraps
@@ -2128,6 +2128,20 @@ def __init__(self, *args, **kwargs):
         dict.__init__(self, *args, **kwargs)
 
 
+class TestNonDictMapping(abc.Mapping):
+    def __init__(self, underlying_dict):
+        self._data = underlying_dict
+
+    def __getitem__(self, key):
+        return self._data.__getitem__(key)
+
+    def __iter__(self):
+        return self._data.__iter__()
+
+    def __len__(self):
+        return self._data.__len__()
+
+
 def optional_args(decorator):
     """allows a decorator to take optional positional and keyword arguments.
     Assumes that taking a single, callable, positional argument means that