问题描述：

我有 python pandas 数据框，其中有一列包含月份名称。

如何使用字典进行自定义排序，例如：

custom_dict = {'March':0, 'April':1, 'Dec':3}  

解决方案 1：

Pandas 0.15 引入了分类系列，它允许更清晰地实现这一点：

首先将月份列设为分类列，并指定要使用的顺序。

In [21]: df['m'] = pd.Categorical(df['m'], ["March", "April", "Dec"])

In [22]: df  # looks the same!
Out[22]:
   a  b      m
0  1  2  March
1  5  6    Dec
2  3  4  April

现在，当您对月份列进行排序时，它将根据该列表进行排序：

In [23]: df.sort_values("m")
Out[23]:
   a  b      m
0  1  2  March
2  3  4  April
1  5  6    Dec

注意：如果值不在列表中，它将被转换为 NaN。

对于那些感兴趣的人来说，这是一个较旧的答案......

您可以创建一个中间系列，然后set_index：

df = pd.DataFrame([[1, 2, 'March'],[5, 6, 'Dec'],[3, 4, 'April']], columns=['a','b','m'])
s = df['m'].apply(lambda x: {'March':0, 'April':1, 'Dec':3}[x])
s.sort_values()

In [4]: df.set_index(s.index).sort()
Out[4]: 
   a  b      m
0  1  2  March
1  3  4  April
2  5  6    Dec

正如评论的那样，在较新的熊猫中，Series 有一种replace更优雅的方法可以做到这一点：

s = df['m'].replace({'March':0, 'April':1, 'Dec':3})

细微的差别是，如果存在字典之外的值，则不会引发此问题（它会保持不变）。

解决方案 2：

pandas >= 1.1

您很快就能使用sort_valueswithkey参数：

pd.__version__
# '1.1.0.dev0+2004.g8d10bfb6f'

custom_dict = {'March': 0, 'April': 1, 'Dec': 3} 
df

   a  b      m
0  1  2  March
1  5  6    Dec
2  3  4  April

df.sort_values(by=['m'], key=lambda x: x.map(custom_dict))

   a  b      m
0  1  2  March
2  3  4  April
1  5  6    Dec

参数key以 Series 作为输入并返回 Series。此 Series 内部经过参数排序，排序后的索引用于对输入 DataFrame 进行重新排序。如果要对多列进行排序，则 key 函数将依次应用于每列。请参阅使用 keys 进行排序。

pandas <= 1.0.X

一种简单的方法是使用输出Series.map并Series.argsort进行索引df（DataFrame.iloc因为 argsort 产生排序的整数位置）；因为你有一本字典；这变得容易。

df.iloc[df['m'].map(custom_dict).argsort()]

   a  b      m
0  1  2  March
2  3  4  April
1  5  6    Dec

如果需要按降序排序，请反转映射。

df.iloc[(-df['m'].map(custom_dict)).argsort()]

   a  b      m
1  5  6    Dec
2  3  4  April
0  1  2  March

请注意，这仅适用于数字项。否则，您将需要使用sort_values并访问索引来解决这个问题：

df.loc[df['m'].map(custom_dict).sort_values(ascending=False).index]

   a  b      m
1  5  6    Dec
2  3  4  April
0  1  2  March

还有更多选项可用astype（现在已弃用），或pd.Categorical，但您需要指定ordered=True才能使其正常工作。

# Older version,
# df['m'].astype('category', 
#                categories=sorted(custom_dict, key=custom_dict.get), 
#                ordered=True)
df['m'] = pd.Categorical(df['m'], 
                         categories=sorted(custom_dict, key=custom_dict.get), 
                         ordered=True)

现在，一个简单的sort_values调用就可以解决问题：

df.sort_values('m')
 
   a  b      m
0  1  2  March
2  3  4  April
1  5  6    Dec

groupby对输出进行排序时也将遵循分类排序。

解决方案 3：

更新

使用选定的答案！它比这篇文章更新，不仅是在熊猫中维护有序数据的官方方法，而且在各个方面都更好，包括功能/性能等。不要使用我下面描述的黑客方法。

我写这个更新只是因为人们一直赞成我的答案，但它肯定比被接受的答案更糟糕:)

原始帖子

有点晚了，但这里有一种方法可以创建一个函数，使用任意函数对 pandas Series、DataFrame 和多索引 DataFrame 对象进行排序。

我使用df.iloc[index]方法来按位置引用 Series/DataFrame 中的一行（相比之下df.loc， 则按值引用）。使用这个方法，我们只需要一个返回一系列位置参数的函数：

def sort_pd(key=None,reverse=False,cmp=None):
    def sorter(series):
        series_list = list(series)
        return [series_list.index(i) 
           for i in sorted(series_list,key=key,reverse=reverse,cmp=cmp)]
    return sorter

您可以使用它来创建自定义排序函数。这适用于 Andy Hayden 的答案中使用的数据框：

df = pd.DataFrame([
    [1, 2, 'March'],
    [5, 6, 'Dec'],
    [3, 4, 'April']], 
  columns=['a','b','m'])

custom_dict = {'March':0, 'April':1, 'Dec':3}
sort_by_custom_dict = sort_pd(key=custom_dict.get)

In [6]: df.iloc[sort_by_custom_dict(df['m'])]
Out[6]:
   a  b  m
0  1  2  March
2  3  4  April
1  5  6  Dec

这也适用于多索引 DataFrames 和 Series 对象：

months = ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec']

df = pd.DataFrame([
    ['New York','Mar',12714],
    ['New York','Apr',89238],
    ['Atlanta','Jan',8161],
    ['Atlanta','Sep',5885],
  ],columns=['location','month','sales']).set_index(['location','month'])

sort_by_month = sort_pd(key=months.index)

In [10]: df.iloc[sort_by_month(df.index.get_level_values('month'))]
Out[10]:
                 sales
location  month  
Atlanta   Jan    8161
New York  Mar    12714
          Apr    89238
Atlanta   Sep    5885

sort_by_last_digit = sort_pd(key=lambda x: x%10)

In [12]: pd.Series(list(df['sales'])).iloc[sort_by_last_digit(df['sales'])]
Out[12]:
2    8161
0   12714
3    5885
1   89238

对我来说，这感觉很干净，但它大量使用 python 操作，而不是依赖优化的 pandas 操作。我没有做过任何压力测试，但我想这在非常大的 DataFrames 上可能会变慢。不确定与添加、排序然后删除列相比，性能如何。任何关于加快代码速度的提示都将不胜感激！

解决方案 4：

import pandas as pd
custom_dict = {'March':0,'April':1,'Dec':3}

df = pd.DataFrame(...) # with columns April, March, Dec (probably alphabetically)

df = pd.DataFrame(df, columns=sorted(custom_dict, key=custom_dict.get))

返回包含三月、四月、十二月列的 DataFrame

解决方案 5：

我有相同的任务，但增加了对多列进行排序的功能。

解决方案之一是将两列都设为pd.Categorical，并将预期顺序作为参数“categories”传递。

但是我有一些要求，无法强制转换未知\意外的值，不幸的是，pd.Categorical 就是这样做的。此外，None不支持作为类别，并且会自动强制转换。

因此，我的解决方案是使用键按自定义排序顺序对多个列进行排序：

import pandas as pd


df = pd.DataFrame([
    [A2, 2],
    [B1, 1],
    [A1, 2],
    [A2, 1],
    [B1, 2],
    [A1, 1]], 
  columns=['one','two'])


def custom_sorting(col: pd.Series) -> pd.Series:
    """Series is input and ordered series is expected as output"""
    to_ret = col
    # apply custom sorting only to column one:
    if col.name == "one":
        custom_dict = {}
        # for example ensure that A2 is first, pass items in sorted order here:
        def custom_sort(value):
            return (value[0], int(value[1:]))

        ordered_items = list(col.unique())
        ordered_items.sort(key=custom_sort)
        # apply custom order first:
        for index, item in enumerate(ordered_items):
            custom_dict[item] = index
        to_ret = col.map(custom_dict)
    # default text sorting is about to be applied
    return to_ret


# pass two columns to be sorted
df.sort_values(
    by=["two", "one"],
    ascending=True,
    inplace=True,
    key=custom_sorting,
)

print(df)

输出：

5  A1    1
3  A2    1
1  B1    1
2  A1    2
0  A2    2
4  B1    2

请注意，这个解决方案可能比较慢。