rebased

Author: topper-123

pandas/core/arrays/categorical.py

@@ -1375,13 +1375,14 @@ def memory_usage(self, deep=False):
     @Appender(_shared_docs['searchsorted'])
     def searchsorted(self, value, side='left', sorter=None):
         from pandas.core.series import Series
-        codes = _get_codes_for_values(Series(value).values, self.categories)
-        if -1 in codes:
+        value_codes = _get_codes_for_values(Series(value).values,
+                                            self.categories)
+        if -1 in value_codes:
             raise KeyError("Value(s) to be inserted must be in categories.")
+        value_codes = value_codes[0] if is_scalar(value) else value_codes
 
-        codes = codes[0] if is_scalar(value) else codes
-
-        return self.codes.searchsorted(codes, side=side, sorter=sorter)
+        return algorithms.searchsorted(self._codes, value_codes,
+                                       side=side, sorter=sorter)
 
     def isna(self):
         """

pandas/core/base.py

@@ -1463,9 +1463,6 @@ def factorize(self, sort=False, na_sentinel=-1):
             wrong locations will likely be returned. Pandas does *not*
             check this for you.
 
-            You can check sortedness by calling
-            :meth:`%(klass)s.is_monotonic_increasing`.
-
         Parameters
         ----------
         value : array_like

pandas/tests/arrays/categorical/test_analytics.py

@@ -75,50 +75,45 @@ def test_searchsorted(self, ordered):
         # https://github.com/pandas-dev/pandas/issues/8420
         # https://github.com/pandas-dev/pandas/issues/14522
 
-        c = Categorical(['cheese', 'milk', 'apple', 'bread', 'bread'],
-                        categories=['cheese', 'milk', 'apple', 'bread'],
-                        ordered=ordered)
-        s = Series(c)
+        cat = Categorical(['cheese', 'milk', 'apple', 'bread', 'bread'],
+                          categories=['cheese', 'milk', 'apple', 'bread'],
+                          ordered=ordered)
+        ser = Series(cat)
 
         # Searching for single item argument, side='left' (default)
-        res_cat = c.searchsorted('apple')
+        res_cat = cat.searchsorted('apple')
         assert res_cat == 2
         assert is_scalar(res_cat)
 
-        res_ser = s.searchsorted('apple')
+        res_ser = ser.searchsorted('apple')
         assert res_ser == 2
         assert is_scalar(res_ser)
 
-        res_cat = c.searchsorted('apple')
-        res_ser = s.searchsorted('apple')
-        assert res_cat == 2
-        assert res_ser == 2
-
         # Searching for single item array, side='left' (default)
-        res_cat = c.searchsorted(['bread'])
-        res_ser = s.searchsorted(['bread'])
+        res_cat = cat.searchsorted(['bread'])
+        res_ser = ser.searchsorted(['bread'])
         exp = np.array([3], dtype=np.intp)
         tm.assert_numpy_array_equal(res_cat, exp)
         tm.assert_numpy_array_equal(res_ser, exp)
 
         # Searching for several items array, side='right'
-        res_cat = c.searchsorted(['apple', 'bread'], side='right')
-        res_ser = s.searchsorted(['apple', 'bread'], side='right')
+        res_cat = cat.searchsorted(['apple', 'bread'], side='right')
+        res_ser = ser.searchsorted(['apple', 'bread'], side='right')
         exp = np.array([3, 5], dtype=np.intp)
         tm.assert_numpy_array_equal(res_cat, exp)
         tm.assert_numpy_array_equal(res_ser, exp)
 
         # Searching for a single value that is not from the Categorical
         with pytest.raises(KeyError):
-            c.searchsorted('cucumber')
+            cat.searchsorted('cucumber')
         with pytest.raises(KeyError):
-            s.searchsorted('cucumber')
+            ser.searchsorted('cucumber')
 
         # Searching for multiple values one of each is not from the Categorical
         with pytest.raises(KeyError):
-            c.searchsorted(['bread', 'cucumber'])
+            cat.searchsorted(['bread', 'cucumber'])
         with pytest.raises(KeyError):
-            s.searchsorted(['bread', 'cucumber'])
+            ser.searchsorted(['bread', 'cucumber'])
 
     def test_unique(self):
         # categories are reordered based on value when ordered=False