如何按两列或更多列对 python pandas 中的数据框进行排序？

Question

假设我有一个包含列

a

、

b

和

c

的数据框，我想按列

b

升序对数据框进行排序，并按列

c

降序排序，我该怎么做？

Answer 1

从 0.17.0 版本开始，

sort

方法已被弃用，取而代之的是

sort_values

。

sort

在 0.20.0 版本中被完全删除。论据（和结果）保持不变：

df.sort_values(['a', 'b'], ascending=[True, False])

---

您可以使用

sort

的升序参数：

df.sort(['a', 'b'], ascending=[True, False])

例如：

In [11]: df1 = pd.DataFrame(np.random.randint(1, 5, (10,2)), columns=['a','b'])

In [12]: df1.sort(['a', 'b'], ascending=[True, False])
Out[12]:
   a  b
2  1  4
7  1  3
1  1  2
3  1  2
4  3  2
6  4  4
0  4  3
9  4  3
5  4  1
8  4  1

---

正如@renadeen 评论的那样

默认情况下没有排序！因此，您应该将排序方法的结果分配给变量或将 inplace=True 添加到方法调用中。

也就是说，如果您想将 df1 重新用作排序的 DataFrame：

df1 = df1.sort(['a', 'b'], ascending=[True, False])

或

df1.sort(['a', 'b'], ascending=[True, False], inplace=True)

Answer 2

从 pandas 0.17.0 开始，

DataFrame.sort()

已弃用，并将在 pandas 的未来版本中删除。现在按数据框的值对数据框进行排序的方法是

DataFrame.sort_values

因此，您问题的答案现在是

df.sort_values(['b', 'c'], ascending=[True, False], inplace=True)

Answer 3

对于数字数据的大型数据帧，您可能会通过

numpy.lexsort

看到显着的性能改进，它使用键序列执行间接排序：

import pandas as pd
import numpy as np

np.random.seed(0)

df1 = pd.DataFrame(np.random.randint(1, 5, (10,2)), columns=['a','b'])
df1 = pd.concat([df1]*100000)

def pdsort(df1):
    return df1.sort_values(['a', 'b'], ascending=[True, False])

def lex(df1):
    arr = df1.values
    return pd.DataFrame(arr[np.lexsort((-arr[:, 1], arr[:, 0]))])

assert (pdsort(df1).values == lex(df1).values).all()

%timeit pdsort(df1)  # 193 ms per loop
%timeit lex(df1)     # 143 ms per loop

一个特点是使用

numpy.lexsort

定义的排序顺序是相反的：

(-'b', 'a')

首先按系列

a

排序。我们否定系列

b

以反映我们希望该系列按降序排列。

请注意，

np.lexsort

仅对数值进行排序，而

pd.DataFrame.sort_values

适用于字符串或数值。将

np.lexsort

与字符串一起使用将给出：

TypeError: bad operand type for unary -: 'str'

。

Answer 4

对于那些来这里进行多栏

DataFrame

的人，请使用

tuple with elements corresponding to each level

。

每个级别对应元素的元组：

d = {}
d['first_level'] = pd.DataFrame(columns=['idx', 'a', 'b', 'c'],
                                         data=[[10, 0.89, 0.98, 0.31],
                                               [20, 0.34, 0.78, 0.34]]).set_index('idx')
d['second_level'] = pd.DataFrame(columns=['idx', 'a', 'b', 'c'],
                                          data=[[10, 0.29, 0.63, 0.99],
                                                [20, 0.23, 0.26, 0.98]]).set_index('idx')

df = pd.concat(d, axis=1)
df.sort_values(('second_level', 'b'))

Answer 5

sort_values

有一个稳定的排序选项，可以通过传递

kind='stable'

来调用。请注意，我们需要反转排序依据的列才能正确使用稳定排序。

因此以下两种方法产生相同的输出，即

df1

和

df2

是等效的。

df = pd.DataFrame(np.random.randint(10, size=(100,2)), columns=['a', 'b'])

df1 = df.sort_values(['a', 'b'], ascending=[True, False])  # sort by 'a' then 'b'

df2 = (
    df
    .sort_values('b', ascending=False)                     # sort by 'b' first
    .sort_values('a', ascending=True, kind='stable')       # then by 'a'
)

assert df1.eq(df2).all().all()

如果您需要更多涉及的排序键，这尤其有用。

假设，给定下面的

df

，您希望按

'date'

和

'value'

排序，但将

'date'

视为日期时间值，即使它们是字符串。带有两个按列排序的简单

sort_values

会产生错误的结果；但是，使用相关排序键调用

sort_values

两次将产生正确的输出。

df = pd.DataFrame({'date': ['10/1/2024', '10/1/2024', '2/23/2024'], 'value': [0, 1, 0]})

df1 = df.sort_values(['date', 'value'], ascending=[True, False])  # <--- wrong output

df2 = (
    df
    .sort_values('value', ascending=False)
    .sort_values('date', ascending=True, kind='stable', key=pd.to_datetime) 
)  # <--- correct output

注意我们可以通过分配一个新的日期时间列并将其用作排序列来获得相同的输出，但在我看来，使用排序键的稳定排序要干净得多。

df3 = df.assign(dummy=pd.to_datetime(df['date'])).sort_values(['dummy', 'value'], ascending=[True, False]).drop(columns='dummy')