Python中，对列表进行排序主要使用 `list.sort()` 方法或内置的 `sorted()` 函数。两者核心区别在于是否修改原列表。`sort()` 是列表对象的内置方法，会**就地修改**列表本身，返回 `None`；而 `sorted()` 是内置函数，接受一个可迭代对象并**返回一个新的、排序后的列表**，原列表保持不变[ref_6]。两者都支持两个关键的相同参数：`reverse`（控制升降序）和 `key`（指定排序规则），并且它们执行的排序都是**稳定排序**[ref_2][ref_4]。 ### 一、`sorted()` 与 `sort()` 的核心区别 | 特性 | `sorted(iterable, ...)` (函数) | `list.sort(...)` (方法) | | :--- | :--- | :--- | | **输入/适用对象** | 任何可迭代对象 (列表、元组、字符串、字典视图等) | 仅**列表**对象 | | **返回值** | 返回一个**新的、排序后的列表** | **就地修改**列表，返回 `None` | | **原数据是否改变** | 原可迭代对象保持不变 | 原列表被永久性排序覆盖[ref_3] | | **调用方式** | 内置函数：`sorted(list_obj)` | 列表方法：`list_obj.sort()` | ```python # sorted() 与 sort() 的核心区别示例 original_list = [3, 1, 4, 1, 5, 9] # 使用 sorted() 函数 sorted_list = sorted(original_list) print(f'sorted() 返回的新列表：{sorted_list}') # 输出：[1, 1, 3, 4, 5, 9] print(f'原列表保持不变：{original_list}') # 输出：[3, 1, 4, 1, 5, 9] # 使用 sort() 方法 original_list.sort() # 注意：此方法无返回值，直接修改原列表 print(f'调用 sort() 后的原列表：{original_list}') # 输出：[1, 1, 3, 4, 5, 9] ``` ### 二、主要参数详解与高级用法 #### 1. `reverse` 参数：控制排序方向 默认 `reverse=False` 为升序排序；设置为 `True` 则为降序排序[ref_1][ref_2]。 ```python nums = [5, 2, 8, 1, 9] # 升序 (默认) ascending_sorted = sorted(nums) # [1, 2, 5, 8, 9] print(f"升序排列: {ascending_sorted}") # 降序 descending_sorted = sorted(nums, reverse=True) # [9, 8, 5, 2, 1] print(f"降序排列: {descending_sorted}") # sort() 的降序用法 nums_copy = nums[:] # 复制列表，避免修改上面的nums nums_copy.sort(reverse=True) # 直接修改 nums_copy 为降序 print(f"sort()降序后: {nums_copy}") ``` #### 2. `key` 参数：自定义排序规则 `key` 参数接收一个函数，该函数会应用于每一个元素，并根据其返回值进行排序。这是实现复杂排序的关键[ref_4][ref_5]。 ```python # 案例1：按字符串长度排序 words = ["apple", "fig", "banana", "kiwi"] sorted_by_length = sorted(words, key=len) # key=len 表示使用 len() 函数获取每个元素的长度作为排序依据 print(f"按长度排序: {sorted_by_length}") # 输出：['fig', 'kiwi', 'apple', 'banana'] # 案例2：按字符串的小写形式排序（解决大小写敏感问题） mixed_case = ["Apple", "banana", "Cherry", "date"] sorted_ignore_case = sorted(mixed_case, key=str.lower) # 将所有元素转为小写后再比较 print(f"忽略大小写排序: {sorted_ignore_case}") # 输出：['Apple', 'banana', 'Cherry', 'date'] # 案例3：对嵌套结构排序 students = [ {"name": "Alice", "score": 88}, {"name": "Bob", "score": 95}, {"name": "Charlie", "score": 78} ] # 按'分数'降序排列 students_sorted_by_score = sorted(students, key=lambda x: x['score'], reverse=True) print(f"按分数降序排列的学生:") for student in students_sorted_by_score: print(f" {student['name']}: {student['score']}") ``` #### 3. 实现稳定排序 Python的 `sorted()` 和 `list.sort()` 都是**稳定排序**。这意味着当两个元素的 `key` 返回值相同时，它们在结果列表中的相对顺序会与输入时的相对顺序保持一致[ref_2][ref_4]。这在多级排序中非常有用。 ```python data = [("apple", 2), ("fig", 1), ("banana", 2), ("kiwi", 1)] # 先按元组的第二个元素（数字）排序 sorted_data = sorted(data, key=lambda x: x[1]) print(f"稳定排序结果: {sorted_data}") # 输出：[('fig', 1), ('kiwi', 1), ('apple', 2), ('banana', 2)] # 注意：同为1的 'fig' 和 'kiwi' 保持了输入顺序；同为2的 'apple' 和 'banana' 也是如此。 ``` ### 三、综合应用场景与选择建议 #### 场景1：数据持久化排序 若需要保留原始数据，同时获得一个排序后的副本用于展示或分析，应使用 `sorted()`。 ```python original_data = [34, 12, 78, 56] report_data = sorted(original_data) # 生成用于报表的排序数据 # 后续 original_data 仍保持原样，可用于其他原始计算 ``` #### 场景2：内存敏感或原地操作 如果列表很大，且排序后不再需要原始顺序，使用 `sort()` 可以避免创建新列表的内存开销，效率更高[ref_6]。 ```python big_list = [ ... ] # 一个非常大的列表 big_list.sort() # 原地排序，内存效率高 ``` #### 场景3：对非列表可迭代对象排序 `sorted()` 可以排序任何可迭代对象，包括元组、字符串等[ref_6]。 ```python # 对元组排序 tuple_data = (5, 2, 8, 1) sorted_tuple_result = sorted(tuple_data) # 返回列表：[1, 2, 5, 8] # 对字符串排序（返回字符列表） string_data = "python" sorted_chars = sorted(string_data) # 返回：['h', 'n', 'o', 'p', 't', 'y'] ``` #### 场景4：使用 `operator` 模块优化复杂 `key` 函数 对于基于对象属性或嵌套索引的排序，使用 `operator` 模块的函数比 `lambda` 表达式更高效且可读[ref_5]。 ```python import operator students = [("Bob", 20, "B"), ("Alice", 22, "A"), ("Charlie", 20, "A")] # 目标：先按年龄（索引1）升序，再按班级（索引2）升序 # 使用 itemgetter 获取多个索引 sorted_students = sorted(students, key=operator.itemgetter(1, 2)) print(f"使用itemgetter多级排序: {sorted_students}") # 输出：[('Charlie', 20, 'A'), ('Bob', 20, 'B'), ('Alice', 22, 'A')] ``` **选择建议总结**： * **需要新列表且保留原数据** → **`sorted()`** * **直接修改原列表，节省内存** → **`sort()`** * **排序非列表的可迭代对象** → **`sorted()`** * **进行多级或复杂规则排序** → 灵活使用 **`key`** 参数，结合 `lambda` 或 `operator` 模块。 * **需要稳定排序保证** → 两者均可，默认满足。