当前位置：首页 > 文章列表 > 文章 > python教程 > Python列表排序方法详解

Python列表排序方法详解

2025-11-02 23:18:39 0浏览收藏

亲爱的编程学习爱好者，如果你点开了这篇文章，说明你对《Python列表排序全攻略》很感兴趣。本篇文章就来给大家详细解析一下，主要介绍一下，希望所有认真读完的童鞋们，都有实质性的提高。

Python列表排序中，sort()和sorted()的主要区别在于：前者原地修改列表并返回None，后者返回新列表而不改变原列表。两者均支持reverse参数控制升降序，以及key参数实现自定义排序逻辑，如按长度、字典值或忽略大小写等。例如，words.sort(key=len)按字符串长度升序排列；sorted(data, key=str.lower)实现不区分大小写的排序。此外，Python使用稳定的Timsort算法，保证相同键值元素的相对顺序不变，这对多阶段排序至关重要——可先按次要条件排序，再按主要条件排序，结果仍能保持各组内先前的顺序。因此，当需保留原数据时应选用sorted()，追求效率且无需保留原始顺序时可用sort()。掌握key参数与稳定性特性，能有效应对复杂排序需求。

python中怎么给列表排序_Python列表排序方法详解

在Python中，给列表排序主要有两种核心方法：一种是利用列表自身提供的 sort() 方法进行“原地”排序，直接修改原列表；另一种是使用内置的 sorted() 函数，它会返回一个全新的已排序列表，而不会触动原始列表。这两种方式都支持升序、降序以及基于自定义规则的复杂排序。

解决方案

当我们需要对Python列表进行排序时，通常会用到以下两种策略，它们各有千秋，适用于不同的场景。

1. list.sort() 方法：原地修改，无返回值

这是列表对象自带的一个方法，顾名思义，它会直接在原列表上进行修改，将列表中的元素重新排列。它的一个显著特点是执行后会返回 None。这意味着如果你尝试 my_sorted_list = my_list.sort()，那么 my_sorted_list 将会是 None，这在初学时是很容易踩的坑。

# 示例：基本升序排序
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
print(f"原始列表: {numbers}")
numbers.sort() # 直接修改numbers列表
print(f"升序排序后: {numbers}")

# 示例：降序排序
data = ['banana', 'apple', 'cherry', 'date']
print(f"原始列表: {data}")
data.sort(reverse=True) # 使用reverse=True参数
print(f"降序排序后: {data}")

# 示例：自定义排序键 (按字符串长度排序)
words = ['apple', 'banana', 'kiwi', 'grapefruit']
print(f"原始列表: {words}")
words.sort(key=len) # 使用key参数，len函数会返回每个元素的长度作为排序依据
print(f"按长度排序后: {words}")

# 示例：按元组的第二个元素排序
items = [('apple', 3), ('banana', 1), ('cherry', 2)]
print(f"原始列表: {items}")
items.sort(key=lambda x: x[1]) # 使用lambda表达式作为key
print(f"按第二个元素排序后: {items}")

2. sorted() 内置函数：返回新列表，不修改原列表

与 list.sort() 不同，sorted() 是一个内置函数，它可以接受任何可迭代对象（不仅仅是列表），并返回一个全新的、已排序的列表。这意味着原始的可迭代对象（比如列表、元组、字符串等）会保持不变。在我看来，这种“非侵入式”的排序方式在很多场景下更安全、更灵活，尤其当你需要保留原始数据结构时。

# 示例：基本升序排序
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
print(f"原始列表: {numbers}")
sorted_numbers = sorted(numbers) # 返回一个新列表
print(f"升序排序后 (新列表): {sorted_numbers}")
print(f"原始列表依然不变: {numbers}")

# 示例：降序排序
data = ('banana', 'apple', 'cherry', 'date') # sorted()可以处理元组
print(f"原始元组: {data}")
sorted_data = sorted(data, reverse=True)
print(f"降序排序后 (新列表): {sorted_data}")
print(f"原始元组依然不变: {data}")

# 示例：自定义排序键 (按字符串长度排序)
words = {'apple', 'banana', 'kiwi', 'grapefruit'} # sorted()可以处理集合
print(f"原始集合: {words}")
sorted_words = sorted(words, key=len)
print(f"按长度排序后 (新列表): {sorted_words}")
print(f"原始集合依然不变: {words}")

这两种方法都提供了 reverse 参数用于控制升序（默认）或降序，以及一个强大的 key 参数，用于指定一个函数，该函数将作用于列表的每个元素，并返回一个用于比较的值。理解 key 参数的灵活运用，是掌握Python复杂排序的关键。

Python列表排序时，`sort()`和`sorted()`函数究竟有什么不同？

这确实是Python初学者常问的一个核心问题，也是我在实际编码中会反复权衡的选择。说白了，它们最根本的区别在于一个“原地修改”而另一个“返回新列表”。

list.sort() 方法是列表对象的一个成员函数。它直接在调用它的列表上进行操作，将列表的元素重新排列，并且不会返回任何值（确切地说是返回 None）。这意味着如果你有一个非常大的列表，并且你确定不需要保留其原始顺序，那么使用 sort() 会更高效，因为它避免了创建新列表所需的额外内存开销。在我看来，这有点像你直接整理你书架上的书，书的位置变了，但书架还是那个书架。然而，它的缺点也很明显：如果你后续还需要用到原始未排序的列表，那么你就得提前复制一份，否则数据就“一去不复返”了。我个人就遇到过几次，因为忘记 sort() 返回 None 而导致的 TypeError 错误，调试起来还挺让人挠头的。

相比之下，sorted() 是Python的内置函数，它接受任何可迭代对象作为参数（比如列表、元组、字符串、集合、字典的键等等），然后返回一个全新的、排好序的列表。原始的可迭代对象则完全不受影响。这就像你把书架上的书拍了一张照片，然后按照某个顺序在照片上重新排列，书架上的书本身并没有动。这种方式的优点在于它的“非破坏性”，你总是能保留原始数据，这在数据分析、日志处理等场景下非常有用，因为你可能需要对同一份数据进行多种不同的排序操作，或者在排序后还需要原始数据的上下文。当然，创建新列表会带来一定的内存和性能开销，但对于大多数应用来说，这种开销通常是可接受的，而且带来的代码清晰度和安全性往往更值得。

总结一下，选择哪个取决于你的具体需求：

选择 list.sort()： 当你需要对列表进行原地修改，并且不需要保留原始顺序时。它通常在性能和内存占用上略有优势。
选择 sorted()： 当你需要一个新排序列表，同时希望保持原始数据不变时；或者你需要排序的对象不是列表（比如元组、集合等）时。它的通用性和安全性更高。

理解这层差异，不仅仅是语法上的区别，更是编程哲学上的考量，关乎你如何管理和操作数据。

如何利用`key`参数实现复杂的自定义排序逻辑？

key 参数是Python排序功能中的一个“瑞士军刀”，它允许我们定义非常灵活和强大的自定义排序规则。它的工作原理是：key 参数接受一个函数，这个函数会在排序过程中作用于列表中的每一个元素。sort() 或 sorted() 不会直接比较元素本身，而是比较这个 key 函数返回的结果。这就像你有一堆学生档案，你不想直接按档案的厚度（元素本身）排序，而是想按档案里某个字段（比如学生的年龄或成绩）来排序。key 函数就是那个帮你从档案里提取出“年龄”或“成绩”的工具。

这里有一些实际应用中我经常会用到的 key 参数技巧：

按字符串长度排序：

words = ["apple", "banana", "kiwi", "grapefruit", "cat"]
# 按字符串长度升序
sorted_by_length = sorted(words, key=len)
print(f"按长度排序: {sorted_by_length}") # ['cat', 'kiwi', 'apple', 'banana', 'grapefruit']

len 函数就是我们的 key，它返回每个字符串的长度，然后 sorted() 就根据这些长度来排序。

按字典中特定键的值排序：

students = [
    {'name': 'Alice', 'age': 30, 'score': 95},
    {'name': 'Bob', 'age': 25, 'score': 88},
    {'name': 'Charlie', 'age': 30, 'score': 92}
]
# 按年龄升序
sorted_by_age = sorted(students, key=lambda student: student['age'])
print(f"按年龄排序: {sorted_by_age}")

# 进一步，如果年龄相同，按分数降序
# 这里我们返回一个元组作为key，Python会按元组元素的顺序进行比较
# 注意：为了实现年龄相同分数降序，需要将分数取负数，或者使用operator.itemgetter和reverse=True的组合
sorted_by_age_score = sorted(students, key=lambda student: (student['age'], -student['score']))
print(f"按年龄升序，年龄相同按分数降序: {sorted_by_age_score}")

lambda student: student['age'] 是一个匿名函数，它接收一个学生字典，并返回其 'age' 键的值。这在处理复杂数据结构时特别方便。当需要多条件排序时，返回一个元组作为 key 是一个非常优雅的解决方案，Python会依次比较元组中的元素。

忽略大小写排序：

names = ["Alice", "bob", "Charlie", "David"]
# 忽略大小写排序
sorted_case_insensitive = sorted(names, key=str.lower)
print(f"忽略大小写排序: {sorted_case_insensitive}") # ['Alice', 'bob', 'Charlie', 'David']

str.lower 函数将每个字符串转换为小写再进行比较，但实际排序的还是原始字符串。

使用 operator 模块的 attrgetter 或 itemgetter： 当处理对象列表或字典列表时，operator 模块提供了更简洁的 key 函数。

from operator import attrgetter, itemgetter

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __repr__(self):
        return f"Person('{self.name}', {self.age})"

people = [Person('Alice', 30), Person('Bob', 25), Person('Charlie', 30)]
# 按age属性排序
sorted_people_by_age = sorted(people, key=attrgetter('age'))
print(f"按年龄排序 (attrgetter): {sorted_people_by_age}")

# 按字典的特定键排序 (等同于lambda x: x['key'])
data_list = [{'id': 2, 'value': 'B'}, {'id': 1, 'value': 'A'}]
sorted_data_by_id = sorted(data_list, key=itemgetter('id'))
print(f"按ID排序 (itemgetter): {sorted_data_by_id}")

attrgetter 和 itemgetter 在性能上通常比 lambda 表达式略优，并且在代码可读性上也很不错。

掌握 key 参数的用法，几乎可以解决所有你能想到的自定义排序需求。它将比较逻辑从排序算法中抽象出来，让代码更加清晰和模块化。

Python列表排序的稳定性是什么？这对我的数据处理有何影响？

排序算法的“稳定性”是一个非常重要的概念，尤其是在处理具有重复元素或多属性数据时。简单来说，一个排序算法被称为是稳定的，如果它能够保证：对于所有具有相同排序键的元素，它们在排序后的相对顺序与它们在原始列表中的相对顺序保持一致。

Python的内置排序算法（无论是 list.sort() 还是 sorted()）都使用了 Timsort 算法，而 Timsort 是一个稳定的排序算法。这意味着我们可以放心地依赖这个特性来处理数据。

我们来看一个例子，这能更好地说明稳定性：

假设我们有一个学生列表，其中包含姓名和分数，并且我们想先按分数排序，然后（如果分数相同）再按学生在原始列表中的顺序来排序。

students = [
    {'name': 'Alice', 'score': 90, 'id': 1},
    {'name': 'Bob', 'score': 85, 'id': 2},
    {'name': 'Charlie', 'score': 90, 'id': 3},
    {'name': 'David', 'score': 85, 'id': 4},
    {'name': 'Eve', 'score': 95, 'id': 5}
]

# 假设我们想按分数排序
# 注意：Alice和Charlie都是90分，Bob和David都是85分
sorted_students = sorted(students, key=lambda s: s['score'])
print(f"按分数排序后的学生列表:\n{sorted_students}")

输出可能会是这样：

按分数排序后的学生列表:
[{'name': 'Bob', 'score': 85, 'id': 2},
 {'name': 'David', 'score': 85, 'id': 4},
 {'name': 'Alice', 'score': 90, 'id': 1},
 {'name': 'Charlie', 'score': 90, 'id': 3},
 {'name': 'Eve', 'score': 95, 'id': 5}]

观察结果，Bob (id:2) 和 David (id:4) 都得了85分。在原始列表中，Bob 在 David 之前。排序后，Bob 仍然在 David 之前。同样，Alice (id:1) 和 Charlie (id:3) 都得了90分。在原始列表中，Alice 在 Charlie 之前。排序后，Alice 依然在 Charlie 之前。这就是稳定性的体现。

这对数据处理有何影响？

多阶段排序的可靠性： 稳定性在进行多阶段排序时至关重要。例如，你可能想先按城市排序，然后对每个城市内部再按年龄排序。如果你的排序算法不稳定，那么当你第二次按年龄排序时，那些城市相同的元素在第一次排序中形成的相对顺序可能会被打乱。但由于Python的排序是稳定的，你可以先按年龄排序，再按城市排序，结果会是：城市相同的元素会保持它们按年龄排序后的相对顺序。

# 错误示例：先按年龄，再按城市（如果想城市内按年龄排，这是不对的）
# sorted_by_age = sorted(students, key=lambda s: s['age'])
# final_sorted = sorted(sorted_by_age, key=lambda s: s['city'])

# 正确做法：利用稳定性，先对次要条件排序，再对主要条件排序
employees = [
    {'name': 'A', 'city': 'NY', 'age': 30},
    {'name': 'B', 'city': 'LA', 'age': 25},
    {'name': 'C', 'city': 'NY', 'age': 28},
    {'name': 'D', 'city': 'LA', 'age': 30},
]
# 先按年龄排序 (次要条件)
sorted_by_age_first = sorted(employees, key=lambda e: e['age'])
# 再按城市排序 (主要条件)，由于稳定性，相同城市的员工会保持按年龄排序后的相对顺序
final_sorted_employees = sorted(sorted_by_age_first, key=lambda e: e['city'])
print(f"多阶段排序结果 (先按年龄，再按城市):\n{final_sorted_employees}")
# 期望结果：
# city='LA'的：B(25), D(30)
# city='NY'的：C(28), A(30)

输出：

多阶段排序结果 (先按年龄，再按城市):
[{'name': 'B', 'city': 'LA', 'age': 25},
 {'name': 'D', 'city': 'LA', 'age': 30},
 {'name': 'C', 'city': 'NY', 'age': 28},
 {'name': 'A', 'city': 'NY', 'age': 30}]

可以看到，LA的员工B和D，依然保持了B在D之前的年龄顺序；NY的员工C和A，也保持了C在A之前的年龄顺序。这就是稳定性的强大之处。

默认顺序的保留： 在某些情况下，数据可能已经预先按照某种“默认”或“录入”顺序排列。当进行一次新的排序时，如果排序键相同，我们往往希望保留这种原始的默认顺序。稳定性确保了这一点，避免了不必要的顺序变动。
调试和可预测性： 稳定的排序算法使得排序结果更具可预测性，这对于调试和理解代码行为非常有帮助。如果一个排序算法不稳定，那么即使输入数据相同，在特定情况下（例如，当有多个相同键的元素时），输出的相对顺序也可能不同，这会给调试带来困难。

因此，Python排序的稳定性是一个非常实用的特性，它简化了多条件排序的逻辑，并使得数据处理结果更加可靠和可预测。在设计数据处理流程时，我常常会利用这个特性来简化我的代码逻辑。

到这里，我们也就讲完了《Python列表排序方法详解》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于的知识点！