pandas.DataFrame.sort_values#

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

按任一轴的值排序。

参数:

通过str 或 str 列表

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

如果 axis 是 0 或 ‘index’，那么 by 可以包含索引级别和/或列标签。
如果 axis 是 1 或 ‘columns’，那么 by 可以包含列级别和/或索引标签。

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

要排序的轴。

升序bool 或 bool 列表，默认 True

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

inplace布尔值, 默认为 False

如果为真，则就地执行操作。

种类{‘quicksort’, ‘mergesort’, ‘heapsort’, ‘stable’}, 默认 ‘quicksort’

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

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

如果 first，则在开头放置 NaNs；last 在末尾放置 NaNs。

ignore_index布尔值, 默认为 False

如果为真，生成的轴将被标记为 0, 1, …, n - 1。

关键可调用，可选

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

返回:

DataFrame 或 None: 如果 inplace=True，则返回排序后的 DataFrame 或 None。

参见

DataFrame.sort_index: 按索引对 DataFrame 进行排序。
Series.sort_values: 类似的方法用于一个 Series。

示例

>>> 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
  A     2     0    a
  A     1     1    B
  B     9     9    c
  C     4     3    F
  D     7     2    e
NaN     8     4    D

按多列排序

你也可以为 by 参数提供多列，如下所示。在这个例子中，行首先根据 col1 排序，然后具有相同 col1 值的行根据 col2 排序。

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

按降序排序

排序顺序可以使用 ascending 参数反转，如下所示：

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

将任何 NA 放在首位

请注意，在上面的示例中，包含 col1 中 NA 值的行被放置在数据框的末尾。这种行为可以通过 na_position 参数进行修改，如下所示：

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

自定义排序顺序

key 参数允许进一步自定义排序行为。例如，您可能希望在排序字符串时忽略字母大小写：

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

另一个典型的例子是自然排序。这可以通过使用 natsort 包来实现，该包提供了根据其自然顺序排序的索引，如下所示：

>>> 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
>>> index_natsorted(df["time"])
[0, 3, 2, 4, 1]
>>> df.sort_values(
...     by="time",
...     key=lambda x: np.argsort(index_natsorted(x)),
... )
    time  value
0    0hr     10
3   48hr     40
2   72hr     30
4   96hr     50
1  128hr     20