Python怎么对嵌套列表或多条件对象进行排序

一、核心机制：基于比较键（Key）的元组仲裁

Python提供了两种排序手段：一种是列表对象的原生方法 list.sort()，它直接就地修改原列表且返回值为 None；另一种是全局函数 sorted()，它接收任意可迭代对象并返回一个全新排好序的列表。无论是哪种方式，处理多条件排序的关键都在于 key 参数。

key 参数接收一个可调用对象（通常为单参数函数）。在排序开始前，Python会为集合中的每个元素调用一次该函数，并记录其返回的键值。当需要根据多个条件排定先后时，让该函数返回一个元组即可。

二、嵌套列表的实战排序范式

嵌套列表常见于表格数据、矩阵数据或从 CSV 读出的行列列表。以下通过具体场景说明多条件排序的写法。

1. 多个字段同向升序

假设有一批学生列表，格式为 [姓名, 成绩, 年龄]。需求是先按成绩升序排列；若成绩相同，再按年龄升序排列：

students = [
    ["Alice", 88, 16],
    ["Bob", 95, 15],
    ["Charlie", 88, 14],
    ["David", 95, 17]
]

# 按成绩升序，成绩相同则按年龄升序
result = sorted(students, key=lambda s: (s[1], s[2]))

# 输出结果展示：
# 示例输出：
# [['Charlie', 88, 14], ['Alice', 88, 16], ['Bob', 95, 15], ['David', 95, 17]]

在上述代码中，当 Alice 和 Charlie 的成绩均为 88 时，第一项对比产生平局，Python自动比对第二项（年龄），由于 14 < 16，因此 Charlie 排在前面。

2. 多字段混合升降序（数值型字段取反）

在实际业务中，经常需要“第一条件降序、第二条件升序”。如果被降序排序的字段是数值型（整数或浮点数），最简便高效的方案是在该字段前加上负号 -：

# 需求：成绩从高到低（降序），同分情况下年龄从小到大（升序）
result = sorted(students, key=lambda s: (-s[1], s[2]))

# 示例输出：
# [['Bob', 95, 15], ['David', 95, 17], ['Charlie', 88, 14], ['Alice', 88, 16]]

因为 -95 < -88，原本数值较大的项在加上负号后变小，从而在默认的升序比对中排在最前，完成了局部降序的效果。

三、字典列表与自定义对象的多条件排序

除了基础的嵌套列表，在开发中更普遍的数据载体是字典列表（如读取 JSON 数据）和自定义类对象实例。两者在使用 key 时的语法细节略有不同。

1. 字典列表排序

字典数据通常通过键名访问。排序时，在 lambda 中提取对应的字段组装为元组：

users = [
    {"username": "alpha", "level": 3, "points": 450},
    {"username": "beta", "level": 5, "points": 450},
    {"username": "gamma", "level": 3, "points": 820},
    {"username": "delta", "level": 5, "points": 310}
]

# 优先按等级降序 (-level)，等级相同时按积分降序 (-points)
sorted_users = sorted(users, key=lambda u: (-u["level"], -u["points"]))

# 示例输出：
# [{'username': 'beta', 'level': 5, 'points': 450},
#  {'username': 'delta', 'level': 5, 'points': 310},
#  {'username': 'gamma', 'level': 3, 'points': 820},
#  {'username': 'alpha', 'level': 3, 'points': 450}]

2. 自定义类对象排序

对于自定义类实例构成的列表，元素属性通过点号 . 访问：

class Order:
    def __init__(self, order_id, amount, customer_level):
        self.order_id = order_id
        self.amount = amount
        self.customer_level = customer_level

    def __repr__(self):
        return f"Order({self.order_id}, 金额:{self.amount}, 等级:{self.customer_level})"

orders = [
    Order("A01", 1200, 2),
    Order("A02", 3500, 1),
    Order("A03", 1200, 3)
]

# 按金额降序 (-amount)，同金额按客户等级升序 (customer_level)
orders.sort(key=lambda o: (-o.amount, o.customer_level))

# 示例输出：
# [Order(A02, 金额:3500, 等级:1), Order(A01, 金额:1200, 等级:2), Order(A03, 金额:1200, 等级:3)]

四、关键做法对比：lambda 表达式 vs operator 模块

在编写排序代码时，很多开发者习惯一律使用 lambda，但标准库中的 operator 模块提供了 itemgetter 和 attrgetter。两者在一致条件下存在显著差异。

示例演示 itemgetter 的简练写法：

from operator import itemgetter

records = [
    ("DepB", 3, "Team1"),
    ("DepA", 1, "Team3"),
    ("DepB", 1, "Team2"),
    ("DepA", 2, "Team1")
]

# 同时按第0列（部门）升序、第1列（级别）升序
sorted_records = sorted(records, key=itemgetter(0, 1))

# 示例输出：
# [('DepA', 1, 'Team3'), ('DepA', 2, 'Team1'), ('DepB', 1, 'Team2'), ('DepB', 2, 'Team1')]

五、特殊边界：非数值字段的混合升降序如何处理？

数值字段可以通过 -x 轻松翻转升降序，但如果第一条件是字符串降序，第二条件是数字升序，由于字符串不支持一元负号运算符，执行 -"Beijing" 会直接抛出 TypeError: bad operand type for unary -: 'str'。

面对这种非数值字段的混合排序，主要有两种行之有效的解决策略：

策略一：利用 Python 排序的稳定性进行“反向多轮排序”

Python 内置的排序算法（Timsort）是稳定排序（Stable Sort）。所谓稳定性，是指若两个元素的键值相同，排序后它们原有的相对次序严格保持不变。

利用这个性质，我们可以从最次要的条件开始向最主要的条件依次排序。每次单独使用 reverse 参数控制该字段的方向：

data = [
    ["Charlie", 25],
    ["Alice", 30],
    ["Charlie", 19],
    ["Bob", 22],
    ["Alice", 21]
]

# 业务目标：姓名降序（Z -> A），姓名相同的按年龄升序（小 -> 大）

# 第一步：先按次要条件（年龄）升序排序
data.sort(key=lambda x: x[1], reverse=False)

# 第二步：再按主要条件（姓名）降序排序
data.sort(key=lambda x: x[0], reverse=True)

# 示例输出：
# [['Charlie', 19], ['Charlie', 25], ['Bob', 22], ['Alice', 21], ['Alice', 30]]

在第二步姓名降序排定后，因为稳定性保证，两名同为 "Charlie" 的选手其此前排好的 19 与 25 的相对次序被原封不动地保留了下来。

策略二：封装逆向比较包装器（ReverseWrapper）

如果希望在一轮排序中完成，可以编写一个通用的倒序包装类，通过重载 __lt__ 方法实现反向比较：

class ReverseOrder:
    def __init__(self, val):
        self.val = val

    def __lt__(self, other):
        # 逆转比较关系
        return self.val > other.val

# 在 key 元组中直接使用包装类
data_sorted = sorted(data, key=lambda x: (ReverseOrder(x[0]), x[1]))

六、综合总结与技术选型决策

最后，为了让大家在面对不同数据形态时能够迅速做出最恰当的技术选型，我们将多条件排序的关键路径总结为如下选型指南：

掌握了 key 参数构造比较元组的本质，无论是二维列表、嵌套字典还是复杂的 ORM 实体对象，你都能以清晰、高效且符合 Python 惯用语法的方式完成多条件排序。