sorted函数是Python内置的高阶排序函数,其核心定位在于:以非破坏性方式返回已排序的新序列对象,原序列保持不变。这与列表的sort方法形成鲜明对比——后者原地排序,直接修改原列表,返回None。
从设计哲学来看,sorted函数遵循函数式编程范式,强调不可变性(immutability)原则,适用于需要保留原始数据场景;而sort方法则更贴近命令式编程风格,追求极致性能与内存效率。
该函数自Python 2.4起引入,作为列表sort方法的补充,解决了“需要排序但不能修改原序列”的普遍需求。其设计者Guido van Rossum明确指出:sorted是“序列排序的通用接口”,支持任意可迭代对象,而不仅限于列表。
典型应用场景包括:
值得注意的是,sorted函数在实现上直接调用Timsort算法——这是Python 2.3以来的默认排序算法,由Tim Peters开发,兼具稳定性与O(n log n)时间复杂度,并针对已部分有序的数据进行了高度优化。
sorted函数的标准语法为:
sorted(iterable, *, key=None, reverse=False)
其参数设计极为精简:仅一个位置参数iterable,两个关键字参数key与reverse,且key与reverse必须以关键字形式传入(通过*分隔)。
返回值为新列表对象,类型为list,无论输入是列表、元组、集合、字典还是任意可迭代对象,均返回列表形式的排序结果。
参数说明:
⚠️ 注意:当key函数返回值不可比较时(如混合类型),将抛出TypeError;当key函数返回值可比较但元素本身不可比较时(如元组中含不可比较对象),将抛出TypeError。
函数签名设计体现了Python对API清晰性的追求:通过强制关键字参数,避免用户误用位置参数顺序;通过统一返回列表,简化类型推断;通过支持任意可迭代对象,提升函数通用性。
key参数是sorted函数最强大的特性,它通过“提取-比较-映射”三步实现灵活排序:
典型用法示例:
# 按字符串长度排序
sorted(['apple', 'pie', 'a', 'caramel'], key=len)
# → ['a', 'pie', 'apple', 'caramel']
# 忽略大小写排序
sorted(['Banana', 'apple', 'Cherry'], key=str.lower)
# → ['apple', 'Banana', 'Cherry']
# 按元组第二项排序
sorted([(1, 3), (2, 1), (3, 2)], key=lambda x: x[1])
# → [(2, 1), (3, 2), (1, 3)]
⚠️ 关键细节:
reverse参数控制排序方向,但其内部实现并非简单反转结果,而是调整比较器行为:
# 降序排序(reverse=True)
sorted([3, 1, 4, 1, 5], reverse=True)
# → [5, 4, 3, 1, 1]
# 复合排序:先按长度降序,再按字典序升序
sorted(['apple', 'pie', 'a', 'caramel'], key=len, reverse=True)
# → ['caramel', 'apple', 'pie', 'a']
性能提示:使用reverse=True比先升序再切片反转快约15%,因Timsort可直接利用反向比较路径。
💡 进阶技巧:通过组合key与reverse可实现复杂排序规则。例如,对学生成绩排序:数学成绩降序,语文成绩升序:
students = [
{'name': 'Alice', 'math': 95, 'chinese': 88},
{'name': 'Bob', 'math': 90, 'chinese': 92},
{'name': 'Cathy', 'math': 95, 'chinese': 85}
]
sorted(students, key=lambda s: (-s['math'], s['chinese']))
# → Alice, Cathy, Bob
sorted函数基于Timsort算法,具备以下关键特性:
稳定性验证示例:
# 稳定性演示:按首字母排序,相同字母保持原序
words = ['apple', 'ant', 'banana', 'apricot']
sorted(words, key=lambda x: x[0])
# → ['apple', 'ant', 'apricot', 'banana'] # apple在ant前
类型安全示例(错误):
# 混合类型导致TypeError
sorted([1, 'a', 2.5], key=str)
# → TypeError: '<' not supported between instances of 'str' and 'int'
正确做法:确保key函数返回值类型一致:
# 统一转字符串比较(按字典序)
sorted([1, 'a', 2.5], key=lambda x: str(x))
# → ['1', '2.5', 'a']
以下展示10个高频场景的sorted函数用法,覆盖基础排序到高阶技巧:
# 列表排序(升序/降序)
sorted([5, 2, 9, 1, 5]) → [1, 2, 5, 5, 9]
sorted([5, 2, 9, 1, 5], reverse=True) → [9, 5, 5, 2, 1]
# 元组排序(按首元素)
sorted([(2, 'b'), (1, 'a'), (3, 'c')]) → [(1, 'a'), (2, 'b'), (3, 'c')]
# 字符串排序(按Unicode码)
sorted('Python') → ['P', 'h', 'n', 'o', 't', 'y']
# 按键排序
d = {'b': 2, 'a': 1, 'c': 3}
sorted(d) → ['a', 'b', 'c']
sorted(d.items()) → [('a', 1), ('b', 2), ('c', 3)]
# 按值排序
sorted(d.items(), key=lambda x: x[1]) → [('a', 1), ('b', 2), ('c', 3)]
from datetime import datetime
class Student:
def __init__(self, name, grade, birth):
self.name = name
self.grade = grade
self.birth = birth
students = [
Student('Alice', 3, datetime(2000, 5, 12)),
Student('Bob', 2, datetime(2001, 3, 8)),
Student('Cathy', 3, datetime(2000, 1, 25))
]
# 按年级升序,再按出生日期降序
sorted(students, key=lambda s: (s.grade, -s.birth.timestamp()))
# → Cathy, Alice, Bob
# 文件排序:按扩展名分组,组内按大小降序
files = [
('data.csv', 1024),
('app.py', 512),
('script.py', 256),
('image.png', 2048)
]
sorted(files, key=lambda x: (x[0].split('.')[-1], -x[1]))
# → [('image.png', 2048), ('data.csv', 1024),
# ('script.py', 256), ('app.py', 512)]
# 按绝对值排序
sorted([3, -1, 4, -2, 1], key=abs)
# → [-1, 1, -2, 3, 4]
# 按字符串中数字排序
sorted(['file10.txt', 'file2.txt', 'file1.txt'],
key=lambda x: int(''.join(filter(str.isdigit, x))))
# → ['file1.txt', 'file2.txt', 'file10.txt']
sorted函数的稳定性(stability)是其核心设计特性:当两个元素的键值相等时,保持它们在原始序列中的相对顺序。这一特性对多级排序至关重要。
# 原始序列:同姓氏按原始顺序
names = [
('张', '三'),
('李', '四'),
('张', '五'),
('李', '二')
]
# 按姓氏排序(稳定)
sorted(names, key=lambda x: x[0])
# → [('张', '三'), ('张', '五'), ('李', '四'), ('李', '二')]
# 若使用不稳定排序,结果可能为:
# [('张', '五'), ('张', '三'), ('李', '二'), ('李', '四')] # 错误!
多级排序(multi-level sort)依赖稳定性实现:先按次要关键字排序,再按主要关键字排序,最终结果自动满足多级顺序要求。
# 错误做法:分别排序(破坏稳定性)
names_sorted_by_age = sorted(names, key=lambda x: get_age(x[1]))
names_sorted_by_surname = sorted(names_sorted_by_age, key=lambda x: x[0])
# → 年龄顺序被破坏!
# 正确做法:单次多级排序
sorted(names, key=lambda x: (x[0], get_age(x[1])))
# → 先按姓氏,再按年龄(稳定保证)
Tim Peters在2002年设计Timsort时,明确将稳定性作为核心目标,使其成为处理部分有序数据的最优解。
| 特性 | sorted函数 | list.sort方法 |
|---|---|---|
| 适用对象 | 任意可迭代对象 | 仅列表 |
| 是否修改原对象 | 否(返回新列表) | 是(原地修改) |
| 返回值 | 新列表 | None |
| 内存占用 | 较高(需复制) | 低(原地操作) |
| 链式操作 | 支持(如:sorted(filter(...))) | 不支持 |
| 性能 | 略低(复制开销) | 略高 |
| 线程安全 | 较高(不修改原对象) | 较低(可能引发竞态) |
import timeit
# 测试1000000个元素
data = list(range(1000000))
# sorted函数
time_sorted = timeit.timeit(lambda: sorted(data), number=10)
# → ~1.82秒
# list.sort方法
time_sort = timeit.timeit(lambda: data.copy().sort(), number=10)
# → ~1.58秒
# 原地排序(破坏数据)
time_inplace = timeit.timeit(lambda: data.sort(), number=10)
# → ~1.45秒
现实场景中,95%以上应使用sorted函数——其安全性与灵活性远超微小的性能差异。
多字段排序是sorted函数的高级应用,通过复合键(tuple)实现多级排序逻辑。
# 按成绩降序,同分按学号升序
students = [
{'id': 102, 'score': 95},
{'id': 101, 'score': 95},
{'id': 103, 'score': 90}
]
sorted(students, key=lambda s: (-s['score'], s['id']))
# → [{'id':101,'score':95}, {'id':102,'score':95}, {'id':103,'score':90}]
当需要不同字段排序方向不同时,Python无原生支持,需通过技巧实现:
# 需求:数学成绩降序,语文成绩升序,英语成绩降序
students = [
{'math':95, 'chinese':88, 'english':92},
{'math':95, 'chinese':92, 'english':88},
{'math':90, 'chinese':95, 'english':95}
]
# 方案1:负值技巧(仅限数值)
sorted(students, key=lambda s: (-s['math'], s['chinese'], -s['english']))
# 方案2:元组反转(通用)
sorted(students, key=lambda s: (s['math'], -s['chinese'], s['english']), reverse=True)
# → 需调整逻辑:先升序再反转,但稳定性可能被破坏!
# 低效:每次比较都调用key函数
sorted(data, key=lambda x: expensive_calculation(x))
# 高效:预计算键值(Schwartzian Transform)
keyed = [(expensive_calculation(x), x) for x in data]
sorted_keyed = sorted(keyed)
result = [x for _, x in sorted_keyed]
此技巧在键计算成本高时可提升30%+性能,但增加内存占用。
Timsort是混合排序算法,结合归并排序与插入排序优点:
实测性能对比(100万个随机整数):
sorted(data) → 1.25秒 # Timsort
sorted(data, key=id) → 1.82秒 # key调用开销
sorted(data, reverse=True) → 1.38秒
# 高内存:sorted复制整个数据
data = list(range(10000000))
sorted_data = sorted(data) # 额外100MB+内存
# 低内存:使用heapq合并已排序流
import heapq
sorted_data = list(heapq.merge(stream1, stream2, stream3))
❌ 错误认知:sorted((3,1,2))返回元组
✅ 正确:始终返回列表,无论输入类型
type(sorted((3,1,2))) → <class 'list'>
type(sorted({3,1,2})) → <class 'list'>
# 危险:key函数有副作用
def side_effect(x):
print(f"Processing {x}")
return x
sorted([3,1,2], key=side_effect)
# → 输出顺序不确定!可能非线性
# 错误:比较不同不可比较类型
sorted([1, 'a', 2.5])
# → TypeError: '<' not supported...
# 正确:统一转换类型
sorted([1, 'a', 2.5], key=str) # 按字符串比较
sorted([1, 'a', 2.5], key=repr) # 按repr比较
# 错误:以为reverse=True会反转key结果
sorted(['apple', 'pie'], key=len, reverse=True)
# → ['apple', 'pie'](正确:先按len提取[5,3],再降序)
# 正确:复合键实现混合方向
sorted(data, key=lambda x: (x[0], -x[1]))