Python排序方法有哪些：list.sort()与sorted()的核心区别

在 Python 中对数据进行排序时，最核心的工具是列表独有的 list.sort() 方法与内置全局函数 sorted()。二者虽然底层均采用稳定高效的 Timsort 算法，并且都支持 key 映射与 reverse 反转参数，但其设计哲学和应用场景存在根本区别：list.sort() 仅适用于列表（list），直接在原列表内存空间上就地排序（In-place），执行后返回 None，不产生新列表对象；而 sorted() 可以接收任何可迭代对象（如元组、字典、集合或生成器），排序时绝不破坏原数据，始终返回一个全新创建的已排序列表。明确二者在修改方式、适用对象及内存开销上的差异，是写出高效且安全 Python 代码的基础。

一、Python 常见排序方法概览

Python 标准库针对排序需求提供了简洁而统一的设计。日常开发中，无论面对何种数据结构，排序逻辑主要通过以下两个核心入口展开：

• 列表专属方法：list.sort() —— 这是定义在 list 类上的成员方法，必须通过列表实例显式调用（如 nums.sort()）。它直接作用于当前列表内部的连续指针数组，完成元素的就地调换。
• 全局内置函数：sorted() —— 这是 Python 内置的一等公民函数，能够接收任何合法的可迭代对象（Iterable）作为参数，例如 sorted(my_tuple) 或 sorted(my_dict)，并统一以新列表的形式输出排序结果。

对于元组（tuple）、字典（dict）和集合（set）等不可变或无序数据结构，Python 并未提供专有的 .sort() 方法。元组本身不可被原地修改，字典和集合在底层结构上也并不依靠顺序数组维持逻辑，因此当需要对它们进行排序处理时，必须统一借助 sorted() 函数提取元素并生成有序列表。

值得注意的是，无论调用 list.sort() 还是 sorted()，Python 底层采用的都是高度优化的 Timsort 混合排序算法。Timsort 结合了归并排序与插入排序的优点，具备自适应特性：最坏时间复杂度为 O(n log n)，在遇到已经部分有序的数据时，最佳时间复杂度可达 O(n)。更关键的是，Timsort 是一种稳定排序（Stable Sort）算法——当多个元素的比较键值相等时，排序后依然能够严格保留其在原始序列中的前后相对次序。

二、list.sort() 与 sorted() 的三大核心区别

虽然两者最终都能得到按规则排列的数据，但在底层实现机制、内存模型和调用方式上存在显著区别，具体体现在以下三个维度：

1. 作用对象与调用入口不同

list.sort() 只能由 list 类型的变量调用。如果尝试在元组、集合或字符串上使用 .sort()，Python 会直接抛出 AttributeError 异常：

# 正确用法：针对列表对象调用
numbers = [5, 2, 8, 1]
numbers.sort()

# 错误示例：元组没有 sort 方法
data_tuple = (5, 2, 8, 1)
# data_tuple.sort()  # 触发 AttributeError: 'tuple' object has no attribute 'sort'

而 sorted() 是一个全局内置函数，具备更广泛的通用性。它通过 Python 的迭代协议依次遍历输入对象，能够无缝处理元组、字典键值、集合甚至自定义生成器：

# 对元组排序，返回已排序的新列表
sorted_from_tuple = sorted((5, 2, 8, 1))  # 结果为 [1, 2, 5, 8]

# 对字典排序，默认按键进行排序并返回键列表
student_scores = {'Bob': 88, 'Alice': 95, 'Tom': 72}
sorted_keys = sorted(student_scores)     # 结果为 ['Alice', 'Bob', 'Tom']

2. 原地修改（In-Place）与返回值的关键陷阱

这是初学者最容易踩坑的技术细节。Python 遵循“命令与查询分离”（Command-Query Separation）的设计规范：凡是会直接修改对象内部状态的原地操作方法，通常都返回 None，以此警示开发者该方法具有副作用。

因此，list.sort() 的返回值永远是 None。如果误将其赋值给变量，会导致原数据变量被置空：

my_list = [3, 1, 4, 1, 5]
# 典型错误：误认为 sort() 会返回排好序的列表
result = my_list.sort()

print(result)   # 输出为 None
print(my_list)  # my_list 本身已经被修改为 [1, 1, 3, 4, 5]

相反，sorted() 从不修改任何传入的原始数据。它会完整保留原序列的原始样貌，并将排序结果打包进一个全新分配的列表实例中返回：

original = [3, 1, 4, 1, 5]
new_list = sorted(original)

print(original)  # 保持原状：[3, 1, 4, 1, 5]
print(new_list)  # 全新列表：[1, 1, 3, 4, 5]

3. 内存开销与执行性能的权衡

在底层内存结构上，list.sort() 直接在已有列表的连续指针存储区内进行元素交换，整个排序过程仅需要 O(1) 的辅助空间开销。在处理数十万乃至数百万元素的大型列表时，这种原地操作能够避免额外的内存分配与垃圾回收压力。

而 sorted() 无论处理何种数据，都必须在内存中开辟一块足以容纳全部元素指针的新列表区域，因而具备 O(n) 的额外空间复杂度。如果系统内存资源极其敏感，或者原列表体积庞大且不再需要原序，盲目使用 sorted() 会导致瞬时内存占用翻倍。

三、选型指南：何时选用 sort，何时选用 sorted

在工程实践中，选择哪种排序方式不应随心所欲，而应依据数据结构类型、数据只读安全需求以及系统资源限制进行精准决策：

1. 优先选择 list.sort() 的典型场景

• 确认操作对象为 list 且原始顺序无须保留：在单向数据清洗或批处理管道中，原列表在排序后即可直接进入后续计算，无需保留旧的次序状态。
• 处理大规模数据以防止内存溢出：当待排序列表包含数百万条记录时，避免分配 O(n) 的额外列表空间可以极大缓解垃圾回收压力，防止瞬时内存使用率超出物理配额。
• 面向对象编程中修改内部封装状态：在自定义类的业务方法中维护其内部私有列表成员时，使用 self._records.sort() 能清晰体现对象内部状态的就地变更语义。

2. 推荐或必须使用 sorted() 的场景

• 待排序对象为非列表类型：需要对元组、字典键值对、集合或文件迭代器进行有序排布时，sorted() 是唯一的标准解法。
• 防御性编程与避免函数副作用：当编写工具函数接收外部传入的列表参数时，若在函数体内直接执行 items.sort()，会直接篡改调用方所在作用域的数据。使用 sorted(items) 能有效保证入参的纯洁性与不可变性。
• 链式调用与即时循环遍历：sorted() 返回全新列表，支持直接嵌入迭代语法中，例如 for item in sorted(dataset):，代码结构更为紧凑流畅。
• 需要同时维护多个维度的排序视图：例如保留原学生名单的同时，分别生成一份按学号排序的名册和一份按成绩排序的名册，可以通过多次调用 sorted() 轻松实现。

四、核心参数用法：key 与 reverse 的高级技巧

为了保证 API 设计的高度一致性，Python 为 list.sort() 和 sorted() 提供了完全统一的高阶控制参数：key 和 reverse。无论使用哪种排序方式，这两个参数的工作逻辑完全一致。

1. key 参数的设计哲学与性能优势

key 参数接收一个单入参函数（可以是匿名函数 lambda、内置函数或对象方法）。在实际排序前，Python 会针对每一个元素调用一次该函数，提取出一个用于比较大小的“代理键”（Proxy Key）。

该机制最突出的优势在于单次计算特性：Timsort 会在排序开始前对每个元素只执行一次 key 映射并缓存计算结果，绝不会在元素相互比较的过程中反复调用 key 函数。这一特性在 Python 内部实现了经典的 Schwartzian 变换（Decorate-Sort-Undecorate），大幅降低了复杂计算的耗时。

# 忽略英文字符串大小写的排序
words = ['banana', 'Apple', 'cherry', 'date']
words.sort(key=str.lower)
# 排序结果为 ['Apple', 'banana', 'cherry', 'date']

# 按照复杂对象的属性或字典字段排序
students = [
    {'name': 'Bob', 'score': 85},
    {'name': 'Alice', 'score': 92},
    {'name': 'Tom', 'score': 85}
]
sorted_students = sorted(students, key=lambda s: s['score'])

2. reverse 参数的逆序控制

默认情况下，reverse=False 表示升序排列。将 reverse=True 传入后，排序机制会直接翻转比较规则，实现降序排列：

scores = [68, 95, 82, 74]
scores.sort(reverse=True)
# 结果为 [95, 82, 74, 68]

3. 多条件复合排序与 Timsort 稳定性的精妙结合

在业务开发中，经常遇到“先按主要条件排序，主条件相同时按次要条件排序”的多维度需求。在 Python 中，有两种极为优雅的实现手段：

1. 返回元组作为比较键：Python 的元组在比较大小时，会严格按照从左到右的次序逐一对比元素。因此，让 key 函数返回一个包含多个属性的元组即可实现复合排序。如果需要其中某一维数值降序，直接取负号即可（如 key=lambda x: (x.grade, -x.score)）。
2. 利用稳定排序进行多趟排序：对于无法简单通过负号取反的字段（如字符串），可以充分利用 Timsort 的稳定性：先对次要条件排序，再对主要条件排序。因为 Timsort 绝不会打乱次要条件排好的同分相对顺序，最终结果必然完全符合多级次序。

五、常见排错与注意事项

在实际编码中，排序功能除了基础调用外，还涉及以下几处极易引发线上 Bug 的隐藏边界：

• 不可比较类型引发的 TypeError：在 Python 3 中，所有参与排序的元素之间必须具备明确的小于（<）比较定义。如果列表中混合了整数和字符串（例如 [1, '2', 3]），执行排序会立即抛出 TypeError: '<' not supported between instances of 'str' and 'int'。此时必须使用 key 参数（如 key=int 或 key=str）将它们归一化到同一类型域后再进行比较。
• 迭代器排序后的“枯竭”现象：当把一个生成器表达式或文件迭代器传入 sorted(gen) 时，生成器会被一次性完全消耗。排序后得到的虽然是一个标准的列表，但原生成器对象已经处于耗尽状态，无法再次被二次迭代。
• 自定义类的比较契约：若要对自定义类的对象直接排序（不使用 key 参数），该类必须显式实现 __lt__（小于）方法，或者配合 functools.total_ordering 装饰器补全富比较方法；否则 Python 无法推导对象之间的大小先后。

六、全文总结

掌握 list.sort() 与 sorted() 的差异，本质上是在就地性能与数据安全性之间做出权衡。概括而言：

• 面对纯粹的 list 数据，若追求极致执行性能且原列表无须保留，果断使用 list.sort()，并时刻牢记它返回 None；
• 面对元组、字典、集合等非列表对象，或在编写需要避免副作用的通用函数时，坚定选择 sorted()，安全获取崭新的有序列表；
• 善用 key 参数的单次映射机制与 Timsort 的稳定性，能够轻松实现忽略大小写、对象属性提取及多级复合排序等高级业务需求。