REF: Move Series logic from Index._get_values_for_loc

Author: jbrockmendel

pandas/core/indexes/base.py

@@ -5949,6 +5949,9 @@ def get_value(self, series: Series, key):
             else:
                 raise
 
+        if is_integer(loc):
+            return series._values[loc]
+
         return self._get_values_for_loc(series, loc, key)
 
     def _check_indexing_error(self, key):
@@ -5964,19 +5967,33 @@ def _should_fallback_to_positional(self) -> bool:
         """
         return not self.holds_integer() and not self.is_boolean()
 
+    def get_loc_result_index(self, loc, key):
+        """
+        Find the index to attach to the result of a Series.loc lookup.
+
+        Assumes `loc` is not an integer.
+
+        key is included for MultiIndex compat.
+        """
+        return self[loc]
+
+    # TODO(2.0): remove once get_value deprecation is enforced
+    @final
     def _get_values_for_loc(self, series: Series, loc, key):
         """
         Do a positional lookup on the given Series, returning either a scalar
         or a Series.
 
-        Assumes that `series.index is self`
+        Assumes that `series.index is self` and that `loc` is not an integer,
+        the result of self.get_loc(key)
 
         key is included for MultiIndex compat.
         """
-        if is_integer(loc):
-            return series._values[loc]
+        new_values = series._values[loc]
 
-        return series.iloc[loc]
+        new_index = self.get_loc_result_index(loc, key)
+        new_ser = series._constructor(new_values, index=new_index, name=series.name)
+        return new_ser.__finalize__(series)
 
     @final
     def set_value(self, arr, key, value) -> None:

pandas/core/indexes/multi.py

@@ -2597,25 +2597,16 @@ def _should_fallback_to_positional(self) -> bool:
         # GH#33355
         return self.levels[0]._should_fallback_to_positional
 
-    def _get_values_for_loc(self, series: Series, loc, key):
+    def get_loc_result_index(self, loc, key):
         """
-        Do a positional lookup on the given Series, returning either a scalar
-        or a Series.
+        Find the index to attach to the result of a Series.loc lookup.
 
-        Assumes that `series.index is self`
-        """
-        new_values = series._values[loc]
-        if is_scalar(loc):
-            return new_values
-
-        if len(new_values) == 1 and not self.nlevels > 1:
-            # If more than one level left, we can not return a scalar
-            return new_values[0]
+        Assumes `loc` is not an integer.
 
-        new_index = self[loc]
-        new_index = maybe_droplevels(new_index, key)
-        new_ser = series._constructor(new_values, index=new_index, name=series.name)
-        return new_ser.__finalize__(series)
+        key is included for MultiIndex compat.
+        """
+        new_index = super().get_loc_result_index(loc, key)
+        return maybe_droplevels(new_index, key)
 
     def _get_indexer_strict(
         self, key, axis_name: str
@@ -2922,6 +2913,15 @@ def _maybe_to_slice(loc):
 
         if not isinstance(key, tuple):
             loc = self._get_level_indexer(key, level=0)
+            if (
+                self.nlevels == 1
+                and isinstance(loc, slice)
+                and loc.stop - loc.start == 1
+                and loc.step is None
+            ):
+                # e.g. test_multiindex_at_get_one_level
+                # TODO: is this the right level at which to do this check?
+                return loc.start
             return _maybe_to_slice(loc)
 
         keylen = len(key)

pandas/core/series.py

@@ -1086,9 +1086,17 @@ def _get_value(self, label, takeable: bool = False):
         if takeable:
             return self._values[label]
 
+        index = self.index
+
         # Similar to Index.get_value, but we do not fall back to positional
         loc = self.index.get_loc(label)
-        return self.index._get_values_for_loc(self, loc, label)
+        res_values = self._values[loc]
+        if is_integer(loc):
+            return res_values
+
+        res_index = index.get_loc_result_index(loc, label)
+        result = self._constructor(res_values, index=res_index, name=self.name)
+        return result.__finalize__(self)
 
     def __setitem__(self, key, value) -> None:
         check_deprecated_indexers(key)