ENH: pd.MultiIndex.get_loc(np.nan) (#19132)

MultiIndex.get_loc could not find nan with values including missing
values as a input

Author: proost

doc/source/whatsnew/v1.0.0.rst

@@ -229,6 +229,7 @@ Indexing
 - Bug in reindexing a :meth:`PeriodIndex` with another type of index that contained a `Period` (:issue:`28323`) (:issue:`28337`)
 - Fix assignment of column via `.loc` with numpy non-ns datetime type (:issue:`27395`)
 - Bug in :meth:`Float64Index.astype` where ``np.inf`` was not handled properly when casting to an integer dtype (:issue:`28475`)
+- When index is ``MultiIndex``, Using ``.get_loc`` can't find ``nan`` with values including missing values as input (:issue:`19132`)
 
 Missing
 ^^^^^^^

pandas/core/indexes/multi.py

@@ -2591,7 +2591,7 @@ def _partial_tup_index(self, tup, side="left"):
         for k, (lab, lev, labs) in enumerate(zipped):
             section = labs[start:end]
 
-            if lab not in lev:
+            if lab not in lev and not isna(lab):
                 if not lev.is_type_compatible(lib.infer_dtype([lab], skipna=False)):
                     raise TypeError("Level type mismatch: %s" % lab)
 
@@ -2601,13 +2601,44 @@ def _partial_tup_index(self, tup, side="left"):
                     loc -= 1
                 return start + section.searchsorted(loc, side=side)
 
-            idx = lev.get_loc(lab)
+            idx = self._get_loc_single_level_index_wrapper(lev, lab)
             if k < n - 1:
                 end = start + section.searchsorted(idx, side="right")
                 start = start + section.searchsorted(idx, side="left")
             else:
                 return start + section.searchsorted(idx, side=side)
 
+    def _get_loc_single_level_index_wrapper(self, level_index: Index, key) -> int:
+        """
+        Wrapper function for MultiIndex.
+        If key is NA value, location of index unify as -1.
+
+        Parameters
+        ----------
+        level_index: Index
+                    Single level index in MultiIndex                    
+        key : label    
+            If .get_loc key is tuple of labels, 
+            In this function, key is each level label                           
+
+        Returns
+        -------
+        loc : int
+            If key is NA value, loc is -1
+            Else, location of key in index. 
+
+        See Also
+        --------
+        Index.get_loc : The get_loc method for (single-level) index.
+
+        Notes
+        -----
+        Depending on Index type, Handling NA value is different using get_loc.
+        But in MultiIndex, NA values is denoted as missing by -1.
+        """
+
+        return -1 if isna(key) else level_index.get_loc(key)
+
     def get_loc(self, key, method=None):
         """
         Get location for a label or a tuple of labels as an integer, slice or
@@ -2668,7 +2699,8 @@ def _maybe_to_slice(loc):
             mask[loc] = True
             return mask
 
-        if not isinstance(key, tuple):
+        if is_scalar(key) or len(key) == 1:
+            # scalar value or a value in list
             loc = self._get_level_indexer(key, level=0)
             return _maybe_to_slice(loc)
 
@@ -2707,7 +2739,9 @@ def _maybe_to_slice(loc):
         loc = np.arange(start, stop, dtype="int64")
 
         for i, k in enumerate(follow_key, len(lead_key)):
-            mask = self.codes[i][loc] == self.levels[i].get_loc(k)
+            mask = self.codes[i][loc] == self._get_loc_single_level_index_wrapper(
+                self.levels[i], k
+            )
             if not mask.all():
                 loc = loc[mask]
             if not len(loc):
@@ -2934,8 +2968,7 @@ def convert_indexer(start, stop, step, indexer=indexer, codes=level_codes):
                 return slice(i, j, step)
 
         else:
-
-            code = level_index.get_loc(key)
+            code = self._get_loc_single_level_index_wrapper(level_index, key)
 
             if level > 0 or self.lexsort_depth == 0:
                 # Desired level is not sorted

pandas/tests/indexes/multi/test_indexing.py

@@ -439,3 +439,30 @@ def test_timestamp_multiindex_indexer():
     )
     should_be = pd.Series(data=np.arange(24, len(qidx) + 24), index=qidx, name="foo")
     tm.assert_series_equal(result, should_be)
+
+
+def test_get_loc_with_values_including_missing_values():
+    # issue 19132
+    idx = MultiIndex.from_product([[np.nan, 1]] * 2)
+    expected = slice(0, 2, None)
+    assert idx.get_loc(np.nan) == expected
+
+    idx = MultiIndex.from_arrays([[np.nan, 1, 2, np.nan]])
+    expected = np.array([True, False, False, True])
+    tm.assert_numpy_array_equal(idx.get_loc(np.nan), expected)
+
+    idx = MultiIndex.from_product([[np.nan, 1]] * 3)
+    expected = slice(2, 4, None)
+    assert idx.get_loc((np.nan, 1)) == expected
+
+
+def test_get_indexer_with_missing_value():
+    # issue 19132
+    idx = MultiIndex.from_arrays([[1, np.nan, 2], [3, 4, 5]])
+    result = idx.get_indexer([1, np.nan, 2])
+    expected = np.array([-1, -1, -1])
+    tm.assert_numpy_array_equal(result, expected)
+
+    result = idx.get_indexer([(np.nan, 4)])
+    expected = np.array([1])
+    tm.assert_numpy_array_equal(result, expected)