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

closes pandas-dev#27148

Author: toobaz

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) 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[l]
+            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,16 +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', [
+    ([], 0),  # empty ok
+    (['A'], 0),
+    (['A', 'D'], 0),
+    (['D', 'E'], -1),  # no values found - fine
+    (['D'], -1),  # same, with single item list: GH 27148
+    (pd.IndexSlice[:, ['foo']], 1),
+    (pd.IndexSlice[:, ['foo', 'bah']], 1)
 ])
-def test_loc_getitem_duplicates_multiindex_missing_indexers(indexer, is_level1,
-                                                            expected_error):
+def test_loc_getitem_duplicates_multiindex_missing_indexers(indexer, level):
     # GH 7866
     # multi-index slicing with missing indexers
     idx = MultiIndex.from_product([['A', 'B', 'C'],
@@ -283,21 +294,20 @@ 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'])
         expected = Series(np.arange(3, dtype='int64'),
                           index=exp_idx).sort_index()
 
-    if expected_error is not None:
-        with pytest.raises(KeyError, match=expected_error):
-            s.loc[indexer]
-    else:
-        result = s.loc[indexer]
-        tm.assert_series_equal(result, expected)
+    result = s.loc[indexer]
+    tm.assert_series_equal(result, expected)
 
 
 def test_series_loc_getitem_fancy(

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]]