IntervalIndex.get_loc can now look for exact matches only

Author: tp

doc/source/whatsnew/v0.23.0.txt

@@ -313,6 +313,7 @@ Other API Changes
 - :func:`DatetimeIndex.shift` and :func:`TimedeltaIndex.shift` will now raise ``NullFrequencyError`` (which subclasses ``ValueError``, which was raised in older versions) when the index object frequency is ``None`` (:issue:`19147`)
 - Addition and subtraction of ``NaN`` from a :class:`Series` with ``dtype='timedelta64[ns]'`` will raise a ``TypeError` instead of treating the ``NaN`` as ``NaT`` (:issue:`19274`)
 - Set operations (union, difference...) on :class:`IntervalIndex` with incompatible index types will now raise a ``TypeError`` rather than a ``ValueError`` (:issue:`19329`)
+- :meth:`IntervalIndex.get_loc` can now find exact matches only by setting ``method='exact'`` (:issue:`19349`)
 
 .. _whatsnew_0230.deprecations:
 

pandas/core/indexes/interval.py

@@ -837,7 +837,7 @@ def _maybe_cast_indexed(self, key):
         return key
 
     def _check_method(self, method):
-        if method is None:
+        if method in {None, 'exact'}:
             return
 
         if method in ['bfill', 'backfill', 'pad', 'ffill', 'nearest']:
@@ -867,17 +867,13 @@ def _searchsorted_monotonic(self, label, side, exclude_label=False):
 
         return sub_idx._searchsorted_monotonic(label, side)
 
-    def _get_loc_only_exact_matches(self, key):
+    def _get_loc_only_exact_matches(self, key, unique=True):
         if isinstance(key, Interval):
-
-            if not self.is_unique:
+            if unique and not self.is_unique:
                 raise ValueError("cannot index with a slice Interval"
                                  " and a non-unique index")
-
-            # TODO: this expands to a tuple index, see if we can
-            # do better
-            return Index(self._multiindex.values).get_loc(key)
-        raise KeyError
+            return super(IntervalIndex, self)._engine.get_loc(key)
+        raise KeyError(key)
 
     def _find_non_overlapping_monotonic_bounds(self, key):
         if isinstance(key, IntervalMixin):
@@ -911,8 +907,9 @@ def get_loc(self, key, method=None):
         Parameters
         ----------
         key : label
-        method : {None}, optional
+        method : {None, 'exact'}, optional
             * default: matches where the label is within an interval only.
+            * exact: exact matches only.
 
         Returns
         -------
@@ -940,12 +937,22 @@ def get_loc(self, key, method=None):
         >>> overlapping_index = pd.IntervalIndex.from_intervals([i2, i3])
         >>> overlapping_index.get_loc(1.5)
         array([0, 1], dtype=int64)
+
+        If you want to find exact matches only, use ``method='exact'``:
+
+        >>> index.get_loc(i1, method='exact')
+        0
+        >>> index.get_loc(pd.Interval(0,2), method='exact')
+        KeyError: Interval(0,2)
         """
         self._check_method(method)
 
         original_key = key
         key = self._maybe_cast_indexed(key)
 
+        if method == 'exact':
+            return self._get_loc_only_exact_matches(key, unique=False)
+
         if self.is_non_overlapping_monotonic:
             if isinstance(key, Interval):
                 left = self._maybe_cast_slice_bound(key.left, 'left', None)

pandas/tests/indexes/interval/test_interval.py

@@ -666,6 +666,10 @@ def test_get_loc_value(self):
         idx = IntervalIndex.from_arrays([0, 2], [1, 3])
         pytest.raises(KeyError, idx.get_loc, 1.5)
 
+        # GH19349
+        with pytest.raises(KeyError):
+            self.index.get_loc(0.5, method='exact')
+
     # To be removed, replaced by test_interval_new.py (see #16316, #16386)
     def slice_locs_cases(self, breaks):
         # TODO: same tests for more index types
@@ -739,6 +743,13 @@ def test_get_loc_interval(self):
         pytest.raises(KeyError, self.index.get_loc, Interval(2, 3))
         pytest.raises(KeyError, self.index.get_loc,
                       Interval(-1, 0, 'left'))
+        # GH19349
+        assert self.index.get_loc(Interval(0, 1), method='exact') == 0
+        with pytest.raises(KeyError):
+            self.index.get_loc(Interval(0, 0.5), method='exact')
+        with pytest.raises(KeyError):
+            self.index.get_loc(Interval(0, 1, closed='neither'),
+                               method='exact')
 
     # To be removed, replaced by test_interval_new.py (see #16316, #16386)
     def test_get_indexer(self):

pandas/tests/indexing/interval/test_interval.py

@@ -136,7 +136,7 @@ def test_with_slices(self):
             s[Interval(3, 6):]
 
         expected = s.iloc[3:5]
-        result = s[[Interval(3, 6)]]
+        result = s[Interval(3, 6)]
         tm.assert_series_equal(expected, result)
 
         # slice of scalar with step != 1