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

一、list.sort()

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表达式示例

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

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

operator模块的函数示例

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()函数

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)]

三、sort和sorted的排序算法

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

timsort 的核心原理

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

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

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

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

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

timsort 的好处

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

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

timsort广泛应用

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()用法内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！