Python中的sort()和sorted()用法示例解析

目录

• 一、list.sort()
• 参数说明
• 常用内置函数
• 基本用法示例
• 自定义函数示例
• lambda表达式示例
• operator模块的函数示例
• 二、sorted()函数
• 参数说明
• 基本用法示例
• 按自定义规则排序示例
• 多级排序示例
• 对字典的键或值排序
• 三、sort和sorted的排序算法
• Timsort 的核心原理
• Timsort 的好处
• Timsort广泛应用

sort()是列表（list）的内置方法，直接对原列表进行排序（原地排序），不返回新列表。

key（可选）：指定一个函数（内置或自定义），用于从每个元素中提取比较键（如 key=str.lower）。
reverse（可选）：布尔值，True 表示降序，False 表示升序（默认）。

abs(x)：按绝对值排序（适用于数字）。
len(x)：按长度排序（适用于字符串、列表等）。
str.lower(x) 或 str.upper(x)：忽略大小写排序（适用于字符串）。
int(x) 或 float(x)：转换为数值后排序（适用于字符串数字）。
ord(x)：按字符的 ASCII 码排序（适用于单个字符）。

numbers = [3, 1, 4, 1, 5, 9, 2]
# 升序排序（默认）
numbers.sort()
print(numbers)  
# [1, 1, 2, 3, 4, 5, 9]
# 降序排序
numbers.sort(reverse=True)
print(numbers) 
# [9, 5, 4, 3, 2, 1, 1]
# 按绝对值排序
numbers = [-3, 1, -4, 2]
numbers.sort(key=abs)
print(numbers)  
# [1, 2, -3, -4]

# 返回元组的第 2 个元素
def get_second_element(item):
    return item[1]  
data = [("Alice", 25), ("Bob", 20), ("Jack", 30)]
data.sort(key=get_second_element)  # 按年龄排序
print(data)
# [('Bob', 20), ('Alice', 25), ('Jack', 30)]

lambda是一种匿名函数，适用于简单的key逻辑

# 按字符串的最后一个字符排序
words = ["apple", "banana", "cherry"]
words.sort(key=lambda x: x[-1]) 
print(words)
# ['banana', 'apple', 'cherry']

operator 模块提供了一些高效的 key 函数：
operator.itemgetter(n)：获取可迭代对象的第 n 个元素（适用于元组、字典等）。
operator.attrgetter(‘attr’)：获取对象的属性（适用于类实例）。

from operator import itemgetter
data = [("Alice", 25), ("Bob", 20), ("Jack", 30)]
# 按年龄排序（等同于 lambda x: x[1]）
data.sort(key=itemgetter(1))
print(data)
# [('Bob', 20), ('Alice', 25), ('Jack', 30)]

sorted()是Python内置函数，对所有可迭代对象（如列表、元组、字典等）进行排序，返回一个新列表，原对象不变。

iterable：要排序的可迭代对象（如列表、元组、字符串等）。
key（可选）：同 sort()，指定比较键。
reverse（可选）：同 sort()，控制排序顺序。

# 对列表排序
numbers = [3, 1, 4, 1, 5]
sorted_numbers = sorted(numbers)
print(sorted_numbers)
# [1, 1, 3, 4, 5]
# 对字符串排序（按字符的 ASCII 码）
word = "python"
sorted_word = sorted(word)
print(sorted_word)
# ['h', 'n', 'o', 'p', 't', 'y']
# 对元组排序
data = (("Alice", 25), ("Bob", 20), ("Jack", 30))
sorted_data = sorted(data, key=lambda x: x[1])  # 按年龄排序
print(sorted_data)
# [('Bob', 20), ('Alice', 25), ('Jack', 30)]

words = ["banana", "watermelon", "apple"]
# 按单词长度排序
sorted_words = sorted(words, key=len)
print(sorted_words)
# ['apple', 'banana', 'watermelon']

people = [("Alice", 25), ("Bob", 20), ("Charlie", 25)]
# 先按年龄升序，再按姓名降序
sorted_people = sorted(people, key=lambda x: (x[1], -ord(x[0][0])))
print(sorted_people)
# [('Bob', 20), ('Charlie', 25), ('Alice', 25)]

scores = {"Alice": 90, "Charlie": 75, "Bob": 85}
# 按键排序
sorted_by_name = sorted(scores.items())
print(sorted_by_name)
# [('Alice', 90), ('Bob', 85), ('Charlie', 75)]
# 按值排序
sorted_by_score = sorted(scores.items(), key=lambda x: x[1])
print(sorted_by_score)
# [('Charlie', 75), ('Bob', 85), ('Alice', 90)]

list.sort()和sorted()函数使用的排序算法是Timsort，这是一种混合、稳定的排序算法，结合了归并排序（Merge Sort） 和 插入排序（Insertion Sort）的优点，并且效率极高。

自适应排序：
Timsort 根据输入数据的特点自适应地选择排序策略：

• 对小规模数据（通常是 <=64个元素），直接使用插入排序（因为在小数据量上插入排序的常数因子更小，速度更快）；
• 对大规模数据，采用归并排序的分治思想，但会利用数据的现有顺序（如部分已排序的子序列）。

利用数据的自然有序性：
Timsort 会扫描数据，识别并分割已经有序的片段（称为 run），然后通过归并排序将这些 run 合并。如果数据本身有部分有序，Timsort 的效率会显著高于传统归并排序。

稳定性：
Timsort是稳定排序，即相等元素的相对顺序在排序后保持不变。这对多关键字排序（如先按年龄排序，再按姓名排序）非常有用。

时间复杂度：
最坏情况：O(nlogn)（与归并排序相同）。
最佳情况：O(n)（当输入数据已有序或接近有序时，利用插入排序优化）。
平均情况：O(nlogn)。

实际数据友好：现实中的数据通常部分有序（如日志按时间接近有序），Timsort 能高效利用这一点。

平衡性能：对于不同规模和数据分布，Timsort 在平均和最坏情况下均表现良好（平均和最坏时间复杂度均为 O(n log n)）。

Java
Arrays.sort() 和 Collections.sort()
JavaScript (V8 引擎)
V8 引擎（Chrome、Node.js）
Swift
标准库的 sort() 方法
Rust
slice::sort 和 slice::sort_by
Kotlin
sort() 和 sorted() 函数
C#（部分场景）
Enumerable.OrderBy LINQ 方法

到此这篇关于Python中的sort()和sorted()用法示例解析的文章就介绍到这了,更多相关python sort()和sorted()用法内容请搜索风君子博客以前的文章或继续浏览下面的相关文章希望大家以后多多支持风君子博客！

您可能感兴趣的文章:

• Python3 sort和sorted用法+cmp_to_key()函数详解
• Python中sorted()用法案例代码
• Python列表排序 list.sort方法和内置函数sorted用法
• Python3 中sorted() 函数的用法
• python内置函数sorted()用法深入分析
• Python中的 sort 和 sorted的用法与区别
• python的sorted用法详解