分享python中sort的使用方法实例.doc

《分享Python中sort的使用方法实例》

在Python编程中，排序是数据处理的核心操作之一。无论是处理列表、元组还是自定义对象，Python提供的排序功能都能高效完成任务。本文将系统介绍`sort()`方法和`sorted()`函数的区别与使用场景，结合实际案例深入解析参数配置、稳定性保障及性能优化技巧，帮助开发者掌握从基础到进阶的排序技能。

一、基础排序：列表的`sort()`方法

Python内置的`list.sort()`方法用于对列表进行原地排序（直接修改原列表），返回值为`None`。这是最基础的排序方式，适用于数字、字符串等可比较类型的简单排序。

# 数字列表升序排序
numbers = [3, 1, 4, 1, 5, 9]
numbers.sort()
print(numbers)  # 输出: [1, 1, 3, 4, 5, 9]

# 字符串列表按字母顺序排序
words = ["banana", "apple", "cherry"]
words.sort()
print(words)  # 输出: ['apple', 'banana', 'cherry']

默认情况下，`sort()`按升序排列。若需降序，可通过`reverse=True`参数实现：

numbers = [3, 1, 4, 1, 5, 9]
numbers.sort(reverse=True)
print(numbers)  # 输出: [9, 5, 4, 3, 1, 1]

二、`sorted()`函数：通用排序解决方案

与`sort()`不同，`sorted()`函数可对任何可迭代对象（如列表、元组、字典等）进行排序，并返回新的排序后列表，原对象保持不变。

# 对元组排序
numbers_tuple = (3, 1, 4, 1, 5, 9)
sorted_numbers = sorted(numbers_tuple)
print(sorted_numbers)  # 输出: [1, 1, 3, 4, 5, 9]

# 对字典的键排序
data = {"apple": 3, "banana": 1, "cherry": 4}
sorted_keys = sorted(data)
print(sorted_keys)  # 输出: ['apple', 'banana', 'cherry']

两者的核心区别如下表所示：

特性	`sort()`方法	`sorted()`函数
作用对象	仅列表	任何可迭代对象
是否修改原对象	是（原地排序）	否（返回新列表）
返回值	`None`	排序后的新列表

三、自定义排序：`key`参数详解

当默认排序无法满足需求时，可通过`key`参数指定排序依据。`key`接受一个函数，该函数会被应用到每个元素上，排序基于函数的返回值进行。

1. 按字符串长度排序

words = ["banana", "apple", "cherry", "kiwi"]
words.sort(key=len)
print(words)  # 输出: ['kiwi', 'apple', 'banana', 'cherry']

2. 按元组的第二个元素排序

pairs = [(1, "one"), (3, "three"), (2, "two")]
pairs.sort(key=lambda x: x[1])  # 按字符串排序
print(pairs)  # 输出: [(1, 'one'), (3, 'three'), (2, 'two')]

# 更复杂的示例：按数字大小排序
pairs.sort(key=lambda x: x[0])
print(pairs)  # 输出: [(1, 'one'), (2, 'two'), (3, 'three')]

3. 忽略大小写的字符串排序

words = ["Banana", "apple", "Cherry", "kiwi"]
words.sort(key=lambda s: s.lower())
print(words)  # 输出: ['apple', 'Banana', 'Cherry', 'kiwi']

四、多级排序：结合多个条件

通过`key`函数返回元组，可实现多级排序。Python会依次比较元组的每个元素，直到分出大小。

# 按名字长度排序，长度相同则按字母顺序
names = ["Alice", "Bob", "Charlie", "David"]
names.sort(key=lambda x: (len(x), x))
print(names)  # 输出: ['Bob', 'Alice', 'David', 'Charlie']

实际应用案例：对学生成绩进行多级排序（先按总分，再按数学成绩）：

students = [
    {"name": "Alice", "math": 90, "english": 85},
    {"name": "Bob", "math": 85, "english": 90},
    {"name": "Charlie", "math": 90, "english": 80}
]

# 按总分降序，总分相同按数学成绩降序
students.sort(key=lambda s: (-(s["math"] + s["english"]), -s["math"]))
for student in students:
    print(student)
# 输出:
# {'name': 'Alice', 'math': 90, 'english': 85}
# {'name': 'Charlie', 'math': 90, 'english': 80}
# {'name': 'Bob', 'math': 85, 'english': 90}

五、稳定性与性能优化

Python的排序算法是稳定的，即相等元素的相对顺序在排序后保持不变。这在处理复杂数据时尤为重要：

# 稳定排序示例
data = [("a", 3), ("b", 2), ("c", 2), ("d", 1)]
# 先按数字排序，再按字母排序（利用稳定性）
data.sort(key=lambda x: x[0])  # 按字母排序
data.sort(key=lambda x: x[1])  # 按数字排序（稳定保持字母顺序）
print(data)
# 输出: [('d', 1), ('b', 2), ('c', 2), ('a', 3)]

对于大数据量排序，可考虑以下优化：

1. 使用`key`而非`cmp`（Python 3已移除`cmp`参数）
2. 对数值型数据，`key`函数应尽可能简单
3. 避免在`key`中执行耗时操作（如I/O操作）

六、自定义对象排序

通过实现`__lt__`（小于）方法或使用`key`函数，可对自定义类对象进行排序。

方法1：实现比较方法

class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score
    
    def __lt__(self, other):
        return self.score 

方法2：使用`key`函数（更灵活）

class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score

students = [
    Student("Alice", 90),
    Student("Bob", 85),
    Student("Charlie", 95)
]
students.sort(key=lambda s: s.score)  # 按分数排序
# 或 students.sort(key=lambda s: (-s.score, s.name)) 多级排序
for s in students:
    print(s.name, s.score)

七、常见问题与解决方案

问题1：混合类型排序报错

# 错误示例：数字和字符串混合
data = [3, "apple", 1, "banana"]
data.sort()  # TypeError: '

问题2：降序排序的两种方式

numbers = [3, 1, 4, 1, 5]

# 方法1：reverse=True
numbers.sort(reverse=True)
print(numbers)  # [5, 4, 3, 1, 1]

# 方法2：key取负数（仅适用于数字）
numbers.sort(key=lambda x: -x)
print(numbers)  # [5, 4, 3, 1, 1]

# 字符串降序需用reverse
words = ["banana", "apple"]
words.sort(reverse=True)
print(words)  # ['banana', 'apple']

问题3：对字典的值排序

data = {"apple": 3, "banana": 1, "cherry": 4}

# 按值升序排序
sorted_items = sorted(data.items(), key=lambda x: x[1])
print(sorted_items)  # 输出: [('banana', 1), ('apple', 3), ('cherry', 4)]

# 按值降序排序
sorted_items = sorted(data.items(), key=lambda x: x[1], reverse=True)
print(sorted_items)  # 输出: [('cherry', 4), ('apple', 3), ('banana', 1)]

八、性能对比：`sort()` vs `sorted()`

在大多数情况下，两者性能差异可忽略。但以下场景需注意：

1. 当需要保留原列表时，必须使用`sorted()`
2. 对超大列表排序，`sort()`可能稍快（避免创建新列表）
3. 链式操作时，`sorted()`更简洁：

# 链式操作示例
data = [3, 1, 4, 1, 5]
result = sorted(data, reverse=True)[:3]  # 取前3大元素
print(result)  # 输出: [5, 4, 3]

九、高级应用：装饰-排序-去装饰模式

当排序条件复杂时，可采用"装饰-排序-去装饰"模式（DSU模式）：

# 按字符串的第二个字母排序
words = ["apple", "banana", "cherry", "date"]

# 装饰：为每个元素添加排序键
decorated = [(word[1], word) for word in words]
# 排序
decorated.sort()
# 去装饰
result = [word for (_, word) in decorated]
print(result)  # 输出: ['apple', 'date', 'banana', 'cherry']

使用`key`参数的等价实现（更简洁）：

words = ["apple", "banana", "cherry", "date"]
words.sort(key=lambda word: word[1])
print(words)  # 输出: ['apple', 'date', 'banana', 'cherry']

十、总结与最佳实践

1. 需要修改原列表时用`sort()`，否则用`sorted()`
2. 简单排序直接使用默认行为
3. 复杂排序优先使用`key`参数而非自定义比较函数
4. 多级排序通过`key`返回元组实现
5. 注意排序的稳定性，必要时利用该特性
6. 对自定义对象，实现`__lt__`或使用`key`函数

关键词：Python排序、sort方法、sorted函数、key参数、多级排序、稳定性、自定义对象排序

简介：本文全面解析Python中sort()方法和sorted()函数的使用，涵盖基础排序、自定义排序、多级排序、稳定性保障及性能优化，通过大量实例演示对列表、字典、自定义对象的排序技巧，适合Python开发者提升数据处理能力。

《分享python中sort的使用方法实例.doc》

将本文以doc文档格式下载到电脑，方便收藏和打印

推荐度：

点击下载文档