一、list.sort()

sort()是列表（list）的內(nèi)置方法，直接對原列表進行排序（原地排序），不返回新列表。

參數(shù)說明

key（可選）：指定一個函數(shù)（內(nèi)置或自定義），用于從每個元素中提取比較鍵（如 key=str.lower）。
reverse（可選）：布爾值，True 表示降序，F(xiàn)alse 表示升序（默認）。

常用內(nèi)置函數(shù)

abs(x)：按絕對值排序（適用于數(shù)字）。
len(x)：按長度排序（適用于字符串、列表等）。
str.lower(x) 或 str.upper(x)：忽略大小寫排序（適用于字符串）。
int(x) 或 float(x)：轉(zhuǎn)換為數(shù)值后排序（適用于字符串數(shù)字）。
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]

自定義函數(shù)示例

# 返回元組的第 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是一種匿名函數(shù)，適用于簡單的key邏輯

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

operator模塊的函數(shù)示例

operator 模塊提供了一些高效的 key 函數(shù)：
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()函數(shù)

sorted()是Python內(nèi)置函數(shù)，對所有可迭代對象（如列表、元組、字典等）進行排序，返回一個新列表，原對象不變。

參數(shù)說明

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

按自定義規(guī)則排序示例

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()函數(shù)使用的排序算法是Timsort，這是一種混合、穩(wěn)定的排序算法，結(jié)合了歸并排序（Merge Sort） 和 插入排序（Insertion Sort）的優(yōu)點，并且效率極高。

Timsort 的核心原理

自適應(yīng)排序：
Timsort 根據(jù)輸入數(shù)據(jù)的特點自適應(yīng)地選擇排序策略：

• 對小規(guī)模數(shù)據(jù)（通常是 <=64個元素），直接使用插入排序（因為在小數(shù)據(jù)量上插入排序的常數(shù)因子更小，速度更快）；
• 對大規(guī)模數(shù)據(jù)，采用歸并排序的分治思想，但會利用數(shù)據(jù)的現(xiàn)有順序（如部分已排序的子序列）。

利用數(shù)據(jù)的自然有序性：
Timsort 會掃描數(shù)據(jù)，識別并分割已經(jīng)有序的片段（稱為 run），然后通過歸并排序?qū)⑦@些 run 合并。如果數(shù)據(jù)本身有部分有序，Timsort 的效率會顯著高于傳統(tǒng)歸并排序。

穩(wěn)定性：
Timsort是穩(wěn)定排序，即相等元素的相對順序在排序后保持不變。這對多關(guān)鍵字排序（如先按年齡排序，再按姓名排序）非常有用。

時間復雜度：
最壞情況：O(nlogn)（與歸并排序相同）。
最佳情況：O(n)（當輸入數(shù)據(jù)已有序或接近有序時，利用插入排序優(yōu)化）。
平均情況：O(nlogn)。

Timsort 的好處

實際數(shù)據(jù)友好：現(xiàn)實中的數(shù)據(jù)通常部分有序（如日志按時間接近有序），Timsort 能高效利用這一點。

平衡性能：對于不同規(guī)模和數(shù)據(jù)分布，Timsort 在平均和最壞情況下均表現(xiàn)良好（平均和最壞時間復雜度均為 O(n log n)）。

Timsort廣泛應(yīng)用

Java
Arrays.sort() 和 Collections.sort()
JavaScript (V8 引擎)
V8 引擎（Chrome、Node.js）
Swift
標準庫的 sort() 方法
Rust
slice::sort 和 slice::sort_by
Kotlin
sort() 和 sorted() 函數(shù)
C#（部分場景）
Enumerable.OrderBy LINQ 方法

到此這篇關(guān)于Python中的sort()和sorted()用法示例解析的文章就介紹到這了,更多相關(guān)python sort()和sorted()用法內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論