引言：为什么数据排序至关重要
在数据分析和处理过程中，数据排序是最基础也是最重要的操作之一。通过排序，我们可以快速识别数据的模式、发现异常值、进行数据对比以及为后续的分析和可视化做好准备。Pandas作为Python中最流行的数据处理库，提供了强大而灵活的排序功能，能够满足从简单到复杂的各种排序需求。
本文将全面介绍Pandas中的排序方法，包括单列排序、多列排序、处理缺失值的技巧，以及一些高级排序应用场景。无论您是数据分析师、数据科学家还是软件开发人员，掌握这些排序技巧都能显著提高您的数据处理效率。
基础排序：单列排序
sort_values()方法详解
Pandas中最常用的排序方法是
sort_values()
，它可以按照指定列的值对DataFrame进行排序。让我们从最基本的单列排序开始：
import pandas as pd
import numpy as np
# 创建示例数据
data = {
‘姓名’: [‘张三’, ‘李四’, ‘王五’, ‘赵六’, ‘钱七’],
‘年龄’: [25, 30, 22, 35, 28],
‘分数’: [85, 92, 78, 88, 95]
}
df = pd.DataFrame(data)
print(“原始数据：”)
print(df)
输出结果：
姓名 年龄 分数
0 张三 25 85
1 李四 30 92
2 王五 22 78
3 赵六 35 88
4 钱七 28 95
升序排序
# 按年龄升序排序
df_sorted = df.sort_values(by=’年龄’)
print(“\n按年龄升序排序：”)
print(df_sorted)
输出：
姓名 年龄 分数
2 王五 22 78
0 张三 25 85
4 钱七 28 95
1 李四 30 92
3 赵六 35 88
降序排序
# 按分数降序排序
df_sorted_desc = df.sort_values(by=’分数’, ascending=False)
print(“\n按分数降序排序：”)
print(df_sorted_desc)
输出：
姓名 年龄 分数
4 钱七 28 95
1 李四 30 92
3 赵六 35 88
0 张三 25 85
2 王五 22 78
sort_index()方法
除了按值排序，Pandas还支持按索引排序：
# 先打乱索引
df_shuffled = df.sample(frac=1).reset_index(drop=True)
print(“\n打乱后的数据：”)
print(df_shuffled)
# 按索引排序
df_sorted_index = df_shuffled.sort_index()
print(“\n按索引排序后：”)
print(df_sorted_index)
多列排序：处理复杂排序需求
基本多列排序
在实际应用中，我们经常需要按照多个列进行排序。例如，先按年龄排序，年龄相同时再按分数排序：
# 多列排序示例
data_multi = {
‘部门’: [‘销售’, ‘技术’, ‘销售’, ‘技术’, ‘销售’, ‘技术’],
‘姓名’: [‘张三’, ‘李四’, ‘王五’, ‘赵六’, ‘钱七’, ‘孙八’],
‘年龄’: [25, 30, 25, 35, 28, 30],
‘分数’: [85, 92, 88, 88, 95, 90]
}
df_multi = pd.DataFrame(data_multi)
print(“原始多列数据：”)
print(df_multi)
# 多列排序：先按部门，再按年龄，最后按分数
df_multi_sorted = df_multi.sort_values(by=[‘部门’, ‘年龄’, ‘分数’])
print(“\n多列排序结果（部门→年龄→分数）：”)
print(df_multi_sorted)
输出：
原始多列数据：
部门 姓名 年龄 分数
0 销售 张三 25 85
1 技术 李四 30 92
2 销售 王五 25 88
3 技术 赵六 35 88
4 销售 钱七 28 95
5 技术 孙八 30 90
多列排序结果（部门→年龄→分数）：
部门 姓名 年龄 分数
1 技术 李四 30 92
5 技术 孙八 30 90
3 技术 赵六 35 88
0 销售 张三 25 85
2 销售 王五 25 88
4 销售 钱七 28 95
混合升降序排序
在多列排序中，可以为不同列指定不同的排序方向：
# 部门升序，年龄降序，分数升序
df_mixed = df_multi.sort_values(
by=[‘部门’, ‘年龄’, ‘分数’],
ascending=[True, False, True]
)
print(“\n混合排序（部门升序→年龄降序→分数升序）：”)
print(df_mixed)
输出：
混合排序（部门升序→年龄降序→分数升序）：
部门 姓名 年龄 分数
3 技术 赵六 35 88
1 技术 李四 30 92
5 技术 孙八 30 90
4 销售 钱七 28 95
0 销售 张三 25 85
2 销售 王五 25 88
多列排序的key参数
Pandas 1.1.0及以上版本支持使用key参数进行自定义排序：
# 使用key参数进行自定义排序（例如按字符串长度排序）
df_text = pd.DataFrame({
‘text’: [‘apple’, ‘banana’, ‘cherry’, ‘date’, ‘elderberry’],
‘value’: [1, 2, 3, 4, 5]
})
# 按文本长度排序
df_text_sorted = df_text.sort_values(by=’text’, key=lambda x: x.str.len())
print(“\n按文本长度排序：”)
print(df_text_sorted)
处理缺失值的排序技巧
缺失值在排序中的行为
在Pandas中，缺失值（NaN）在排序时默认会被放在最后（升序）或最前（降序）：
# 包含缺失值的数据
data_nan = {
‘姓名’: [‘张三’, ‘李四’, ‘王五’, ‘赵六’, ‘钱七’],
‘年龄’: [25, np.nan, 22, 35, 28],
‘分数’: [85, 92, np.nan, 88, 95]
}
df_nan = pd.DataFrame(data_nan)
print(“包含缺失值的原始数据：”)
print(df_nan)
# 升序排序（NaN在最后）
df_nan_sorted = df_nan.sort_values(by=’年龄’)
print(“\n按年龄升序排序（NaN在最后）：”)
print(df_nan_sorted)
# 降序排序（NaN在最前）
df_nan_sorted_desc = df_nan.sort_values(by=’年龄’, ascending=False)
print(“\n按年龄降序排序（NaN在最前）：”)
print(df_nan_sorted_desc)
输出：
包含缺失值的原始数据：
姓名 年龄 分数
0 张三 25.0 85.0
1 李四 NaN 92.0
2 � 王五 22.0 NaN
3 赵六 35.0 88.0
4 钱七 28.0 95.0
按年龄升序排序（NaN在最后）：
姓名 年龄 分数
2 王五 22.0 NaN
0 张三 25.0 85.0
4 钱七 28.0 95.0
3 赵六 35.0 88.0
1 李四 NaN 92. 自定义排序函数
### 使用key参数处理缺失值
“`python
# 使用key参数将NaN放在最前或最后
df_nan_sorted_custom = df_nan.sort_values(
by=’年龄’,
key=lambda x: x.fillna(float(‘inf’)) # 将NaN视为最大值
)
print(“\n自定义处理NaN（视为最大值）：”)
print(df_nan_sorted_custom)
使用na_position参数
虽然Pandas的sort_values()没有直接的na_position参数，但可以通过其他方式控制：
# 方法1：先填充再排序
df_filled = df_nan.fillna({‘年龄’: 0}) # 用0填充NaN
df_filled_sorted = df_filled.sort_values(by=’年龄’)
print(“\n填充NaN为0后排序：”)
print(df_filled_sorted)
# 方法2：使用where或mask
df_masked = df_nan.copy()
df_masked[‘年龄’] = df_masked[‘年龄’].where(df_masked[‘年龄’].notna(), float(‘inf’))
df_masked_sorted = df_masked.sort_values(by=’年龄’)
print(“\n使用where处理NaN后排序：”)
print(df_masked_sorted)
多列排序中的缺失值处理
在多列排序中，缺失值的处理更加复杂：
# 多列包含缺失值
data_multi_nan = {
‘部门’: [‘销售’, ‘技术’, ‘销售’, ‘技术’, ‘销售’, ‘技术’],
‘姓名’: [‘张三’, ‘李四’, ‘王五’, ‘赵六’, ‘钱七’, ‘孙八’],
‘年龄’: [25, np.nan, 25, 35, 28, np.nan],
‘分数’: [85, 92, np.nan, 88, 95, 90]
}
df_multi_nan = pd.DataFrame(data_multi_nan)
# 多列排序，先按部门，再按年龄（NaN处理）
df_multi_nan_sorted = df_multi_nan.sort_values(
by=[‘部门’, ‘年龄’],
ascending=[True, True],
na_position=’last’ # 注意：这个参数在较新版本中可用
)
print(“\n多列排序处理NaN：”)
print(df_multi_nan_sorted)
高级排序技巧
按自定义顺序排序
有时我们需要按照特定的顺序而不是字母或数字顺序排序：
# 自定义排序顺序
custom_order = [‘初级’, ‘中级’, ‘高级’]
data_level = {
‘员工’: [‘张三’, ‘李四’, ‘王五’, ‘赵六’],
‘级别’: [‘中级’, ‘初级’, ‘高级’, ‘中级’]
}
df_level = pd.DataFrame(data_level)
# 使用Categorical类型实现自定义排序
df_level[‘级别’] = pd.Categorical(
df_level[‘级别’],
categories=custom_order,
ordered=True
)
df_level_sorted = df_level.sort_values(‘级别’)
print(“\n按自定义级别顺序排序：”)
print(df_level_sorted)
按索引排序
除了按值排序，还可以按索引排序：
# 按索引排序
df_index = df.set_index(‘姓名’)
df_index_sorted = df_index.sort_index()
print(“\n按索引排序：”)
print(df_index_sorted)
# 多级索引排序
arrays = [[‘销售’, ‘销售’, ‘技术’, ‘技术’],
[‘张三’, ‘王五’, ‘李四’, ‘赵六’]]
index = pd.MultiIndex.from_arrays(arrays, names=[‘部门’, ‘姓名’])
df_multi_index = pd.DataFrame({‘分数’: [85, 88, 92, 88]}, index=index)
df_multi_index_sorted = df_multi_index.sort_index()
print(“\n多级索引排序：”)
print(df_multi_index_sorted)
排名（rank）方法
Pandas还提供了rank()方法，用于计算数据的排名：
# 基本排名
df_rank = df.copy()
df_rank[‘年龄排名’] = df_rank[‘年龄’].rank(method=’min’)
df_rank[‘分数排名’] = df_rank[‘分数’].rank(method=’dense’, ascending=False)
print(“\n添加排名列：”)
print(df_rank)
# 不同排名方法的比较
methods = [‘average’, ‘min’, ‘max’, ‘first’, ‘dense’]
for method in methods:
df[f’rank_{method}’] = df[‘分数’].rank(method=method)
print(“\n不同排名方法比较：”)
print(df)
排序后重置索引
排序后索引会保持不变，但有时我们需要重置索引：
# 排序后重置索引
df_sorted_reset = df.sort_values(‘分数’, ascending=False).reset_index(drop=True)
print(“\n排序后重置索引：”)
print(df_sorted_reset)
性能优化技巧
大数据集排序
对于大数据集，排序可能比较耗时，以下是一些优化建议：
# 1. 选择合适的排序算法
# Pandas默认使用Timsort，对于大多数情况都很高效
# 2. 只排序需要的列
df_sorted = df.sort_values(‘分数’, ascending=False) # 只排序分数列
# 3. 使用numba加速（如果适用）
from numba import jit
@jit(nopython=True)
def custom_sort(arr):
return np.sort(arr)
# 4. 分块处理大数据集
def sort_large_dataframe(df, by, chunk_size=100000):
# 将大数据集分块排序
chunks = [df[i:i+chunk_size] for i in range(0, len(df), chunk_size)]
sorted_chunks = [chunk.sort_values(by) for chunk in chunks]
return pd.concat(sorted_chunks).sort_values(by)
内存优化
# 对于大数据集，考虑使用适当的数据类型
df_optimized = df.copy()
df_optimized[‘年龄’] = df_optimized[‘年龄’].astype(‘int32’)
df_optimized[‘分数’] = df_optimized[‘分数’].astype(‘int16’)
# 使用category类型处理重复字符串
df_optimized[‘部门’] = df_optimized[‘部门’].astype(‘category’)
实际应用案例
案例1：学生成绩分析
# 学生成绩排序分析
students = {
‘姓名’: [‘张三’, ‘李四’, ‘王五’, ‘赵六’, ‘钱七’, ‘孙八’, ‘周九’, ‘吴十’],
‘班级’: [‘A’, ‘A’, ‘B’, ‘B’, ‘A’, ‘B’, ‘A’, ‘B’],
‘数学’: [85, 92, 78, 88, 95, 82, 90, 85],
‘英语’: [88, 85, 90, 82, 92, 88, 85, 90],
‘科学’: [90, 88, 85, 92, 88, 85, 90, 88]
}
df_students = pd.DataFrame(students)
# 计算总分
df_students[‘总分’] = df_students[[‘数学’, ‘英语’, ‘科学’]].sum(axis=1)
# 按班级和总分排序
df_students_sorted = df_students.sort_values(
by=[‘班级’, ‘总分’],
ascending=[True, False]
)
# 添加排名
df_students_sorted[‘班级排名’] = df_students_sorted.groupby(‘班级’)[‘总分’].rank(method=’min’, ascending=False)
print(“学生成绩排序分析：”)
print(df_students_sorted)
案例2：销售数据分析
# 销售数据排序分析
sales_data = {
‘日期’: pd.date_range(‘2023-01-01′, periods=10, freq=’D’),
‘产品’: [‘A’, ‘B’, ‘A’, ‘C’, ‘B’, ‘A’, ‘C’, ‘B’, ‘A’, ‘C’],
‘销售额’: [1000, 1500, 1200, 800, 1600, 1300, 900, 1700, 1400, 950],
‘地区’: [‘东区’, ‘西区’, ‘东区’, ‘南区’, ‘西区’, ‘东区’, ‘南区’, ‘西区’, ‘东区’, ‘南区’]
}
df_sales = pd.DataFrame(sales_data)
# 按地区和销售额排序
df_sales_sorted = df_sales.sort_values(
by=[‘地区’, ‘销售额’],
ascending=[True, False]
)
# 计算每个地区的累计销售额
df_sales_sorted[‘地区累计’] = df_sales_sorted.groupby(‘地区’)[‘销售额’].cumsum()
print(“\n销售数据排序分析：”)
print(df_sales_sorted)
常见问题与解决方案
问题1：排序后索引混乱
解决方案
：
# 问题：排序后索引不连续
df_sorted = df.sort_values(‘分数’)
# 解决方案：重置索引
df_sorted.reset_index(drop=True, inplace=True)
问题2：多列排序性能差
解决方案
：
# 问题：大数据集多列排序慢
# 解决方案1：只排序需要的列
df_sorted = df[[‘列1’, ‘列2’, ‘列3’]].sort_values([‘列1’, ‘列2’])
# 解决方案2：使用numba加速
# 需要安装numba: pip install numba
问题3：无法按自定义顺序排序
解决方案
：
# 问题：需要按[‘高’, ‘中’, ‘低’]排序，但默认按字母排序
# 解决方案：使用Categorical类型
df[‘优先级’] = pd.Categorical(df[‘优先级’], categories=[‘高’, ‘中’, ‘0’], ordered=True)
df_sorted = df.sort_values(‘优先级’)
总结
Pandas提供了强大而灵活的排序功能，从简单的单列排序到复杂的多列排序，再到处理缺失值和自定义排序顺序，都能轻松应对。掌握这些排序技巧将大大提升您的数据处理能力。
关键要点：
sort_values()
是主要的排序方法，支持单列和多列排序
ascending
参数控制排序方向，可以为不同列指定不同方向
缺失值
默认放在排序的最后（升序）或最前（降序）
自定义排序
可以通过Categorical类型或key参数实现
性能优化
对于大数据集很重要，包括选择合适的数据类型和分块处理
通过本文的详细示例和说明，相信您已经掌握了Pandas数据排序的核心技巧。在实际工作中，根据具体需求灵活运用这些方法，将使您的数据分析工作更加高效和准确。