Pandas DataFrame中两种排序函数的使用_Asp.net

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

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

函数	核心作用	适用场景
sort_values()	按列的值排序（最常用）	按分数、日期、金额等业务字段排序
sort_index()	按行 / 列索引排序	按行标签（如学号、日期）或列名排序

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

参数	作用	常用值
ascending	升序 / 降序	true（升序，默认）/false（降序）
inplace	是否修改原 dataframe	false（返回新对象，默认）/true（原地修改）
na_position	缺失值（nan）的位置	last（默认，放最后）/first（放最前）
ignore_index	是否重置行索引（0,1,2...）	false（保留原索引，默认）/true（重置）

二、核心排序：按列值排序（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", "david"],
    "分数": [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），再排序，提升效率。

总结

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

到此这篇关于pandas dataframe中两种排序函数的使用的文章就介绍到这了,更多相关pandas dataframe排序函数内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！