BUG: fix Series.argsort

doc/source/whatsnew/v1.4.0.rst

@@ -212,7 +212,7 @@ Interval
 Indexing
 ^^^^^^^^
 - Bug in indexing on a :class:`Series` or :class:`DataFrame` with a :class:`DatetimeIndex` when passing a string, the return type depended on whether the index was monotonic (:issue:`24892`)
--
+- Bug in :class:`Series.argsort` where the index was misaligned and the indexed values were not correct (:issue:`42056`, :issue:`12694`)
 
 Missing
 ^^^^^^^

pandas/core/series.py

@@ -3637,8 +3637,8 @@ def argsort(self, axis=0, kind="quicksort", order=None) -> Series:
         """
         Return the integer indices that would sort the Series values.
 
-        Override ndarray.argsort. Argsorts the value, omitting NA/null values,
-        and places the result in the same locations as the non-NA values.
+        Override ndarray.argsort. NA/null sort indices are replaced by -1. The index
+        is sorted so that index labels correspond to the integer indices
 
         Parameters
         ----------
@@ -3659,21 +3659,62 @@ def argsort(self, axis=0, kind="quicksort", order=None) -> Series:
         See Also
         --------
         numpy.ndarray.argsort : Returns the indices that would sort this array.
-        """
-        values = self._values
-        mask = isna(values)
 
-        if mask.any():
-            result = Series(-1, index=self.index, name=self.name, dtype="int64")
-            notmask = ~mask
-            result[notmask] = np.argsort(values[notmask], kind=kind)
-            return self._constructor(result, index=self.index).__finalize__(
+        Examples
+        --------
+
+        Argsorting a basic Series.
+
+        >>> series = Series([30, 10, 20], index=["high", "low", "mid"], name="xy")
+        >>> series.argsort()
+        low     1
+        mid     2
+        high    0
+        Name: xy, dtype: int64
+
+        Argsorting a Series with null values.
+
+        >>> series = Series([30, 10, np.nan, 20], name="xy",
+        ...                    index=["high", "low", "null", "mid"])
+        >>> series.argsort()
+        low     1
+        mid     3
+        high    0
+        null   -1
+        Name: xy, dtype: int64
+        """
+        values = self.values
+        na_mask = isna(values)
+        if not any(na_mask):
+            res = np.argsort(values, kind=kind)
+            res_ser = Series(res, index=self.index[res], dtype="int64", name=self.name)
+            return res_ser.__finalize__(self, method="argsort")
+        else:
+            # GH 42090
+            # count the missing index values that will be added to not na results
+            if isinstance(na_mask, pandas.core.arrays.sparse.SparseArray):
+                # avoid RecursionError
+                na_mask = np.asarray(na_mask)
+            notna_na_cumsum = na_mask.cumsum()[~na_mask]
+            notna_argsort = np.argsort(values[~na_mask])
+            notna_argsort += notna_na_cumsum[notna_argsort]
+            # combine the notna and na series
+            na_res_ser = Series(
+                -1, index=self.index[na_mask], dtype="int64", name=self.name
+            )
+            notna_res_ser = Series(
+                notna_argsort,
+                index=self.index[notna_argsort],
+                dtype="int64",
+                name=self.name,
+            )
+            from pandas.core.reshape.concat import concat
+
+            ret_ser = concat([notna_res_ser, na_res_ser]).__finalize__(
                 self, method="argsort"
             )
-        else:
-            return self._constructor(
-                np.argsort(values, kind=kind), index=self.index, dtype="int64"
-            ).__finalize__(self, method="argsort")
+            assert isinstance(ret_ser, Series)  # mypy: concat 2 Series so is OK
+            return ret_ser
 
     def nlargest(self, n=5, keep="first") -> Series:
         """

pandas/tests/extension/base/methods.py

@@ -71,7 +71,7 @@ def test_apply_simple_series(self, data):
 
     def test_argsort(self, data_for_sorting):
         result = pd.Series(data_for_sorting).argsort()
-        expected = pd.Series(np.array([2, 0, 1], dtype=np.int64))
+        expected = pd.Series(np.array([2, 0, 1], dtype=np.int64), index=[2, 0, 1])
         self.assert_series_equal(result, expected)
 
     def test_argsort_missing_array(self, data_missing_for_sorting):
@@ -84,7 +84,7 @@ def test_argsort_missing_array(self, data_missing_for_sorting):
 
     def test_argsort_missing(self, data_missing_for_sorting):
         result = pd.Series(data_missing_for_sorting).argsort()
-        expected = pd.Series(np.array([1, -1, 0], dtype=np.int64))
+        expected = pd.Series(np.array([2, 0, -1], dtype=np.int64), index=[2, 0, 1])
         self.assert_series_equal(result, expected)
 
     def test_argmin_argmax(self, data_for_sorting, data_missing_for_sorting, na_value):

pandas/tests/series/methods/test_argsort.py

@@ -20,8 +20,9 @@ def _check_accum_op(self, name, ser, check_dtype=True):
         ts = ser.copy()
         ts[::2] = np.NaN
 
-        result = func(ts)[1::2]
-        expected = func(np.array(ts.dropna()))
+        result = func(ts)
+        expected = func(ts.to_numpy())
+        expected[int(len(expected) / 2) :] = -1
 
         tm.assert_numpy_array_equal(result.values, expected, check_dtype=False)
 
@@ -53,8 +54,12 @@ def test_argsort_stable(self):
         mexpected = np.argsort(s.values, kind="mergesort")
         qexpected = np.argsort(s.values, kind="quicksort")
 
-        tm.assert_series_equal(mindexer.astype(np.intp), Series(mexpected))
-        tm.assert_series_equal(qindexer.astype(np.intp), Series(qexpected))
+        tm.assert_series_equal(
+            mindexer.astype(np.intp), Series(mexpected, index=s.index[mexpected])
+        )
+        tm.assert_series_equal(
+            qindexer.astype(np.intp), Series(qexpected, index=s.index[qexpected])
+        )
         msg = (
             r"ndarray Expected type <class 'numpy\.ndarray'>, "
             r"found <class 'pandas\.core\.series\.Series'> instead"