BUG: fix KeyError with list of a single, missing, element

closes #27148

Author: toobaz

doc/source/whatsnew/v0.25.0.rst

@@ -768,6 +768,7 @@ Indexing
 - Bug in which :meth:`DataFrame.to_csv` caused a segfault for a reindexed data frame, when the indices were single-level :class:`MultiIndex` (:issue:`26303`).
 - Fixed bug where assigning a :class:`arrays.PandasArray` to a :class:`pandas.core.frame.DataFrame` would raise error (:issue:`26390`)
 - Allow keyword arguments for callable local reference used in the :meth:`DataFrame.query` string (:issue:`26426`)
+- Fixed a ``KeyError`` when indexing a :class:`MultiIndex`` level with a list containing exactly one label, which is missing (:issue:`16396`)
 
 
 Missing

pandas/core/indexing.py

@@ -1818,7 +1818,7 @@ def _getitem_axis(self, key, axis=None):
                                               "multidimensional key is not "
                                               "implemented")
 
-                if (not isinstance(key, tuple) and len(key) > 1 and
+                if (not isinstance(key, tuple) and len(key) > 0 and
                         not isinstance(key[0], tuple)):
                     key = tuple([key])
 

pandas/tests/indexing/multiindex/test_loc.py

@@ -123,6 +123,17 @@ def test_loc_multiindex_missing_label_raises(self):
         with pytest.raises(KeyError, match=r"^2$"):
             df.loc[2]
 
+        # Lists with missing labels do not raise:
+        expected = df.iloc[[0, 1]]
+        result = df.loc[[2, 4]]
+        tm.assert_frame_equal(result, expected)
+
+        # ... even when none is found:
+        expected = df.iloc[[]]
+        for l in [2], [2, 3]:  # GH 27148
+            result = df.loc[[2]]
+            tm.assert_frame_equal(result, expected)
+
     def test_loc_multiindex_too_many_dims_raises(self):
         # GH 14885
         s = Series(range(8), index=MultiIndex.from_product(
@@ -264,15 +275,16 @@ def convert_nested_indexer(indexer_type, keys):
         tm.assert_series_equal(result, expected)
 
 
-@pytest.mark.parametrize('indexer, is_level1, expected_error', [
-    ([], False, None),  # empty ok
-    (['A'], False, None),
-    (['A', 'D'], False, None),
-    (['D'], False, r"\['D'\] not in index"),  # not any values found
-    (pd.IndexSlice[:, ['foo']], True, None),
-    (pd.IndexSlice[:, ['foo', 'bah']], True, None)
+@pytest.mark.parametrize('indexer, level, expected_error', [
+    ([], 0, None),  # empty ok
+    (['A'], 0, None),
+    (['A', 'D'], 0, None),
+    (['D', 'E'], -1, None),  # no values found - fine
+    (['D'], -1, None),  # same, with single item list: GH 27148
+    (pd.IndexSlice[:, ['foo']], 1, None),
+    (pd.IndexSlice[:, ['foo', 'bah']], 1, None)
 ])
-def test_loc_getitem_duplicates_multiindex_missing_indexers(indexer, is_level1,
+def test_loc_getitem_duplicates_multiindex_missing_indexers(indexer, level,
                                                             expected_error):
     # GH 7866
     # multi-index slicing with missing indexers
@@ -283,9 +295,12 @@ def test_loc_getitem_duplicates_multiindex_missing_indexers(indexer, is_level1,
 
     if indexer == []:
         expected = s.iloc[[]]
-    elif is_level1:
+    elif level == 1:
         expected = Series([0, 3, 6], index=MultiIndex.from_product(
             [['A', 'B', 'C'], ['foo']], names=['one', 'two'])).sort_index()
+    elif level == -1:
+        # Empty: use idx[:0] as index to have appropriate (hidden) labels
+        expected = Series([], index=idx[:0], dtype='int64')
     else:
         exp_idx = MultiIndex.from_product([['A'], ['foo', 'bar', 'baz']],
                                           names=['one', 'two'])

pandas/tests/indexing/multiindex/test_slice.py

@@ -104,11 +104,11 @@ def test_per_axis_per_level_getitem(self):
         with pytest.raises(ValueError):
             df.loc[(slice(None), np.array([True, False])), :]
 
-        # ambiguous cases
-        # these can be multiply interpreted (e.g. in this case
-        # as df.loc[slice(None),[1]] as well
-        with pytest.raises(KeyError, match=r"'\[1\] not in index'"):
-            df.loc[slice(None), [1]]
+        # ambiguous notation:
+        # this is interpreted as slicing on both axes (GH #16396)
+        result = df.loc[slice(None), [1]]
+        expected = df.iloc[:, []]
+        tm.assert_frame_equal(result, expected)
 
         result = df.loc[(slice(None), [1]), :]
         expected = df.iloc[[0, 3]]