rebased

Author: topper-123

pandas/core/arrays/categorical.py

@@ -1377,13 +1377,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

@@ -1473,9 +1473,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

@@ -76,35 +76,30 @@ 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)