作為一種通用語言，Python已在各種學術和工業領域逐漸流行，用于科學計算，工程，Web開發和許多其他用途。 Python的一項引人入勝的功能是它是如此靈活，以至于同一功能可以有多個實現。讓我們考慮以下簡單的示例。

>>> # sort a list using sort() 
>>> names0 = ['Danny', 'Johnny', 'Billy', 'Donny'] 
>>> names0.sort() 
>>> names0['Billy', 'Danny', 'Donny', 'Johnny'] 
>>>>>> # sort a list using sorted() 
>>> names1 = ['Danny', 'Johnny', 'Billy', 'Donny'] 
>>> sorted(names1)['Billy', 'Danny', 'Donny', 'Johnny']>>> 

[“比利”，“丹尼”，“唐尼”，“約翰尼”]

在上面的代碼中，我們創建了兩個列表：names0和names1，并使用sort()和sorted()函數分別對它們進行排序。顯然，我們能夠以相同順序在列表中獲得。

盡管sort()和sorted()函數之間的相似之處，但我想指出，幾乎總是要使用sorted()而不是sort()。這是三個原因。

1. 與任何迭代器的兼容性

第一個原因是sorted()函數更靈活，因為它可以與任何可迭代對象一起使用。相比之下，sort()函數僅適用于列表。如果您不知道什么是可迭代的，可以參考下面的我的上一篇文章。簡而言之，可迭代對象是可以在迭代中進行迭代的Python對象，例如元組，列表，集合和字典。

讓我們根據兼容的數據類型比較sorted()和sort()。需要注意的一件事是，這兩種功能的使用方式存在細微的差異。 sorted()函數將iterable作為參數，而sort()函數的調用者則使用點表示法調用該函數。

>>> # sort a tuple 
>>> _ = (3, 5, 4).sort() 
Traceback (most recent call last):  File "<stdin>", line 1, in <module> 
AttributeError: 'tuple' object has no attribute 'sort' 
>>> _ = sorted((3, 5, 4)) 
>>>>>> # sort a dictionary>>> _ = {2: 'two', 0: 'zero', 1: 'one'}.sort()  
Traceback (most recent call last):  File "<stdin>", line 1, in <module> 
AttributeError: 'dict' object has no attribute 'sort' 
>>> _ = sorted({2: 'two', 0: 'zero', 1: 'one'}) 
>>>>>> # sort a set 
>>> _ = set([2, 3, 4]).sort() 
Traceback (most recent call last):  File "<stdin>", line 1, in <module> 
AttributeError: 'set' object has no attribute 'sort' 
>>> _ = sorted(set([2, 3, 4])) 

如上面的代碼所示，元組，字典和集合均無法調用sort()函數。實際上，sort()函數是列表對象的實例方法，而不是其他集合對象的實例方法，這意味著此函數僅可用于列表對象。相比之下，元組，字典和集合都可以通過sorted()函數進行排序，因為所有這些數據類型都是可迭代的，因此使其適合使用sorted()函數。

2. 創建列表的便利

第二個原因是sorted()函數將按所需順序對可迭代對象進行排序后將返回一個列表對象。因此，這是構建新列表的便捷方法。但是，sort()函數會更改調用此方法的列表的順序，我們稱此順序為就地排序。此外，此函數隱式返回None(有時，我們可以說，當隱式返回值為None時，它不返回任何內容)。

讓我們考慮以下假設示例。我們從一個名為sales_dict的字典開始，該字典保存全年的銷售記錄。我們要根據銷售額創建一個按降序排列的記錄列表。

>>> # records of sales in a dictionary 
>>> sales_dict = {'Spring': 1000, 'Summer': 950, 'Fall': 1030, 'Winter': 1200} 
>>>>>> # create a list object of sales records 
>>> sales_list0 = sorted(sales_dict.items(), key=lambda x: x[1], reverse=True) 
>>> sales_list0[('Winter', 1200), ('Fall', 1030), ('Spring', 1000), ('Summer', 950)] 
>>>>>> sales_list1 = list(sales_dict.items())>>> sales_list1.sort(key=lambda x: x[1], reverse=True) 
>>> sales_list1[('Winter', 1200), ('Fall', 1030), ('Spring', 1000), ('Summer', 950)] 

在上面的代碼中，我們只需要使用sorted()函數編寫一行代碼即可獲得所需的結果。但是，使用sort()函數，我們必須編寫兩行代碼。值得注意的是，由于某人可能會誤認為，我們無法通過使用點符號來組合這兩行來生成所需的列表對象。

>>> # combine the two lines 
>>> sales_list2 = list(sales_dict.items()).sort(key=lambda x: x[1], reverse=True) 
>>> sales_list2>>> type(sales_list2) 
<class 'NoneType'> 
>>> print(sales_list2) 
None 

如上面的代碼所示，通過組合兩行，我們得到的是None值。這是因為sort()函數的返回值為None，而不是調用該函數的列表對象。

3. 與迭代集成

由于sorted()函數返回列表，而sort()函數返回None，這種區別的含義是什么?好吧，在許多情況下，我們期望有可迭代對象，但沒有NoneType對象。一種這樣的場景是迭代，畢竟這是我們經常使用列表對象執行的一項關鍵操作。

考慮以下示例。我們有兩個字典分別保存第一學期和第二學期的分數。目的是創建一個報告卡，總結每個學生的表現，并按姓名進行排序。

>>> # test results for the first semester 
>>> results1 = {'John': 95, 'Danny': 80, 'Zack': 98} 
>>>>>> # test results for the second semester 
>>> results2 = {'Danny': 84, 'Zack': 95, 'John': 88} 
>>>>>> # generate the report card>>> for name, score in sorted(results2.items()): 
...     print(f'{name} | Spring: {results1[name]} | Fall: {score}') 
... Danny | Spring: 80 | Fall: 84 
John | Spring: 95 | Fall: 88 
Zack | Spring: 98 | Fall: 95 

在上面的代碼中，我們注意到這兩個字典都沒有期望的輸出順序，因此，我們將使用sorted()函數對字典進行排序。如您所見，我們可以將排序后的結果直接集成到for循環中，因為sorted()函數返回排序后的列表。

您可能已經預料到，如果我們在這種情況下嘗試使用sort()函數，將會發生什么。請參閱下面的更多細節。

>>> for name, score in list(results2.items()).sort(): 
...     print(f'{name} | Spring: {results1[name]} | Fall: {score}') 
... Traceback (most recent call last):  File "<stdin>", line 1, in <module> 
TypeError: 'NoneType' object is not iterable 

總結

在本文中，我們討論了為什么幾乎應該始終使用sorted()函數而不是sort()函數的三個原因。

• sorted()函數更靈活，因為它可與任何可迭代對象一起使用，這與只適用于列表的sort()函數不同。
• sorted()函數是創建排序列表的便捷方法。
• sorted()函數可以方便地與迭代集成。

篇尾思考

最后但并非最不重要的一點是，您可能想知道何時應該考慮使用sort()函數。 對于這個問題，我沒有確切的答案，但是我可以想到的一種情況是，當我們只處理列表對象而又不希望得到返回的列表時。 畢竟，sorted()函數將生成一個新列表，因此，當列表特別大時，使用sorted()函數創建新列表的內存使用效率不高。

考慮簡單的例子。 我們需要對每個嵌套列表進行排序。 在某些情況下，列表可能非常大。 使用sort()函數只會對原始列表進行排序，從而避免創建不必要的新列表對象。

>>> # simplified nested lists; each list can be much larger 
>>> group_scores = [[7, 3, 5], [3, 2, 8], [9, 4, 5]] 
>>> for scores in group_scores: 
...     scores.sort() 
... >>> group_scores[[3, 5, 7], [2, 3, 8], [4, 5, 9]] 

原文：

https://medium.com/swlh/3-reasons-why-you-should-almost-always-use-sorted-in-python-9fe122e6ce71