pandas.DataFrame.sort_values#

DataFrame.sort_values(by, *, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last', ignore_index=False, key=None)[源代码]#

沿任一轴按值进行排序。

Parameters:
bystr 或 str 列表

要排序的名称或名称列表。

  • 如果 axis 为 0 或 ‘index’，则 by 可以包含索引级别和/或列标签。

  • 如果 axis 为 1 或 ‘columns’，则 by 可以包含列级别和/或索引标签。

axis“{0 或 ‘index’, 1 或 ‘columns’}”, 默认为 0

要排序的轴。

ascendingbool 或布尔值列表，默认为 True

升序与降序排序。为多个排序顺序指定列表。如果这是布尔值列表，则必须与 by 的长度匹配。

inplacebool，默认 False

如果为 True，则原地执行操作。

kind{‘quicksort’, ‘mergesort’, ‘heapsort’, ‘stable’}，默认为 ‘quicksort’

排序算法的选择。有关更多信息，请参阅 numpy.sort() 。mergesort 和 stable 是唯一的稳定算法。对于 DataFrames，此选项仅在按单个列或标签排序时应用。

na_position{‘first’, ‘last’}，默认为 ‘last’

如果为 first，则将 NaN 放在开头；last 将 NaN 放在末尾。

ignore_indexbool，默认 False

如果为 True，则生成的轴标签为 0, 1, …, n - 1。

keycallable，可选

在排序前将键函数应用于值。这类似于内置 sorted() 函数中的 key 参数，但有一个显著的区别是，此 key 函数应该是*矢量化*的。它应该接受一个 Series 并返回一个与输入形状相同的 Series。它将独立应用于 by 中的每个列。

Returns:
DataFrame 或 None

值已排序的 DataFrame，如果 inplace=True 则为 None。

参见

DataFrame.sort_index

按索引对 DataFrame 进行排序。

Series.sort_values

Series 的类似方法。

Examples

>>> df = pd.DataFrame({
...     'col1': ['A', 'A', 'B', np.nan, 'D', 'C'],
...     'col2': [2, 1, 9, 8, 7, 4],
...     'col3': [0, 1, 9, 4, 2, 3],
...     'col4': ['a', 'B', 'c', 'D', 'e', 'F']
... })
>>> df
  col1  col2  col3 col4
0    A     2     0    a
1    A     1     1    B
2    B     9     9    c
3  NaN     8     4    D
4    D     7     2    e
5    C     4     3    F

按 col1 排序

>>> df.sort_values(by=['col1'])
  col1  col2  col3 col4
0    A     2     0    a
1    A     1     1    B
2    B     9     9    c
5    C     4     3    F
4    D     7     2    e
3  NaN     8     4    D

按多个列排序

>>> df.sort_values(by=['col1', 'col2'])
  col1  col2  col3 col4
1    A     1     1    B
0    A     2     0    a
2    B     9     9    c
5    C     4     3    F
4    D     7     2    e
3  NaN     8     4    D

降序排序

>>> df.sort_values(by='col1', ascending=False)
  col1  col2  col3 col4
4    D     7     2    e
5    C     4     3    F
2    B     9     9    c
0    A     2     0    a
1    A     1     1    B
3  NaN     8     4    D

将 NA 值放在前面

>>> df.sort_values(by='col1', ascending=False, na_position='first')
  col1  col2  col3 col4
3  NaN     8     4    D
4    D     7     2    e
5    C     4     3    F
2    B     9     9    c
0    A     2     0    a
1    A     1     1    B

使用键函数排序

>>> df.sort_values(by='col4', key=lambda col: col.str.lower())
   col1  col2  col3 col4
0    A     2     0    a
1    A     1     1    B
2    B     9     9    c
3  NaN     8     4    D
4    D     7     2    e
5    C     4     3    F

使用 natsort <https://github.com/SethMMorton/natsort> 包，进行自然排序，使用 key 参数。

>>> df = pd.DataFrame({
...    "time": ['0hr', '128hr', '72hr', '48hr', '96hr'],
...    "value": [10, 20, 30, 40, 50]
... })
>>> df
    time  value
0    0hr     10
1  128hr     20
2   72hr     30
3   48hr     40
4   96hr     50
>>> from natsort import index_natsorted
>>> df.sort_values(
...     by="time",
...     key=lambda x: np.argsort(index_natsorted(df["time"]))
... )
    time  value
0    0hr     10
3   48hr     40
2   72hr     30
4   96hr     50
1  128hr     20
On this page
显示源代码