Skip to main content
`Ctrl`+`K`

# pandas.Series.sort_values

Series.sort_values(*, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last', ignore_index=False, key=None)

  Sort by the values.

  Sort a Series in ascending or descending order by some criterion.

  Parameters:
    axis{0 or ‘index’}

      Unused. Parameter needed for compatibility with DataFrame.

    ascending bool or list of bools, default True

      If True, sort values in ascending order, otherwise descending.

    inplace bool, default False

      If True, perform operation in-place.

    kind{‘quicksort’, ‘mergesort’, ‘heapsort’, ‘stable’}, default ‘quicksort’

      Choice of sorting algorithm. See also `numpy.sort()` for more information. The sort order is deterministic for a given input. mergesort and stable are the only stable algorithms, which preserve the relative order of equal keys.

    na_position{‘first’ or ‘last’}, default ‘last’

      Argument ‘first’ puts NaNs at the beginning, ‘last’ puts NaNs at the end.

    ignore_index bool, default False

      If True, the resulting axis will be labeled 0, 1, …, n - 1.

    key callable, optional

      If not None, apply the key function to the series values before sorting. This is similar to the key argument in the builtin `sorted()` function, with the notable difference that this key function should be vectorized. It should expect a `Series` and return an array-like.

  Returns:
    Series or None

      Series ordered by values or None if `inplace=True`.

  See also

  `Series.sort_index`

    Sort by the Series indices.

  `DataFrame.sort_values`

    Sort DataFrame by the values along either axis.

  `DataFrame.sort_index`

    Sort DataFrame by indices.

  Examples

      >>> s = pd.Series([np.nan, 1, 3, 10, 5])
      >>> s
      0     NaN
      1     1.0
      2     3.0
      3     10.0
      4     5.0
      dtype: float64

  Sort values ascending order (default behavior)

      >>> s.sort_values(ascending=True)
      1     1.0
      2     3.0
      4     5.0
      3    10.0
      0     NaN
      dtype: float64

  Sort values descending order

      >>> s.sort_values(ascending=False)
      3    10.0
      4     5.0
      2     3.0
      1     1.0
      0     NaN
      dtype: float64

  Sort values putting NAs first

      >>> s.sort_values(na_position="first")
      0     NaN
      1     1.0
      2     3.0
      4     5.0
      3    10.0
      dtype: float64

  Sort a series of strings

      >>> s = pd.Series(["z", "b", "d", "a", "c"])
      >>> s
      0    z
      1    b
      2    d
      3    a
      4    c
      dtype: str

      >>> s.sort_values()
      3    a
      1    b
      4    c
      2    d
      0    z
      dtype: str

  Sort using a key function. Your key function will be given the `Series` of values and should return an array-like.

      >>> s = pd.Series(["a", "B", "c", "D", "e"])
      >>> s.sort_values()
      1    B
      3    D
      0    a
      2    c
      4    e
      dtype: str
      >>> s.sort_values(key=lambda x: x.str.lower())
      0    a
      1    B
      2    c
      3    D
      4    e
      dtype: str

  NumPy ufuncs work well here. For example, we can sort by the `sin` of the value

      >>> s = pd.Series([-4, -2, 0, 2, 4])
      >>> s.sort_values(key=np.sin)
      1   -2
      4    4
      2    0
      0   -4
      3    2
      dtype: int64

  More complicated user-defined functions can be used, as long as they expect a Series and return an array-like

      >>> s.sort_values(key=lambda x: np.tan(x.cumsum()))
      0   -4
      3    2
      4    4
      1   -2
      2    0
      dtype: int64