Python列表排序终极指南：`sort()`与`sorted()`函数详解及高级用法88

在Python编程中，数据排序是日常任务中不可或缺的一部分。无论是处理数据库查询结果、分析数据集、优化算法性能，还是仅仅为了美观地展示信息，高效且灵活的排序能力都至关重要。Python为我们提供了两种主要且功能强大的排序机制：列表的sort()方法和内置的sorted()函数。虽然它们都能实现排序功能，但在使用场景、行为模式和灵活性上存在显著差异。

作为一名专业的程序员，熟练掌握这两种工具及其高级用法（特别是key参数的巧妙运用）是提升代码质量和解决复杂排序问题的关键。本文将深入探讨sort()和sorted()的各项功能，从基础用法到高级定制，并结合丰富的代码示例，助您成为Python排序的专家。

Python排序的基石：`()`方法

()是Python列表中一个原地（in-place）排序的方法。这意味着它会直接修改原有的列表，而不会创建新的列表。由于其原地修改的特性，sort()方法不返回任何值（它返回None）。这一特性在内存优化方面非常有用，尤其是当处理大型列表时。

基本用法

默认情况下，sort()方法会按照升序对列表中的元素进行排序。
# 示例1：基本升序排序
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
print(f"原始列表: {numbers}")
()
print(f"排序后列表: {numbers}") # 输出: 原始列表: [3, 1, 4, 1, 5, 9, 2, 6]
# 排序后列表: [1, 1, 2, 3, 4, 5, 6, 9]
# 示例2：对字符串列表排序
words = ["banana", "apple", "cherry", "date"]
print(f"原始字符串列表: {words}")
()
print(f"排序后字符串列表: {words}") # 输出: 原始字符串列表: ['banana', 'apple', 'cherry', 'date']
# 排序后字符串列表: ['apple', 'banana', 'cherry', 'date']

注意：()之后，numbers列表的内容已经改变。如果您尝试打印()的返回值，会得到None。

逆序排序 (`reverse`参数)

如果您需要进行降序排序，可以传递reverse=True参数给sort()方法。
# 示例3：降序排序
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
print(f"原始列表: {numbers}")
(reverse=True)
print(f"降序排序后列表: {numbers}") # 输出: 原始列表: [3, 1, 4, 1, 5, 9, 2, 6]
# 降序排序后列表: [9, 6, 5, 4, 3, 2, 1, 1]

Python排序的利器：`sorted()`函数

与()方法不同，内置的sorted()函数可以对任何可迭代对象（如列表、元组、字符串、字典、集合等）进行排序，并返回一个新的已排序的列表。原始的可迭代对象保持不变。这一特性使得sorted()在需要保留原始数据结构而又想获取排序结果的场景中非常有用。

基本用法

sorted()函数接受一个可迭代对象作为参数，并返回一个新的排序后的列表。
# 示例4：对列表排序并生成新列表
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
print(f"原始列表: {numbers}")
sorted_numbers = sorted(numbers)
print(f"排序后的新列表: {sorted_numbers}") # 输出: 原始列表: [3, 1, 4, 1, 5, 9, 2, 6]
# 排序后的新列表: [1, 1, 2, 3, 4, 5, 6, 9]
print(f"原始列表（未改变）: {numbers}") # 输出: 原始列表（未改变）: [3, 1, 4, 1, 5, 9, 2, 6]
# 示例5：对元组排序
data_tuple = (3, 1, 4, 1, 5, 9, 2, 6)
sorted_tuple_as_list = sorted(data_tuple)
print(f"原始元组: {data_tuple}") # 输出: 原始元组: (3, 1, 4, 1, 5, 9, 2, 6)
print(f"排序后的列表（来自元组）: {sorted_tuple_as_list}") # 输出: 排序后的列表（来自元组）: [1, 1, 2, 3, 4, 5, 6, 9]
# 示例6：对字符串排序（按字符ASCII值）
string_data = "python"
sorted_string_as_list = sorted(string_data)
print(f"原始字符串: {string_data}") # 输出: 原始字符串: python
print(f"排序后的列表（来自字符串）: {sorted_string_as_list}") # 输出: 排序后的列表（来自字符串）: ['h', 'n', 'o', 'p', 't', 'y']
# 示例7：对字典的键排序
dict_data = {"apple": 3, "banana": 1, "cherry": 2}
sorted_keys = sorted(dict_data)
print(f"原始字典: {dict_data}") # 输出: 原始字典: {'apple': 3, 'banana': 1, 'cherry': 2}
print(f"排序后的字典键: {sorted_keys}") # 输出: 排序后的字典键: ['apple', 'banana', 'cherry']

逆序排序 (`reverse`参数)

与sort()方法一样，sorted()函数也支持reverse=True参数进行降序排序。
# 示例8：降序排序
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
sorted_numbers_desc = sorted(numbers, reverse=True)
print(f"降序排序后的新列表: {sorted_numbers_desc}") # 输出: 降序排序后的新列表: [9, 6, 5, 4, 3, 2, 1, 1]

排序的核心：`key`参数的魔法

sort()方法和sorted()函数都提供了一个强大的key参数，它允许我们指定一个函数，该函数将作用于可迭代对象的每个元素，并返回一个用于比较的值。换句话说，排序不是基于元素本身，而是基于key函数返回的结果。

key参数极大地增强了Python排序的灵活性，使其能够处理各种复杂的排序逻辑，例如根据对象的特定属性、字典的特定键、字符串的长度或自定义的计算结果进行排序。

使用`lambda`函数作为`key`

lambda函数是定义小型匿名函数的简洁方式，非常适合作为key参数的值。

排序列表中的元组

假设我们有一个学生列表，每个学生由一个元组表示(姓名, 年龄, 成绩)，我们想根据年龄进行排序。
# 示例9：根据元组的第二个元素（年龄）排序
students = [('Alice', 20, 'A'), ('Bob', 22, 'B'), ('Charlie', 20, 'C'), ('David', 21, 'A')]
print(f"原始学生列表: {students}")
# 根据年龄（第二个元素）升序排序
sorted_by_age = sorted(students, key=lambda student: student[1])
print(f"按年龄排序: {sorted_by_age}")
# 输出: [('Alice', 20, 'A'), ('Charlie', 20, 'C'), ('David', 21, 'A'), ('Bob', 22, 'B')]
# 根据年龄降序排序
sorted_by_age_desc = sorted(students, key=lambda student: student[1], reverse=True)
print(f"按年龄降序排序: {sorted_by_age_desc}")
# 输出: [('Bob', 22, 'B'), ('David', 21, 'A'), ('Alice', 20, 'A'), ('Charlie', 20, 'C')]
# 根据年龄（主键）和姓名（次键）排序
sorted_by_age_then_name = sorted(students, key=lambda student: (student[1], student[0]))
print(f"按年龄和姓名排序: {sorted_by_age_then_name}")
# 输出: [('Alice', 20, 'A'), ('Charlie', 20, 'C'), ('David', 21, 'A'), ('Bob', 22, 'B')]

在最后一个例子中，lambda student: (student[1], student[0])返回一个元组。Python在比较元组时，会按顺序比较每个元素。如果第一个元素相等，则比较第二个元素，以此类推。这实现了多级排序。

排序列表中的字典

假设我们有一个商品列表，每个商品由一个字典表示{'name': '...', 'price': ..., 'stock': ...}，我们想根据价格进行排序。
# 示例10：根据字典的特定键（价格）排序
products = [
{'name': 'Laptop', 'price': 1200, 'stock': 10},
{'name': 'Mouse', 'price': 25, 'stock': 50},
{'name': 'Keyboard', 'price': 75, 'stock': 30},
{'name': 'Monitor', 'price': 300, 'stock': 15}
]
print(f"原始商品列表: {products}")
# 根据价格升序排序
sorted_by_price = sorted(products, key=lambda p: p['price'])
print(f"按价格排序: {sorted_by_price}")
# 输出: [{'name': 'Mouse', 'price': 25, 'stock': 50}, {'name': 'Keyboard', 'price': 75, 'stock': 30}, {'name': 'Monitor', 'price': 300, 'stock': 15}, {'name': 'Laptop', 'price': 1200, 'stock': 10}]
# 根据库存降序排序
sorted_by_stock_desc = sorted(products, key=lambda p: p['stock'], reverse=True)
print(f"按库存降序排序: {sorted_by_stock_desc}")
# 输出: [{'name': 'Mouse', 'price': 25, 'stock': 50}, {'name': 'Keyboard', 'price': 75, 'stock': 30}, {'name': 'Monitor', 'price': 300, 'stock': 15}, {'name': 'Laptop', 'price': 1200, 'stock': 10}]

排序自定义对象

当处理自定义类实例时，key参数同样有效。
# 示例11：根据自定义对象的属性排序
class Person:
def __init__(self, name, age):
= name
= age
def __repr__(self): # 用于打印对象时更具可读性
return f"Person('{}', {})"
people = [
Person('Alice', 30),
Person('Bob', 25),
Person('Charlie', 35)
]
print(f"原始人物列表: {people}")
# 根据年龄属性排序
sorted_people_by_age = sorted(people, key=lambda p: )
print(f"按年龄排序: {sorted_people_by_age}")
# 输出: [Person('Bob', 25), Person('Alice', 30), Person('Charlie', 35)]

使用`operator`模块的`itemgetter`和`attrgetter`

对于元组的特定索引或字典的特定键，以及对象的特定属性，operator模块提供了itemgetter和attrgetter函数，它们通常比lambda函数更高效且代码更清晰，尤其是在处理多级排序时。
# 示例12：使用itemgetter排序元组和字典
from operator import itemgetter, attrgetter
students = [('Alice', 20, 'A'), ('Bob', 22, 'B'), ('Charlie', 20, 'C'), ('David', 21, 'A')]
products = [
{'name': 'Laptop', 'price': 1200, 'stock': 10},
{'name': 'Mouse', 'price': 25, 'stock': 50},
{'name': 'Keyboard', 'price': 75, 'stock': 30},
{'name': 'Monitor', 'price': 300, 'stock': 15}
]
# 按年龄（元组索引1）排序
sorted_students_by_age_ig = sorted(students, key=itemgetter(1))
print(f"按年龄（itemgetter）排序: {sorted_students_by_age_ig}")
# 按年龄和姓名（元组索引1和0）排序
sorted_students_by_age_name_ig = sorted(students, key=itemgetter(1, 0))
print(f"按年龄和姓名（itemgetter）排序: {sorted_students_by_age_name_ig}")
# 按价格（字典键'price'）排序
sorted_products_by_price_ig = sorted(products, key=itemgetter('price'))
print(f"按价格（itemgetter）排序: {sorted_products_by_price_ig}")
# 示例13：使用attrgetter排序自定义对象
class Person:
def __init__(self, name, age):
= name
= age
def __repr__(self):
return f"Person('{}', {})"
people = [
Person('Alice', 30),
Person('Bob', 25),
Person('Charlie', 35),
Person('Aaron', 30)
]
# 按年龄属性排序
sorted_people_by_age_ag = sorted(people, key=attrgetter('age'))
print(f"按年龄（attrgetter）排序: {sorted_people_by_age_ag}")
# 按年龄属性和姓名属性排序
sorted_people_by_age_name_ag = sorted(people, key=attrgetter('age', 'name'))
print(f"按年龄和姓名（attrgetter）排序: {sorted_people_by_age_name_ag}")

itemgetter和attrgetter可以接受多个参数，返回一个元组作为key，从而实现多级排序，与lambda x: (x[idx1], x[idx2])或lambda x: (x.attr1, x.attr2)的效果相同，但代码更简洁，有时性能也稍优。

深入理解：排序算法与性能

Python的排序实现是基于Timsort算法。Timsort是一种混合排序算法，结合了归并排序（Merge Sort）和插入排序（Insertion Sort）的优点。它由Tim Peters为Python设计，并已在Java和Android等其他平台中采用。
时间复杂度：Timsort在平均和最坏情况下都表现为O(N log N)的时间复杂度。在处理部分有序的数据时，它可以达到O(N)的最佳情况，效率非常高。
空间复杂度：在最坏情况下，Timsort的空间复杂度为O(N)，但在许多实际场景中，它能优化到O(log N)。
稳定性：Timsort是一种稳定的排序算法。这意味着如果两个元素在比较时被认为是相等的，它们在排序后的相对顺序会保持不变。稳定性对于多级排序非常重要，例如，先按年龄排序，再按姓名排序，如果年龄相同的学生，其原始的姓名顺序不会被打乱。

何时选择`sort()`，何时选择`sorted()`？

()：

优点：原地修改，不创建新列表，内存效率高。
缺点：只能用于列表，会修改原始数据，不返回排序结果（返回None）。
适用场景：当您只关心排序后的列表结果，且不再需要原始列表的未排序版本时，或者在内存受限的环境中处理大型列表时，使用sort()是首选。


sorted()：

优点：可用于任何可迭代对象，返回一个新的列表，不修改原始数据，更加灵活。
缺点：会创建新列表，可能会占用更多内存。
适用场景：当您需要保留原始数据结构，同时又想获取排序结果时；或者对非列表的可迭代对象进行排序时，sorted()是更合适的选择。

实用高级技巧与注意事项

字符串不区分大小写排序

默认情况下，字符串排序会区分大小写（大写字母的ASCII值小于小写字母）。通过key=可以实现不区分大小写的排序。
# 示例14：不区分大小写排序
words = ["Apple", "banana", "Cherry", "date"]
sorted_case_insensitive = sorted(words, key=)
print(f"不区分大小写排序: {sorted_case_insensitive}") # 输出: ['Apple', 'banana', 'Cherry', 'date'] (实际是['Apple', 'banana', 'Cherry', 'date']，相对顺序可能因Timsort内部实现而异，但逻辑上是按a,b,c,d排列)
# 正确输出应是：['Apple', 'banana', 'Cherry', 'date'] 或 ['banana', 'Apple', 'Cherry', 'date']
# 具体结果取决于稳定性：如果'Apple'和'apple'是相等的话，Timsort保证原先的相对顺序。
# 这里'Apple'和'apple'其实是不同的字符串，但它们的lower()结果相同。
# 更准确的输出应是：['Apple', 'banana', 'Cherry', 'date']，因为A,b,C,d的lower()排序后，原始字符串的相对位置保持。
# 为了更清晰展示，我们使用另一个例子
names = ["Bob", "alice", "Charlie", "david", "Anna"]
sorted_names = sorted(names, key=)
print(f"不区分大小写排序: {sorted_names}")
# 输出: ['alice', 'Anna', 'Bob', 'Charlie', 'david']

按长度排序

使用key=len可以按元素的长度进行排序。
# 示例15：按字符串长度排序
words = ["apple", "banana", "kiwi", "grapefruit"]
sorted_by_length = sorted(words, key=len)
print(f"按长度排序: {sorted_by_length}") # 输出: ['kiwi', 'apple', 'banana', 'grapefruit']

处理混合类型列表

在Python 3中，不同类型之间不能直接进行比较（例如，整数不能与字符串比较，会引发TypeError）。如果列表中包含混合类型，您需要提供一个key函数来统一它们的比较方式，或者确保比较的类型是兼容的。
# 示例16：混合类型列表排序（会引发TypeError）
# mixed_list = [1, 'b', 3, 'a']
# sorted_mixed = sorted(mixed_list) # 这会抛出 TypeError: '

2025-10-15

---

上一篇：Python字符串重排：从基础到高级，玩转字符序列的各种姿势

下一篇：打造Emacs高效Python开发环境：从零到精通