在 Python 中對一個可迭代對象進行排序是很常見的一個操作，一般會用到 sorted() 函數
num_list = [4, 2, 8, -9, 1, -3]
sorted_num_list = sorted(num_list)
print(sorted_num_list)
上面的代碼是對整數列表 num_list 按從小到大的順序進行排序，得到的結果如下
有時候不僅僅是對元素本身進行排序，而是在元素值的基礎上進行一些計算之后再進行比較，比如將 num_list 中的元素按照其平方值的大小進行排序。
在 Python 2 中，可以通過 sorted() 函數中的 cmp 或 key 參數來實現這種自定義的比較邏輯。cmp 比較函數接收兩個參數 x 和 y（x 和 y 都是列表中元素）并且返回一個數字，如果返回正數表示 x > y，返回 0 表示 x == y，返回負數表示 x y。key 函數接收一個參數，重新計算出一個結果，然后用計算出的結果參與排序比較。因此在 Python 2 中按平方值大小排序可以有下面兩種實現方式
num_list = [4, 2, 8, -9, 1, -3]
# cmp 參數只在 Python 2 中存在，Python 3 及之后的版本移除了 cmp 參數
sorted_num_list = sorted(num_list, cmp=lambda x, y: x ** 2 - y ** 2)
sorted_num_list = sorted(num_list, key=lambda x: x ** 2)
但是隨著 Python 3.0 的發布，cmp 參數也隨之被移除了，也就是說在 Python 3 中自定義比較邏輯就只能通過 key 參數來實現。至于為什么將 cmp 參數移除，在 Python 的 Issue tracker 中有一段很長的討論，主要有以下兩點原因
- cmp 是一個冗余參數，所有使用 cmp 的場景都可以用 key 來代替
- 使用 key 比使用 cmp 的性能更快，對于有 N 個元素的列表，在排序過程中如果調用 cmp 進行比較，那么 cmp 的調用次數為 Nlog(N) 量級（基于比較的排序的最快時間復雜度），如果使用 key 參數，那么只需要在每個元素上調用一次 key 函數，只有 N 次調用，雖然使用 key 參數也要進行 O(Nlog(N)) 量級比較次數，但這些比較是在 C 語言層，比調用用戶自定義的函數快。
關于上面性能的問題，我做了一個實驗，分別隨機生成 1000、10000、100000 和 1000000 個整數，然后用 key 和 cmp 的方式分別進行排序并記錄排序的時間消耗
import random
import time
counts = (1000, 10000, 100000, 1000000)
def custom_cmp(x, y):
return x ** 2 - y ** 2
def custom_key(x):
return x ** 2
print('%7s%20s%20s' % ('count', 'cmp_duration', 'key_duration'))
for count in counts:
min_num = -count // 2
max_num = count // 2
nums = [random.randint(min_num, max_num) for _ in range(count)]
start = time.time()
sorted(nums, cmp=custom_cmp)
cmp_duration = time.time() - start
start = time.time()
sorted(nums, key=custom_key)
key_duration = time.time() - start
print('%7d%20.2f%20.2f' % (count, cmp_duration, key_duration))
在我的筆記本上一次運行結果如下
count cmp_duration key_duration
1000 0.00 0.00
10000 0.02 0.01
100000 0.34 0.11
1000000 4.75 1.85
可以看到，當列表中數字的數量超過 100000 的時候，使用 key 函數的性能優勢就非常明顯了，比 cmp 快了 2~3 倍。
對于熟悉 Java 或 C++ 等其他編程語言的同學來說，可能更熟悉 cmp 的比較方式。其實 Python 3 中也可以通過 functools 工具包中的 cmp_to_key() 函數來將 cmp 轉換成 key，從而使用接收兩個參數的自定義比較函數 cmp。
import functools
num_list = [4, 2, 8, -9, 1, -3]
def custom_cmp(x, y):
return x ** 2 - y ** 2
sorted_num_list = sorted(num_list, key=functools.cmp_to_key(custom_cmp))
print(sorted_num_list)
那么，cmp_to_key() 函數是如何將 cmp 轉換成 key 的呢，我們可以通過源碼一探究竟
def cmp_to_key(mycmp):
"""Convert a cmp= function into a key= function"""
class K(object):
__slots__ = ['obj']
def __init__(self, obj):
self.obj = obj
def __lt__(self, other):
return mycmp(self.obj, other.obj) 0
def __gt__(self, other):
return mycmp(self.obj, other.obj) > 0
def __eq__(self, other):
return mycmp(self.obj, other.obj) == 0
def __le__(self, other):
return mycmp(self.obj, other.obj) = 0
def __ge__(self, other):
return mycmp(self.obj, other.obj) >= 0
__hash__ = None
return K
其實 cmp_to_key() 返回的是一個類 K，只不過在類 K 中重載了各種比較運算符，重載的過程中使用到了自定義的比較函數 mycmp，使得 K 的大小比較邏輯與 mycmp 一致。這樣，對于 num_list 中的每個元素 num 都會執行一次 K(num) 生成一個類 K 的實例，然后通過比較不同 K 的實例的大小進行排序。
雖然通過 cmp_to_key() 可以調用自定義的 cmp 函數，但是還是要優先使用 key 函數，因為通過 cmp_to_key() 方式會在排序過程中創建很多類 K 的實例，對性能有很大影響，下面是 cmp_to_key() 和 key 的性能比較
count cmp_to_key key_duration
1000 0.01 0.00
10000 0.10 0.01
100000 1.36 0.09
1000000 16.89 1.13
當 num_list 中的數量為 1000000 的時候 key 比 cmp_to_key 快了將近 15 倍。
本文主要介紹了如何在 sorted 函數中自定義比較邏輯，Python 2 中可以通過 cmp 或 key 來實現，cmp 接收 2 個參數，通過返回的數值來判斷兩個參數的大小，key 重新計算一個新的結果參與比較。在 Python 3 中，考慮到 cmp 的性能和冗余的原因，將其移除了。在 Python 3.2 中提供了 functools.cmp_to_key 這個函數來使用自定義的比較函數 cmp，但是出于性能的考慮，我們還是要優先使用 key 來進行排序。
以上就是Python 中 sorted 如何自定義比較邏輯的詳細內容，更多關于python sorted自定義比較邏輯的資料請關注腳本之家其它相關文章！
您可能感興趣的文章:- Python自定義sorted排序實現方法詳解
- 詳解python中的lambda與sorted函數
- Python sorted對list和dict排序
- python中sort sorted reverse reversed函數的區別說明
- Python sorted排序方法如何實現
- Python3 中sorted() 函數的用法
- python3 sorted 如何實現自定義排序標準
- python3中sorted函數里cmp參數改變詳解
- Python中sorted()排序與字母大小寫的問題
