Python列表排序全解析：从基础到高级技巧-代码聚汇网

Python列表排序全解析：从基础到高级技巧

第三世界的妖孽·2026-08-27·阅读 22 GEO检测（免费）

Python排序列表排序sort方法

|难度：普通|阅读约 21 分钟

1. Python列表排序的基础方法

在Python中，列表是最常用的数据结构之一，排序操作几乎是每个Python开发者每天都会遇到的常规任务。列表排序看似简单，但其中包含了许多值得深入探讨的技术细节和实用技巧。

Python提供了多种内置方法来对列表进行排序，每种方法都有其特定的使用场景和性能特点。最基础的方法是使用列表对象的sort()方法和内置的sorted()函数。这两个方法看起来功能相似，但在实际使用中存在关键区别：

python复制# 使用sort()方法对列表进行原地排序
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
numbers.sort()
print(numbers)  # 输出：[1, 1, 2, 3, 4, 5, 6, 9]

# 使用sorted()函数返回新的排序列表
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # 输出：[1, 1, 2, 3, 4, 5, 6, 9]
print(numbers)  # 原列表未被修改：[3, 1, 4, 1, 5, 9, 2, 6]

关键区别：sort()是列表方法，会直接修改原列表；sorted()是内置函数，会返回一个新的排序后的列表，原列表保持不变。

在实际开发中，选择使用sort()还是sorted()取决于具体需求。如果不需要保留原始列表的顺序，使用sort()可以节省内存；如果需要保留原始列表，则应使用sorted()。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 自定义排序规则

Python的排序功能非常灵活，允许开发者通过key参数和reverse参数来自定义排序规则。这种灵活性使得Python能够处理各种复杂的排序需求。

2.1 使用key参数自定义排序

key参数接受一个函数，该函数将被应用于列表中的每个元素，然后根据函数的返回值进行排序。这在处理复杂数据结构时特别有用：

python复制# 按字符串长度排序
words = ['banana', 'pie', 'Washington', 'book']
words.sort(key=len)
print(words)  # 输出：['pie', 'book', 'banana', 'Washington']

# 按学生成绩排序
students = [
    {'name': 'Alice', 'grade': 89},
    {'name': 'Bob', 'grade': 72},
    {'name': 'Charlie', 'grade': 95}
]
students.sort(key=lambda x: x['grade'], reverse=True)
print(students)
# 输出：[{'name': 'Charlie', 'grade': 95}, {'name': 'Alice', 'grade': 89}, {'name': 'Bob', 'grade': 72}]

2.2 多条件排序

在实际应用中，经常需要根据多个条件进行排序。Python可以通过在key函数中返回元组来实现多条件排序：

python复制# 先按长度排序，长度相同的按字母顺序排序
words = ['banana', 'pie', 'apple', 'orange', 'pear']
words.sort(key=lambda x: (len(x), x))
print(words)  # 输出：['pear', 'pie', 'apple', 'banana', 'orange']

# 学生先按成绩降序，成绩相同的按姓名升序
students = [
    {'name': 'Alice', 'grade': 89},
    {'name': 'Bob', 'grade': 72},
    {'name': 'Charlie', 'grade': 95},
    {'name': 'David', 'grade': 89}
]
students.sort(key=lambda x: (-x['grade'], x['name']))
print(students)
# 输出：[{'name': 'Charlie', 'grade': 95}, {'name': 'Alice', 'grade': 89}, {'name': 'David', 'grade': 89}, {'name': 'Bob', 'grade': 72}]

实用技巧：对于数字类型的排序，可以通过取负数来实现降序排列，而不必设置reverse=True，这在多条件排序中特别有用。

3. 高级排序技术

除了基本的排序方法外，Python还提供了一些高级排序技术，可以处理更复杂的排序需求。

3.1 使用operator模块提高性能

对于简单的key函数，使用operator模块中的itemgetter、attrgetter和methodcaller可以提高排序性能：

python复制from operator import itemgetter, attrgetter

# 使用itemgetter排序字典列表
students = [
    {'name': 'Alice', 'grade': 89},
    {'name': 'Bob', 'grade': 72},
    {'name': 'Charlie', 'grade': 95}
]
students.sort(key=itemgetter('grade'), reverse=True)
print(students)

# 使用attrgetter排序对象列表
class Student:
    def __init__(self, name, grade):
        self.name = name
        self.grade = grade
    def __repr__(self):
        return f"Student(name='{self.name}', grade={self.grade})"

student_objects = [
    Student('Alice', 89),
    Student('Bob', 72),
    Student('Charlie', 95)
]
student_objects.sort(key=attrgetter('grade'), reverse=True)
print(student_objects)

3.2 稳定排序的特性

Python的排序算法是稳定的，这意味着当多个元素具有相同的key时，它们将保持原有的相对顺序。这一特性在多条件排序中非常有用：

python复制# 先按姓排序，再按名排序
names = ['John Doe', 'Jane Smith', 'Alice Johnson', 'Bob Smith']
names.sort(key=lambda x: x.split()[1])  # 按姓排序
names.sort(key=lambda x: x.split()[0])  # 按名排序
print(names)
# 输出：['Alice Johnson', 'Bob Smith', 'Jane Smith', 'John Doe']

注意：为了实现多条件排序，应该先按次要条件排序，再按主要条件排序，这样才能保证最终结果符合预期。

4. 性能优化与大型列表排序

当处理大型列表时，排序性能变得尤为重要。Python的排序算法使用的是TimSort算法，这是一种结合了归并排序和插入排序的混合算法，在最坏情况下的时间复杂度为O(n log n)。

4.1 排序大型数据集的技巧

对于非常大的数据集，可以考虑以下优化策略：

使用生成器表达式而非列表推导式：当key函数复杂时，使用生成器可以节省内存
考虑使用内置函数：如min()和max()可能比排序整个列表更高效
使用heapq模块：对于只需要前N个元素的情况，heapq.nlargest()和heapq.nsmallest()更高效

python复制import heapq

# 获取最大的3个元素
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
largest = heapq.nlargest(3, numbers)
print(largest)  # 输出：[9, 6, 5]

4.2 排序与其他操作的结合

在实际应用中，排序经常与其他列表操作结合使用，如过滤、映射等。Python的生成器表达式和内置函数可以高效地组合这些操作：

python复制# 过滤后排序
numbers = [3, -1, 4, -1, 5, -9, 2, 6]
positive_sorted = sorted(x for x in numbers if x > 0)
print(positive_sorted)  # 输出：[2, 3, 4, 5, 6]

# 映射后排序
words = ['banana', 'pie', 'apple', 'orange', 'pear']
sorted_by_second_letter = sorted(words, key=lambda x: x[1] if len(x) > 1 else '')
print(sorted_by_second_letter)  # 输出：['banana', 'apple', 'pear', 'pie', 'orange']

5. 特殊场景下的排序技巧

Python的排序功能非常灵活，可以处理各种特殊场景下的排序需求。

5.1 处理包含None值的列表

当列表中包含None值时，直接排序会抛出TypeError。可以通过自定义key函数来处理这种情况：

python复制data = [3, None, 1, 4, None, 2]
# 将None转换为一个极大值或极小值
data.sort(key=lambda x: float('inf') if x is None else x)
print(data)  # 输出：[1, 2, 3, 4, None, None]

5.2 自然排序（人类可读的排序）

对于包含数字的字符串，常规的字典序排序可能不符合人类直觉（如"file2"会排在"file10"前面）。可以使用第三方库natsort来实现自然排序：

python复制from natsort import natsorted

files = ['file1', 'file10', 'file2', 'file20']
sorted_files = natsorted(files)
print(sorted_files)  # 输出：['file1', 'file2', 'file10', 'file20']

5.3 随机排序与打乱列表

有时需要随机打乱列表顺序，可以使用random模块的shuffle函数：

python复制import random

numbers = [1, 2, 3, 4, 5]
random.shuffle(numbers)
print(numbers)  # 可能的输出：[3, 1, 5, 2, 4]

注意：random.shuffle是原地操作，会直接修改原列表。如果需要保留原列表，可以先复制一份。

6. 排序在数据分析中的应用

在数据分析和处理中，排序是最基础也是最重要的操作之一。结合Pandas等数据分析库，排序功能变得更加强大。

6.1 使用Pandas进行排序

Pandas提供了更高级的排序功能，特别适合处理结构化数据：

python复制import pandas as pd

data = {
    'name': ['Alice', 'Bob', 'Charlie', 'David'],
    'age': [25, 30, 22, 30],
    'score': [89, 72, 95, 89]
}
df = pd.DataFrame(data)

# 按单列排序
df_sorted = df.sort_values('score', ascending=False)
print(df_sorted)

# 按多列排序
df_sorted = df.sort_values(['age', 'score'], ascending=[True, False])
print(df_sorted)

6.2 分组排序

在数据分析中，经常需要对分组后的数据进行排序：

python复制# 按年龄分组后，每组内按分数排序
df['rank'] = df.groupby('age')['score'].rank(ascending=False)
print(df)

7. 排序算法原理与性能比较

虽然Python内置的排序方法已经非常高效，但了解不同排序算法的原理和性能特点对于开发者来说仍然很重要。

7.1 Python使用的TimSort算法

Python的list.sort()和sorted()使用的都是TimSort算法，这是一种稳定的、自适应的排序算法，结合了归并排序和插入排序的优点：

对于小规模数据（通常<=64个元素），使用插入排序
对于大规模数据，识别数据中的"自然运行"（已经有序的子序列）
合并这些运行，类似于归并排序
在最坏情况下时间复杂度为O(n log n)，最好情况下为O(n)

7.2 不同排序算法的比较

虽然在实际开发中我们通常使用内置排序，但了解不同算法的特点有助于在特殊情况下选择合适的算法：

算法	平均时间复杂度	最坏时间复杂度	空间复杂度	稳定性
冒泡排序	O(n²)	O(n²)	O(1)	稳定
选择排序	O(n²)	O(n²)	O(1)	不稳定
插入排序	O(n²)	O(n²)	O(1)	稳定
快速排序	O(n log n)	O(n²)	O(log n)	不稳定
归并排序	O(n log n)	O(n log n)	O(n)	稳定
TimSort	O(n log n)	O(n log n)	O(n)	稳定

在实际应用中，对于几乎有序的数据，插入排序和TimSort表现最好；对于随机数据，快速排序和归并排序表现较好；对于小规模数据，插入排序通常是最佳选择。

8. 排序在实际项目中的应用案例

让我们看几个排序在实际项目中的应用案例，这些案例展示了排序功能的强大和灵活。

8.1 文件系统操作中的排序

在处理文件系统时，经常需要对文件名进行排序：

python复制import os

# 获取当前目录下的文件并按修改时间排序
files = os.listdir('.')
files.sort(key=lambda x: os.path.getmtime(x))
print(files)

# 按文件大小排序
files.sort(key=lambda x: os.path.getsize(x))
print(files)

8.2 网络数据处理中的排序

处理网络数据时，经常需要对IP地址进行排序：

python复制import socket

ips = ['192.168.1.1', '10.0.0.1', '172.16.0.1', '192.168.1.10']
# 将IP地址转换为整数后排序
ips.sort(key=lambda x: [int(i) for i in x.split('.')])
print(ips)  # 输出：['10.0.0.1', '172.16.0.1', '192.168.1.1', '192.168.1.10']

8.3 数据库查询结果排序

虽然数据库通常有自己的排序功能，但有时需要在应用层对结果进行排序：

python复制# 模拟从数据库获取的数据
users = [
    {'id': 1, 'name': 'Alice', 'join_date': '2022-01-15'},
    {'id': 2, 'name': 'Bob', 'join_date': '2021-11-03'},
    {'id': 3, 'name': 'Charlie', 'join_date': '2022-03-22'}
]

# 按加入日期排序
users.sort(key=lambda x: x['join_date'])
print(users)

9. 排序的边界条件与错误处理

在实际开发中，处理各种边界条件和潜在错误是保证代码健壮性的关键。

9.1 处理不可比较的元素

当列表中包含不可比较的元素时，排序会抛出TypeError。可以通过自定义key函数来处理这种情况：

python复制mixed = [1, 'two', 3, 'four']
# 尝试直接排序会抛出TypeError
try:
    mixed.sort()
except TypeError as e:
    print(f"Error: {e}")

# 解决方案1：过滤掉不可排序的元素
sortable = [x for x in mixed if isinstance(x, (int, float))]
sortable.sort()
print(sortable)  # 输出：[1, 3]

# 解决方案2：自定义比较函数（Python3中已移除cmp参数，需使用functools.cmp_to_key）
from functools import cmp_to_key

def compare(a, b):
    try:
        return (a > b) - (a < b)
    except TypeError:
        a_type = type(a).__name__
        b_type = type(b).__name__
        return (a_type > b_type) - (a_type < b_type)

mixed.sort(key=cmp_to_key(compare))
print(mixed)  # 输出：[1, 3, 'four', 'two']

9.2 处理大型数据集的排序

对于非常大的数据集，内存可能成为限制因素。可以考虑以下策略：

使用生成器表达式：避免在内存中创建中间列表
分批处理：将数据分成多个小块，分别排序后再合并
使用数据库：对于超大数据集，考虑使用数据库的排序功能

python复制# 使用生成器表达式处理大型数据集
def large_dataset():
    for i in range(1, 1000001):
        yield i

# 获取最大的100个数字
import heapq
largest = heapq.nlargest(100, large_dataset())
print(largest[:10])  # 输出前10个最大的数字

10. Python排序的最佳实践

根据多年Python开发经验，我总结了以下排序最佳实践：

优先使用内置排序：Python的内置排序已经高度优化，在大多数情况下都是最佳选择
避免不必要的排序：如果只需要最大值或最小值，使用max()/min()更高效
考虑使用operator模块：对于简单的key函数，itemgetter和attrgetter可以提高性能
注意排序的稳定性：利用稳定排序特性实现多条件排序
处理边界条件：考虑None值、不可比较元素等特殊情况
考虑内存使用：对于大型数据集，考虑使用生成器或分批处理
保持代码可读性：复杂的key函数可以定义为普通函数而非lambda表达式
测试性能关键路径：如果排序是性能瓶颈，进行基准测试比较不同方法

python复制# 可读性更好的key函数定义
def get_sort_key(item):
    # 复杂的排序逻辑可以放在这里
    return (item['priority'], -item['timestamp'])

items = [
    {'priority': 1, 'timestamp': 100},
    {'priority': 2, 'timestamp': 50},
    {'priority': 1, 'timestamp': 200}
]
items.sort(key=get_sort_key)
print(items)

在实际项目中，合理使用排序功能可以显著提高代码的效率和可读性。掌握Python排序的各种技巧和最佳实践，是每个Python开发者必备的技能。