ENH: 'replaced' series.replace with generic.replace !

Author: jreback

pandas/core/generic.py

@@ -1619,8 +1619,11 @@ def is_dictlike(x):
             return self.replace(to_replace, value, inplace=inplace,
                                 limit=limit, regex=regex)
         else:
-            if not len(self.columns):
-                return self
+
+            # need a non-zero len on all axes
+            for a in self._AXIS_ORDERS:
+                if not len(self._get_axis(a)):
+                    return self
 
             new_data = self._data
             if is_dictlike(to_replace):

pandas/core/series.py

@@ -2594,108 +2594,6 @@ def apply(self, func, convert_dtype=True, args=(), **kwds):
         else:
             return self._constructor(mapped, index=self.index, name=self.name)
 
-    def replace(self, to_replace, value=None, method='pad', inplace=False,
-                limit=None):
-        """
-        Replace arbitrary values in a Series
-
-        Parameters
-        ----------
-        to_replace : list or dict
-            list of values to be replaced or dict of replacement values
-        value : anything
-            if to_replace is a list then value is the replacement value
-        method : {'backfill', 'bfill', 'pad', 'ffill', None}, default 'pad'
-            Method to use for filling holes in reindexed Series
-            pad / ffill: propagate last valid observation forward to next valid
-            backfill / bfill: use NEXT valid observation to fill gap
-        inplace : boolean, default False
-            If True, fill the Series in place. Note: this will modify any other
-            views on this Series, for example a column in a DataFrame. Returns
-            a reference to the filled object, which is self if inplace=True
-        limit : int, default None
-            Maximum size gap to forward or backward fill
-
-        Notes
-        -----
-        replace does not distinguish between NaN and None
-
-        See also
-        --------
-        fillna, reindex, asfreq
-
-        Returns
-        -------
-        replaced : Series
-        """
-
-        if inplace:
-            result = self
-            change = self
-        else:
-            result = self.copy()
-            change = None
-
-        def _rep_one(s, to_rep, v):  # replace single value
-            mask = com.mask_missing(s.values, to_rep)
-            com._maybe_upcast_putmask(s.values, mask, v, change=change)
-
-        def _rep_dict(rs, to_rep):  # replace {[src] -> dest}
-
-            all_src = set()
-            dd = {}  # group by unique destination value
-            for s, d in to_rep.iteritems():
-                dd.setdefault(d, []).append(s)
-                all_src.add(s)
-
-            if any(d in all_src for d in dd.keys()):
-                # don't clobber each other at the cost of temporaries
-                masks = {}
-                for d, sset in dd.iteritems():  # now replace by each dest
-                    masks[d] = com.mask_missing(rs.values, sset)
-
-                for d, m in masks.iteritems():
-                    com._maybe_upcast_putmask(rs.values, m, d, change=change)
-            else:  # if no risk of clobbering then simple
-                for d, sset in dd.iteritems():
-                    _rep_one(rs, sset, d)
-
-        if np.isscalar(to_replace):
-            to_replace = [to_replace]
-
-        if isinstance(to_replace, dict):
-            _rep_dict(result, to_replace)
-        elif isinstance(to_replace, (list, pa.Array, Series)):
-
-            # check same length
-            if isinstance(value, (list, pa.Array, Series)):
-                vl, rl = len(value), len(to_replace)
-                if vl == rl:
-                    _rep_dict(result, dict(zip(to_replace, value)))
-                else:
-                    raise ValueError('Got %d to replace but %d values'
-                                     % (rl, vl))
-
-            elif value is not None:  # otherwise all replaced with same value
-                _rep_one(result, to_replace, value)
-            else:  # method
-                if method is None:  # pragma: no cover
-                    raise ValueError('must specify a fill method')
-                fill_f = _get_fill_func(method)
-
-                mask = com.mask_missing(result.values, to_replace)
-                fill_f(result.values, limit=limit, mask=mask)
-
-                if not inplace:
-                    result = Series(result.values, index=self.index,
-                                    name=self.name)
-        else:
-            raise ValueError('Unrecognized to_replace type %s' %
-                             type(to_replace))
-
-        if not inplace:
-            return result
-
     def align(self, other, join='outer', level=None, copy=True,
               fill_value=None, method=None, limit=None):
         """

pandas/tests/test_series.py

@@ -4085,16 +4085,6 @@ def test_replace(self):
         rs2 = ser.replace([np.nan, 'foo', 'bar'], [-1, -2, -3])
         assert_series_equal(rs, rs2)
 
-        # replace with forward fill not considering np.nan missing
-        s2 = ser.copy()
-        s2[5] = np.nan
-        rs3 = s2.replace(['foo', 'bar'])
-        self.assert_(isnull(rs3[6]))
-
-        # replace with back fill considering np.nan as missing
-        rs4 = ser.replace([np.nan, 'foo', 'bar'], method='bfill')
-        assert_almost_equal(rs4[4], ser[5])
-
         # replace inplace
         ser.replace([np.nan, 'foo', 'bar'], -1, inplace=True)
 
@@ -4116,7 +4106,7 @@ def test_replace(self):
 
         # malformed
         self.assertRaises(ValueError, ser.replace, [1, 2, 3], [np.nan, 0])
-        self.assertRaises(ValueError, ser.replace, xrange(1, 3), [np.nan, 0])
+        self.assertRaises(TypeError, ser.replace, xrange(1, 3), [np.nan, 0])
 
         ser = Series([0, 1, 2, 3, 4])
         result = ser.replace([0, 1, 2, 3, 4], [4, 3, 2, 1, 0])
@@ -4433,16 +4423,6 @@ def test_replace(self):
         rs2 = ser.replace([np.nan, 'foo', 'bar'], [-1, -2, -3])
         assert_series_equal(rs, rs2)
 
-        # replace with forward fill not considering np.nan missing
-        s2 = ser.copy()
-        s2[5] = np.nan
-        rs3 = s2.replace(['foo', 'bar'])
-        self.assert_(isnull(rs3[6]))
-
-        # replace with back fill considering np.nan as missing
-        rs4 = ser.replace([np.nan, 'foo', 'bar'], method='bfill')
-        assert_almost_equal(rs4[4], ser[5])
-
         # replace inplace
         ser.replace([np.nan, 'foo', 'bar'], -1, inplace=True)
         self.assert_((ser[:5] == -1).all())