小开

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

小开

最佳答案

熊猫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})

细微的差别在于，如果字典之外有一个值，这个值不会增加(它将保持不变)。

小开

更新

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

我之所以写这篇文章，是因为人们不断地对我的答案表示赞赏，但这绝对比已被接受的答案更糟糕:)

原文

这个游戏有点晚了，但是这里有一种方法可以创建一个函数，使用任意函数对熊猫 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 操作，而不是依赖于优化的熊猫操作。我还没有做过任何压力测试，但是我可以想象在非常大的 DataFrames 上这会变得非常慢。不确定与添加、排序、然后删除列相比性能如何。任何关于加快代码的提示都将受到感谢！

小开

熊猫 > = 1.1

你很快就能使用 sort_values和 key参数:

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。该系列在内部进行了排序，并使用排序后的索引对输入 DataFrame 进行重新排序。如果要对多个列进行排序，键函数将依次应用于每个列。见用钥匙分类。

熊猫 < = 1.0. X

一个简单的方法是使用输出 Series.map和 Series.argsort使用 DataFrame.iloc索引到 df中(因为 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对输出进行排序时，也将遵守分类排序。

小开

我有同样的任务，但增加了对多个列进行排序。

其中一种解决方案是使两列都为 警察，绝对的，并将预期的顺序作为参数“类别”传递。

但我有一些要求，我不能强制未知的意外值，不幸的是，这是什么 pd。绝对主义就是这样。也无不是支持作为一个类别和强制自动。

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

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)

产出:

请注意，这个解决方案可能会很慢。

熊猫数据框架中的自定义排序

更新

原文

熊猫 > = 1.1

熊猫 < = 1.0. X