PandasDataFrame中两种排序函数的使用

做数据分析的朋友都知道，Pandas里DataFrame的排序是日常高频操作。看似简单，但真要处理多列排序、缺失值定位、自定义规则这些场景时，稍不留神就容易踩坑。今天咱们就把这块彻底理清楚。

一、排序的核心函数：sort_values()和sort_index()

DataFrame的排序主要依赖两个核心函数，先明确它们的定位：

通用参数（两个函数都支持）

二、核心排序：按列值排序（sort_values()）

这是实战中最常用的排序方式，支持单列、多列、自定义排序规则。下面一个个拆解。

1. 单列排序（基础）

import pandas as pd
import numpy as np
# 构建示例数据（学生成绩）
data = {
    "姓名": ["小明", "小红", "小刚", "小丽", "小强"],
    "班级": ["1班", "2班", "1班", "2班", "1班"],
    "数学": [85, 92, 78, 90, np.nan],  # 含缺失值
    "语文": [92, 88, 80, 85, 90]
}
df = pd.DataFrame(data, index=["stu01", "stu02", "stu03", "stu04", "stu05"])
print("原始DataFrame：")
print(df)
# 1.1 按「数学」列升序排序（默认）
df_sort_math_asc = df.sort_values(by="数学")
print("\n按数学升序排序（缺失值放最后）：")
print(df_sort_math_asc)
# 1.2 按「数学」列降序排序，缺失值放最前
df_sort_math_desc = df.sort_values(by="数学", ascending=False, na_position="first")
print("\n按数学降序排序（缺失值放最前）：")
print(df_sort_math_desc)
# 1.3 原地排序（修改原DataFrame）+ 重置行索引
df.sort_values(by="语文", ascending=False, inplace=True, ignore_index=True)
print("\n按语文降序原地排序（重置索引）：")
print(df)

关键说明：

• by="列名" 是必传参数，指定排序依据的列；
• na_position 仅对含 NaN 的列有效，默认 last（缺失值放最后）；
• ignore_index=True 会将排序后的行索引重置为 0,1,2...，避免原索引混乱。

2. 多列排序（进阶）

按多个列依次排序（先按第一列，第一列值相同则按第二列），适用于“分组排序”场景。比如先按班级，再按数学成绩。

import pandas as pd
# 重置示例数据
data = {
    "姓名": ["小明", "小红", "小刚", "小丽", "小强", "小芳"],
    "班级": ["1班", "2班", "1班", "2班", "1班", "2班"],
    "数学": [85, 92, 85, 90, 88, 92],
    "语文": [92, 88, 80, 85, 90, 82]
}
df = pd.DataFrame(data)
print("原始DataFrame：")
print(df)
# 2.1 先按「班级」升序，再按「数学」降序排序
df_sort_multi = df.sort_values(
    by=["班级", "数学"],  # 排序列（先班级，后数学）
    ascending=[True, False]  # 对应列的排序方向（班级升序，数学降序）
)
print("\n按班级升序、数学降序排序：")
print(df_sort_multi)
# 2.2 多列排序+重置索引
df_sort_multi_reset = df.sort_values(
    by=["班级", "语文"],
    ascending=[True, True],
    ignore_index=True
)
print("\n按班级升序、语文升序排序（重置索引）：")
print(df_sort_multi_reset)

核心逻辑：

• by 传入列名列表，排序优先级从左到右；
• ascending 传入布尔值列表，与 by 的列一一对应（数量必须相等）。

3. 按字符串列排序（特殊场景）

支持按字符串的字母/汉字顺序排序，可结合字符串方法增强灵活性。比如按姓名排序，或者按城市分组后再按分数排。

import pandas as pd
data = {
    "姓名": ["张三", "李四", "王五", "赵六", "钱七"],
    "城市": ["北京", "上海", "广州", "深圳", "北京"],
    "分数": [85, 92, 78, 90, 88]
}
df = pd.DataFrame(data)
print("原始DataFrame：")
print(df)
# 3.1 按「姓名」字符串排序（汉字拼音顺序）
df_sort_name = df.sort_values(by="姓名")
print("\n按姓名字符串排序：")
print(df_sort_name)
# 3.2 按「城市」升序，再按「分数」降序
df_sort_city_score = df.sort_values(by=["城市", "分数"], ascending=[True, False])
print("\n按城市升序、分数降序排序：")
print(df_sort_city_score)
# 3.3 按字符串长度排序（需自定义key）
df["姓名长度"] = df["姓名"].str.len()
df_sort_len = df.sort_values(by="姓名长度")
print("\n按姓名长度排序：")
print(df_sort_len)

三、按索引排序（sort_index()）

分为「按行索引排序」和「按列索引（列名）排序」，适用于索引有业务含义的场景（如日期索引、学号索引）。

1. 按行索引排序

import pandas as pd
# 构建带自定义行索引的DataFrame
data = {
    "数学": [85, 92, 78, 90],
    "语文": [92, 88, 80, 85]
}
df = pd.DataFrame(data, index=["stu03", "stu01", "stu04", "stu02"])
print("原始DataFrame（行索引混乱）：")
print(df)
# 1.1 按行索引升序排序（默认）
df_sort_idx_asc = df.sort_index()
print("\n按行索引升序排序：")
print(df_sort_idx_asc)
# 1.2 按行索引降序排序
df_sort_idx_desc = df.sort_index(ascending=False)
print("\n按行索引降序排序：")
print(df_sort_idx_desc)

2. 按列名排序

通过 axis=1 指定按列索引（列名）排序，适用于列名较多且需规范顺序的场景。比如把“姓名”、“班级”这样的列名按字母顺序排列。

import pandas as pd
# 构建列名混乱的DataFrame
data = {
    "语文": [92, 88, 80],
    "班级": ["1班", "2班", "1班"],
    "数学": [85, 92, 78],
    "姓名": ["小明", "小红", "小刚"]
}
df = pd.DataFrame(data)
print("原始DataFrame（列名混乱）：")
print(df)
# 按列名升序排序（axis=1）
df_sort_cols = df.sort_index(axis=1)
print("\n按列名升序排序：")
print(df_sort_cols)
# 按列名降序排序
df_sort_cols_desc = df.sort_index(axis=1, ascending=False)
print("\n按列名降序排序：")
print(df_sort_cols_desc)

关键参数：

• axis=0（默认）：按行索引排序；
• axis=1：按列索引（列名）排序。

四、进阶排序技巧

1. 按自定义规则排序（key参数）

sort_values() 的 key 参数支持传入自定义函数，实现非默认排序逻辑（如按字符串首字母、数值的绝对值排序）。这招在需要“特殊规则”时特别好用。

import pandas as pd
import numpy as np
data = {
    "姓名": ["Alice", "Bob", "Charlie", "Da vid"],
    "分数": [85, -92, 78, -90],
    "等级": ["B", "A", "C", "A"]
}
df = pd.DataFrame(data)
print("原始DataFrame：")
print(df)
# 1.1 按分数的绝对值降序排序
df_sort_abs = df.sort_values(by="分数", key=lambda x: x.abs(), ascending=False)
print("\n按分数绝对值降序排序：")
print(df_sort_abs)
# 1.2 按姓名首字母小写排序
df_sort_name_lower = df.sort_values(by="姓名", key=lambda x: x.str.lower())
print("\n按姓名首字母小写排序：")
print(df_sort_name_lower)
# 1.3 按自定义等级规则排序（A>B>C）
grade_order = {"A": 1, "B": 2, "C": 3}
df_sort_grade = df.sort_values(by="等级", key=lambda x: x.map(grade_order))
print("\n按等级规则（A>B>C）排序：")
print(df_sort_grade)

2. 按行值排序（横向排序）

默认排序是“纵向”（按列值排行），如需“横向”（按行值排列），需结合 apply 和 sort_values。比如每个学生各科成绩，想按分数从高到低排列各科。

import pandas as pd
# 构建每行是学生、每列是科目的DataFrame
data = {
    "数学": [85, 92, 78],
    "语文": [92, 88, 80],
    "英语": [88, 90, 85]
}
df = pd.DataFrame(data, index=["小明", "小红", "小刚"])
print("原始DataFrame（每行是学生，每列是科目）：")
print(df)
# 按每行的值降序排序（横向排序，即每个学生的科目按分数从高到低排）
df_sort_row = df.apply(lambda x: x.sort_values(ascending=False).values, axis=1)
# 重置列名（保持原列名顺序，仅值排序）
df_sort_row.columns = df.columns
print("\n按每行分数降序排序（横向）：")
print(df_sort_row)

3. 排序后保留/删除重复值

排序后结合 drop_duplicates() 实现“保留每组最大值/最小值”的场景。比如每个班级只保留数学成绩最高的学生。

import pandas as pd
data = {
    "班级": ["1班", "1班", "2班", "2班", "1班"],
    "数学": [85, 92, 78, 90, 88],
    "姓名": ["小明", "小红", "小刚", "小丽", "小强"]
}
df = pd.DataFrame(data)
print("原始DataFrame：")
print(df)
# 按班级分组，保留每个班级数学分数最高的学生
# 步骤1：按班级升序、数学降序排序
df_sort = df.sort_values(by=["班级", "数学"], ascending=[True, False])
# 步骤2：按班级去重，保留第一个（即分数最高的）
df_top1 = df_sort.drop_duplicates(subset=["班级"], keep="first")
print("\n每个班级数学最高分学生：")
print(df_top1)

五、实战场景：排序的典型应用

时间序列数据排序

拿到一份日期混乱的温度数据，第一件事就是按日期索引恢复顺序，然后可能会按温度降序找极端值。

import pandas as pd
import numpy as np
# 构建日期索引混乱的温度数据
dates = pd.date_range("2026-01-01", periods=5)
np.random.shuffle(dates)  # 打乱日期
data = {
    "温度": np.random.normal(5, 3, 5).round(1),
    "湿度": np.random.uniform(30, 80, 5).round(1)
}
df = pd.DataFrame(data, index=dates)
print("原始时间序列数据（日期混乱）：")
print(df)
# 按日期索引升序排序（恢复时间顺序）
df_sort_date = df.sort_index()
print("\n按日期升序排序：")
print(df_sort_date)
# 按温度降序排序，保留日期索引
df_sort_temp = df.sort_values(by="温度", ascending=False)
print("\n按温度降序排序：")
print(df_sort_temp)

六、避坑点与最佳实践

1. 核心避坑点

• ❌ 多列排序时 ascending 数量不匹配：by=["A","B"] 必须对应 ascending=[True, False]（2个值）；
• ❌ 混淆 axis 参数：按列名排序需设 axis=1，默认 axis=0 是按行索引；
• ❌ 忽略缺失值位置：含 NaN 的列排序时，NaN 默认放最后，需调整 na_position 时忘记设置；
• ❌ 原地排序后索引混乱：未加 ignore_index=True，导致排序后行索引还是原混乱索引；
• ❌ 自定义 key 函数错误：key 需返回与原列长度相同的数组（如 lambda x: x.abs()），而非单个值。

2. 最佳实践

• ✅ 优先用 sort_values() 按业务列排序，sort_index() 按索引排序；
• ✅ 多列排序时，先排分组列（如班级），后排业务列（如分数）；
• ✅ 排序后重置索引：重要分析结果建议加 ignore_index=True，避免索引混乱；
• ✅ 自定义排序用 key 参数：避免手动修改数据后排序，保持代码简洁；
• ✅ 大数据集排序：先筛选需要的列（usecols），再排序，提升效率。

总结

1. DataFrame 排序核心依赖两个函数：
   • sort_values(by=列名)：按列值排序（单列/多列），支持 ascending/na_position/key；
   • sort_index(axis=0/1)：按行/列索引排序，适用于索引有业务含义的场景；
2. 核心参数：
   • by：指定排序列（仅 sort_values 需传）；
   • ascending：排序方向（True = 升序，False = 降序）；
   • ignore_index：排序后重置行索引（推荐开启）；
   • axis：按行/列索引排序（仅 sort_index 需传）；
3. 进阶技巧：
   • 自定义规则用 key 参数（如绝对值、字符串处理）；
   • 横向排序用 apply(axis=1)；
   • 分组取最值：排序 + drop_duplicates()；
4. 避坑关键：多列排序时 ascending 数量匹配，含缺失值时指定 na_position，排序后重置索引。