如何按两列或更多列对 pandas dataFrame 进行排序？

问题描述：

假设我有一个包含列a、b和 的数据框c。我想按列b升序对数据框进行排序，并按列c降序对数据框进行排序。我该怎么做？

解决方案 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)

解决方案 2：

从 pandas 0.17.0 开始，DataFrame.sort()已弃用，并将在 pandas 的未来版本中删除。现在按数据框的值对其进行排序的方式是DataFrame.sort_values

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

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

解决方案 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'。

解决方案 4：

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

解决方案 5：

对于那些来这里寻求多列的人来说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'))