Address PR comments

Author: fjetter

doc/source/whatsnew/v0.23.0.txt

@@ -1289,9 +1289,6 @@ Indexing
 - Bug in performing in-place operations on a ``DataFrame`` with a duplicate ``Index`` (:issue:`17105`)
 - Bug in :meth:`IntervalIndex.get_loc` and :meth:`IntervalIndex.get_indexer` when used with an :class:`IntervalIndex` containing a single interval (:issue:`17284`, :issue:`20921`)
 - Bug in ``.loc`` with a ``uint64`` indexer (:issue:`20722`)
-- Bug in :func:`CategoricalIndex.searchsorted` where the method did not return a scalar when the input values was scalar (:issue:`21019`)
-- Bug in :class:`CategoricalIndex` where slicing beyond the range of the data raised a KeyError (:issue:`21019`)
-
 
 MultiIndex
 ^^^^^^^^^^

doc/source/whatsnew/v0.23.1.txt

@@ -89,8 +89,7 @@ Indexing
 - Bug in :class:`IntervalIndex` constructors where creating an ``IntervalIndex`` from categorical data was not fully supported (:issue:`21243`, issue:`21253`)
 - Bug in :meth:`MultiIndex.sort_index` which was not guaranteed to sort correctly with ``level=1``; this was also causing data misalignment in particular :meth:`DataFrame.stack` operations (:issue:`20994`, :issue:`20945`, :issue:`21052`)
 - Bug in :func:`CategoricalIndex.searchsorted` where the method did not return a scalar when the input values was scalar (:issue:`21019`)
-- Bug in :class:`CategoricalIndex` where slicing beyond the range of the data raised a KeyError (:issue:`21019`)
--
+- Bug in :class:`CategoricalIndex` where slicing beyond the range of the data raised a ``KeyError`` (:issue:`21019`)
 
 I/O
 ^^^

pandas/tests/indexing/test_categorical.py

@@ -627,38 +627,29 @@ def test_reindexing(self):
                       lambda: self.df2.reindex(['a'], limit=2))
 
     def test_loc_slice(self):
-        # Raises KeyError since the left slice 'a' is not unique
-        pytest.raises(KeyError, lambda: self.df.loc["a":"b"])
-        result = self.df.loc["b":"c"]
-
-        expected = DataFrame(
-            {"A": [2, 3, 4]},
-            index=CategoricalIndex(
-                ["b", "b", "c"], name="B", categories=list("cab")
-            ),
+        df = DataFrame(
+            {"A": range(0, 6)},
+            index=CategoricalIndex(list("aabcde"), name="B"),
         )
 
+        # slice on an unordered categorical using in-sample, connected edges
+        result = df.loc["b":"d"]
+        expected = df.iloc[2:5]
         assert_frame_equal(result, expected)
 
-        ordered_df = DataFrame(
-            {"A": range(0, 6)},
-            index=CategoricalIndex(list("aabcde"), name="B", ordered=True),
-        )
-
-        # This should select the entire dataframe
-        result = ordered_df.loc["a":"e"]
-        assert_frame_equal(result, ordered_df)
-        result_iloc = ordered_df.iloc[0:6]
+        # Slice the entire dataframe
+        result = df.loc["a":"e"]
+        assert_frame_equal(result, df)
+        result_iloc = df.iloc[0:6]
         assert_frame_equal(result_iloc, result)
 
-        result = ordered_df.loc["a":"b"]
-        expected = DataFrame(
-            {"A": range(0, 3)},
-            index=CategoricalIndex(
-                list("aab"), categories=list("abcde"), name="B", ordered=True
-            ),
-        )
-        assert_frame_equal(result, expected)
+        # check if the result is identical to an ordinary index
+        df_non_cat_index = df.copy()
+        df_non_cat_index.index = df_non_cat_index.index.astype(str)
+        result = df.loc["a":"e"]
+        result_non_cat = df_non_cat_index.loc["a": "e"]
+        result.index = result.index.astype(str)
+        assert_frame_equal(result_non_cat, result)
 
     @pytest.mark.parametrize(
         "content",
@@ -669,6 +660,8 @@ def test_loc_beyond_edge_slicing(self, content):
         """
         This test ensures that no `KeyError` is raised if trying to slice
         beyond the edges of known, ordered categories.
+
+        see GH21019
         """
         # This dataframe might be a slice of a larger categorical
         # (i.e. more categories are known than there are in the column)
@@ -701,6 +694,14 @@ def test_loc_beyond_edge_slicing(self, content):
             # If the category is not known, there is nothing we can do
             ordered_df.loc["a":"z"]
 
+        unordered_df = ordered_df.copy()
+        unordered_df.index = unordered_df.index.as_unordered()
+        with pytest.raises(KeyError):
+            # This operation previously succeeded for an ordered index. Since
+            # this index is no longer ordered, we cannot perfom out of range
+            # slicing / searchsorted
+            unordered_df.loc["a": "d"]
+
     def test_boolean_selection(self):
 
         df3 = self.df3