# 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’}, default 0

      Axis to direct sorting. The value ‘index’ is accepted for compatibility with DataFrame.sort_values.

    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. ‘mergesort’ and ‘stable’ are the only stable algorithms.

    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.

      New in version 1.0.0.

    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.

      New in version 1.1.0.

  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 behaviour)

      >>> 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 inplace

      >>> s.sort_values(ascending=False, inplace=True)
      >>> s
      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: object

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

  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: object
      >>> s.sort_values(key=lambda x: x.str.lower())
      0    a
      1    B
      2    c
      3    D
      4    e
      dtype: object

  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