removed bottleneck calls from replace

Author: Chang She

pandas/core/common.py

@@ -97,6 +97,37 @@ def notnull(obj):
         return not res
     return -res
 
+def mask_missing(arr, values_to_mask):
+    """
+    Return a masking array of same size/shape as arr
+    with entries equaling any member of values_to_mask set to True
+    """
+    if np.isscalar(values_to_mask):
+        values_to_mask = [values_to_mask]
+
+    try:
+        values_to_mask = np.array(values_to_mask, dtype=arr.dtype)
+    except Exception:
+        values_to_mask = np.array(values_to_mask, dtype=object)
+
+    na_mask = isnull(values_to_mask)
+    nonna = values_to_mask[-na_mask]
+
+    mask = None
+    for x in nonna:
+        if mask is None:
+            mask = arr == x
+        else:
+            mask = mask | (arr == x)
+
+    if na_mask.any():
+        if mask is None:
+            mask = isnull(arr)
+        else:
+            mask = mask | isnull(arr)
+
+    return mask
+
 def _pickle_array(arr):
     arr = arr.view(np.ndarray)
 

pandas/core/frame.py

@@ -2649,44 +2649,14 @@ def replace(self, to_replace, value=None, method='pad', axis=0,
         self._consolidate_inplace()
 
         if value is None:
-            if self._is_mixed_type and axis == 1:
-                return self.T.replace(to_replace, method=method, limit=limit).T
-
-            method = com._clean_fill_method(method)
-
-            if isinstance(to_replace, dict):
-                if axis == 1:
-                    return self.T.replace(to_replace, method=method,
-                                          limit=limit).T
-
-                rs = self if inplace else self.copy()
-                for k, v in to_replace.iteritems():
-                    if k in rs:
-                        rs[k].replace(v, method=method, limit=limit,
-                                      inplace=True)
-                return rs
-
-            else:
-                new_blocks = []
-                for block in self._data.blocks:
-                    newb = block.interpolate(method, axis=axis,
-                                             limit=limit, inplace=inplace,
-                                             missing=to_replace)
-                    new_blocks.append(newb)
-                new_data = BlockManager(new_blocks, self._data.axes)
-
-                if inplace:
-                    self._data = new_data
-                    return self
-                else:
-                    return self._constructor(new_data)
-
+            return self._interpolate(to_replace, method, axis, inplace, limit)
         else:
             # Float type values
             if len(self.columns) == 0:
                 return self
 
             if np.isscalar(to_replace):
+
                 if np.isscalar(value): # np.nan -> 0
                     new_data = self._data.replace(to_replace, value,
                                                   inplace=inplace)
@@ -2699,14 +2669,17 @@ def replace(self, to_replace, value=None, method='pad', axis=0,
                 elif isinstance(value, dict): # np.nan -> {'A' : 0, 'B' : -1}
                     return self._replace_dest_dict(to_replace, value, inplace)
 
+
             elif isinstance(to_replace, dict):
+
                 if np.isscalar(value): # {'A' : np.nan, 'B' : ''} -> 0
                     return self._replace_src_dict(to_replace, value, inplace)
+
                 elif isinstance(value, dict): # {'A' : np.nan} -> {'A' : 0}
                     return self._replace_both_dict(to_replace, value, inplace)
-                else:
-                    raise ValueError('Fill value must be scalar or dict')
-                return rs
+
+                raise ValueError('Fill value must be scalar or dict')
+
 
             elif isinstance(to_replace, (list, np.ndarray)):
                 # [np.nan, ''] -> [0, 'missing']
@@ -2723,14 +2696,48 @@ def replace(self, to_replace, value=None, method='pad', axis=0,
                 else: # [np.nan, ''] -> 0
                     new_data = self._data.replace(to_replace, value,
                                                   inplace=inplace)
+
                 if inplace:
                     self._data = new_data
                     return self
                 else:
                     return self._constructor(new_data)
+
+            raise ValueError('Invalid to_replace type: %s' % type(to_replace))
+
+    def _interpolate(self, to_replace, method, axis, inplace, limit):
+        if self._is_mixed_type and axis == 1:
+            return self.T.replace(to_replace, method=method, limit=limit).T
+
+        method = com._clean_fill_method(method)
+
+        if isinstance(to_replace, dict):
+            if axis == 1:
+                return self.T.replace(to_replace, method=method,
+                                      limit=limit).T
+
+            rs = self if inplace else self.copy()
+            for k, v in to_replace.iteritems():
+                if k in rs:
+                    rs[k].replace(v, method=method, limit=limit,
+                                  inplace=True)
+            return rs
+
+        else:
+            new_blocks = []
+            for block in self._data.blocks:
+                newb = block.interpolate(method, axis=axis,
+                                         limit=limit, inplace=inplace,
+                                         missing=to_replace)
+                new_blocks.append(newb)
+            new_data = BlockManager(new_blocks, self._data.axes)
+
+            if inplace:
+                self._data = new_data
+                return self
             else:
-                raise ValueError('Invalid to_replace type: %s' %
-                                 type(to_replace))
+                return self._constructor(new_data)
+
 
     def _replace_dest_dict(self, to_replace, value, inplace):
         rs = self if inplace else self.copy()

pandas/core/internals.py

@@ -232,17 +232,21 @@ def replace(self, to_replace, value, inplace=False):
         if np.isscalar(to_replace):
             if self._can_hold_element(to_replace):
                 to_replace = self._try_cast(to_replace)
-                lib.replace(new_values, to_replace, value)
+                np.putmask(new_values, com.mask_missing(new_values, to_replace),
+                           value)
         else:
             try:
                 to_replace = np.array(to_replace, dtype=self.dtype)
-                lib.replace(new_values, to_replace, value)
+                np.putmask(new_values, com.mask_missing(new_values, to_replace),
+                           value)
             except:
                 to_replace = np.array(to_replace, dtype=object)
                 for r in to_replace:
                     if self._can_hold_element(r):
                         r = self._try_cast(r)
-                        lib.replace(new_values, r, value)
+                np.putmask(new_values, com.mask_missing(new_values, to_replace),
+                           value)
+
         if inplace:
             return self
         else:

pandas/core/nanops.py

@@ -412,4 +412,3 @@ def unique1d(values):
         uniques = table.unique(com._ensure_object(values))
         uniques = lib.list_to_object_array(uniques)
     return uniques
-

pandas/core/series.py

@@ -2131,10 +2131,8 @@ def replace(self, to_replace, value=None, method='pad', inplace=False,
         result = self.copy() if not inplace else self
 
         def _rep_one(s, to_rep, v): # replace single value
-            if isinstance(to_rep, (list, np.ndarray)):
-                to_rep = lib.maybe_convert_objects(np.array(to_rep,
-                                                            dtype=object))
-            lib.replace(s.values, to_rep, v)
+            mask = com.mask_missing(s.values, to_rep)
+            np.putmask(s.values, mask, v)
             return s
 
         def _rep_dict(rs, to_rep): # replace {[src] -> dest}