這篇文章將為大家詳細(xì)講解有關(guān)Python中sorted與sort用法，文章內(nèi)容質(zhì)量較高，因此小編分享給大家做個(gè)參考，希望大家閱讀完這篇文章后對(duì)相關(guān)知識(shí)有一定的了解。

平泉ssl適用于網(wǎng)站、小程序/APP、API接口等需要進(jìn)行數(shù)據(jù)傳輸應(yīng)用場(chǎng)景，ssl證書(shū)未來(lái)市場(chǎng)廣闊！成為創(chuàng)新互聯(lián)建站的ssl證書(shū)銷(xiāo)售渠道，可以享受市場(chǎng)價(jià)格4-6折優(yōu)惠！如果有意向歡迎電話聯(lián)系或者加微信：18982081108（備注：SSL證書(shū)合作）期待與您的合作！

使用sorted()排序值

開(kāi)始使用Python排序，首先要了解如何對(duì)數(shù)字?jǐn)?shù)據(jù)和字符串?dāng)?shù)據(jù)進(jìn)行排序。

1. 排序數(shù)字型數(shù)據(jù)

可以使用Python通過(guò)sorted()對(duì)列表進(jìn)行排序。比如定義了一個(gè)整數(shù)列表，然后使用numbers變量作為參數(shù)調(diào)用sorted()：

>>> numbers = [6, 9, 3, 1]
>>> sorted(numbers)
[1, 3, 6, 9]
>>> numbers
[6, 9, 3, 1]

輸出是一個(gè)新的排序列表，如果打印原始變量時(shí)， 原始數(shù)字變量numbers未改變，因?yàn)閟orted()只提供已排序的輸出，而不會(huì)更改原始值。這 意味著sorted()可以在列表中使用，將輸出立即分配給變量：

>>> numbers = [6, 9, 3, 1]
>>> numbers_sorted = sorted(numbers)
>>> numbers_sorted
[1, 3, 6, 9]
>>> numbers
[6, 9, 3, 1]

我們還可以通過(guò)調(diào)用sorted的help()來(lái)確認(rèn)所有這些觀察結(jié)果。可選參數(shù)key和reverse將在本教程后面介紹：

>>> # Python 3
>>> help(sorted)
Help on built-in function sorted in module builtins:

sorted(iterable, /, *, key=None, reverse=False)
    Return a new list containing all items from the iterable in ascending order.

    A custom key function can be supplied to customize the sort order, and the
    reverse flag can be set to request the result in descending order.

像操作列表一樣，sorted()也可同樣地用于元組和集合：

>>> numbers_tuple = (6, 9, 3, 1)
>>> numbers_set = {5, 5, 10, 1, 0}
>>> numbers_tuple_sorted = sorted(numbers_tuple)
>>> numbers_set_sorted = sorted(numbers_set)
>>> numbers_tuple_sorted
[1, 3, 6, 9]
>>> numbers_set_sorted
[0, 1, 5, 10]

注意到，即使輸入一個(gè)集合和一個(gè)元組，輸出也是一個(gè)列表，因?yàn)閟orted()按定義返回一個(gè)新列表。如果需要匹配輸入類(lèi)型，則可以將返回的對(duì)象強(qiáng)制轉(zhuǎn)換為新類(lèi)型。如果嘗試將結(jié)果列表強(qiáng)制轉(zhuǎn)換回集合，結(jié)果將是無(wú)序的，因?yàn)榧鲜菬o(wú)序的，如下：

>>> numbers_tuple = (6, 9, 3, 1)
>>> numbers_set = {5, 5, 10, 1, 0}
>>> numbers_tuple_sorted = sorted(numbers_tuple)
>>> numbers_set_sorted = sorted(numbers_set)
>>> numbers_tuple_sorted
[1, 3, 6, 9]
>>> numbers_set_sorted
[0, 1, 5, 10]
>>> tuple(numbers_tuple_sorted)
(1, 3, 6, 9)
>>> set(numbers_set_sorted)
{0, 1, 10, 5}

2. 排序字符串型數(shù)據(jù)

字符串類(lèi)型與其他可迭代對(duì)象類(lèi)似，如列表和元組。下面的示例顯示了sorted()如何將傳遞給它的字符串進(jìn)行遍歷，并在輸出中對(duì)每個(gè)字符進(jìn)行排序：

>>> string_number_value = '34521'
>>> string_value = 'I like to sort'
>>> sorted_string_number = sorted(string_number_value)
>>> sorted_string = sorted(string_value)
>>> sorted_string_number
['1', '2', '3', '4', '5']
>>> sorted_string
[' ', ' ', ' ', 'I', 'e', 'i', 'k', 'l', 'o', 'o', 'r', 's', 't', 't']

sorted()將字符串視為列表并遍歷每個(gè)元素。在字符串中，每個(gè)元素表示字符串中的一個(gè)字符，sorted會(huì)以相同的方式處理一個(gè)字符串，對(duì)每個(gè)字符進(jìn)行排序，包括空格。 .

我們通過(guò)使用split()可以改變輸出是單個(gè)字符的結(jié)果，以空格為邊界將原始字符串拆分成幾個(gè)單詞，再通過(guò).join()將幾個(gè)單詞重新組合在一起成為新的字符串，具體如下：

>>> string_value = 'I like to sort'
>>> sorted_string = sorted(string_value.split())
>>> sorted_string
['I', 'like', 'sort', 'to']
>>> ' '.join(sorted_string)
'I like sort to'

Python排序的局限性和陷阱

當(dāng)使用Python對(duì)整數(shù)值進(jìn)行排序時(shí)，可能會(huì)出現(xiàn)一些限制和奇怪的現(xiàn)象。

1. 具有不能比較數(shù)據(jù)類(lèi)型的列表無(wú)法進(jìn)行排序

有些數(shù)據(jù)類(lèi)型使用sorted是無(wú)法進(jìn)行比較的，因?yàn)樗鼈兊念?lèi)型不同。如果嘗試在包含不可比較數(shù)據(jù)的列表上使用sorted()，Python將返回錯(cuò)誤。在此示例中，由于不兼容性，無(wú)法對(duì)同一列表中的None和int進(jìn)行排序：

>>> mixed_types = [None, 0]
>>> sorted(mixed_types)
Traceback (most recent call last):
  File "", line 1, in 
TypeError: '<' not supported between instances of 'int' and 'NoneType'

此錯(cuò)誤顯示了為什么Python無(wú)法對(duì)給定的值進(jìn)行排序。它試圖通過(guò)使用小于運(yùn)算符（<）來(lái)確定值，以確定排序順序中哪個(gè)值較低。 例如，數(shù)字1應(yīng)該出現(xiàn)在蘋(píng)果這個(gè)詞之前嗎？但是，如果迭代器包含所有數(shù)字的整數(shù)和字符串的組合，則可以使用列表推導(dǎo)將它們強(qiáng)制轉(zhuǎn)換為可比較的數(shù)據(jù)類(lèi)型：

>>> mixed_numbers = [5, "1", 100, "34"]
>>> sorted(mixed_numbers)
Traceback (most recent call last):
  File "", line 1, in 
TypeError: '<' not supported between instances of 'str' and 'int'
>>> # List comprehension to convert all values to integers
>>> [int(x) for x in mixed_numbers]
[5, 1, 100, 34]
>>> sorted([int(x) for x in mixed_numbers])
[1, 5, 34, 100]

mixed_numbers中的每個(gè)元素都調(diào)用了int()來(lái)將任何str值轉(zhuǎn)換為int值。然后調(diào)用sorted()并成功比較每個(gè)元素并提供排序的輸出。

另外，Python還可以隱式地將值轉(zhuǎn)換為另一種類(lèi)型。在下面的示例中，1 <= 0的評(píng)估是false語(yǔ)句，因此評(píng)估的輸出將為False。數(shù)字1可以轉(zhuǎn)換為T(mén)rue作為bool類(lèi)型，而0轉(zhuǎn)換為False。

即使列表中的元素看起來(lái)不同，它們也可以全部轉(zhuǎn)換為布爾值（True或False）并使用sorted()進(jìn)行相互比較：

>>> similar_values = [False, 0, 1, 'A' == 'B', 1 <= 0]
>>> sorted(similar_values)
[False, 0, False, False, 1]

'A'=='B'和1 <= 0轉(zhuǎn)換為False并在有序輸出中返回。

此示例說(shuō)明了排序的一個(gè)重要方面： 排序穩(wěn)定性。 在Python中，當(dāng)你對(duì)相等的值進(jìn)行排序時(shí)，它們將在輸出中保留其原始順序。即使1移動(dòng)，所有其他值都相等，它們保持相對(duì)于彼此的原始順序。在下面的示例中，所有值都被視為相等，并將保留其原始位置：

>>> false_values = [False, 0, 0, 1 == 2, 0, False, False]
>>> sorted(false_values)
[False, 0, 0, False, 0, False, False]

如果檢查原始順序和排序輸出，可以看到1 == 2轉(zhuǎn)換為False，所有排序輸出都是原始順序。

2. 當(dāng)排序字符串時(shí)，大小寫(xiě)很重要

sorted()可用于字符串列表，以按升序?qū)χ颠M(jìn)行排序，默認(rèn)情況下按字母順序排列：

>>> names = ['Harry', 'Suzy', 'Al', 'Mark']
>>> sorted(names)
['Al', 'Harry', 'Mark', 'Suzy']

但是，Python使用每個(gè)字符串中第一個(gè)字母的Unicode代碼點(diǎn)來(lái)確定升序排序。意思是sorted()不會(huì)將名稱(chēng)Al和al視為相同。此示例使用ord()返回每個(gè)字符串中第一個(gè)字母的Unicode代碼點(diǎn)：

>>> names_with_case = ['harry', 'Suzy', 'al', 'Mark']
>>> sorted(names_with_case)
['Mark', 'Suzy', 'al', 'harry']
>>> # 每個(gè)word中第一個(gè)字母的unicode代碼點(diǎn)列表推導(dǎo)式
>>> [(ord(name[0]), name[0]) for name in sorted(names_with_case)]
[(77, 'M'), (83, 'S'), (97, 'a'), (104, 'h')]

name [0]返回sorted(names_with_case)的每個(gè)元素中的第一個(gè)字符，ord()提供Unicode代碼點(diǎn)。即使a在字母表中的M之前，M的代碼點(diǎn)在a之前，因此排序的輸出首先是M。 如果第一個(gè)字母相同，則sorted()將使用第二個(gè)字符來(lái)確定順序，第三個(gè)字符等，依此類(lèi)推，一直到字符串的結(jié)尾：

>>> very_similar_strs = ['hhhhhd', 'hhhhha', 'hhhhhc','hhhhhb']
>>> sorted(very_similar_strs)
['hhhhha', 'hhhhhb', 'hhhhhc', 'hhhhhd']

除最后一個(gè)字符外，very_similar_strs的每個(gè)值都相同。 sorted()比較字符串，因?yàn)榍拔鍌€(gè)字符相同，輸出將基于第六個(gè)字符。

包含相同值的字符串將最終排序?yàn)樽疃痰阶铋L(zhǎng)，因?yàn)檩^短的字符串沒(méi)有要與較長(zhǎng)字符串進(jìn)行比較的元素：

>>> different_lengths = ['hhhh', 'hh', 'hhhhh','h']
>>> sorted(different_lengths)
['h', 'hh', 'hhhh', 'hhhhh']

最短的字符串h排序第一，最長(zhǎng)的字符串hhhhh排序最后。

用reverse參數(shù)使用sorted()

如sorted()的help()文檔所示，有一個(gè)名為reverse的可選關(guān)鍵字參數(shù)，它將根據(jù)分配給它的布爾值更改排序行為。如果將reverse指定為T(mén)rue，則排序?qū)唇敌蚺帕校?/p>

>>> names = ['Harry', 'Suzy', 'Al', 'Mark']
>>> sorted(names)
['Al', 'Harry', 'Mark', 'Suzy']
>>> sorted(names, reverse=True)
['Suzy', 'Mark', 'Harry', 'Al']

排序邏輯保持不變，這意味著名稱(chēng)仍按其第一個(gè)字母排序。但是，如果reverse關(guān)鍵字設(shè)置為T(mén)rue，則輸出反轉(zhuǎn)。

如果指定了False，則排序?qū)⒈３稚颉？梢允褂们懊娴娜魏问纠齺?lái)使用True或False來(lái)查看reverse的行為：

>>> names_with_case = ['harry', 'Suzy', 'al', 'Mark']
>>> sorted(names_with_case, reverse=True)
['harry', 'al', 'Suzy', 'Mark']
>>> similar_values = [False, 1, 'A' == 'B', 1 <= 0]
>>> sorted(similar_values, reverse=True)
[1, False, False, False]
>>> numbers = [6, 9, 3, 1]
>>> sorted(numbers, reverse=False)
[1, 3, 6, 9]

sorted()使用key參數(shù)排序

sorted()最強(qiáng)大的功能之一是一個(gè)叫做key的關(guān)鍵字參數(shù)。此參數(shù)需要將函數(shù)傳遞給它，并且該函數(shù)將用于要排序的列表中的每個(gè)值，以確定生成的順序。

我們假設(shè)排序一個(gè)特定列表的要求是列表中字符串的長(zhǎng)度，最短到最長(zhǎng)。返回字符串長(zhǎng)度len()的函數(shù)將與key參數(shù)一起使用：

>>> word = 'paper'
>>> len(word)
5
>>> words = ['banana', 'pie', 'Washington', 'book']
>>> sorted(words, key=len)
['pie', 'book', 'banana', 'Washington']

生成的順序是一個(gè)字符串順序最短到最長(zhǎng)的列表。列表中每個(gè)元素的長(zhǎng)度由len確定，然后以升序返回。

回到前面的例子，當(dāng)大小寫(xiě)不同時(shí)按第一個(gè)字母排序。key可以通過(guò)將整個(gè)字符串轉(zhuǎn)換為小寫(xiě)來(lái)解決該問(wèn)題：

>>> names_with_case = ['harry', 'Suzy', 'al', 'Mark']
>>> sorted(names_with_case)
['Mark', 'Suzy', 'al', 'harry']
>>> sorted(names_with_case, key=str.lower)
['al', 'harry', 'Mark', 'Suzy']

輸出值尚未轉(zhuǎn)換為小寫(xiě)，因?yàn)閗ey不會(huì)處理原始列表中的數(shù)據(jù)。在排序期間，傳遞給key的函數(shù)將在每個(gè)元素上調(diào)用以確定排序順序，但原始值仍將體現(xiàn)在輸出中。 使用帶有key參數(shù)的函數(shù)時(shí)，有兩個(gè)主要限制。

首先，傳遞給key的函數(shù)中參數(shù)的數(shù)量必須為1。

下面的示例顯示了帶有兩個(gè)參數(shù)的加法函數(shù)的定義。當(dāng)該函數(shù)用于數(shù)字列表中的鍵時(shí)，它會(huì)失敗，因?yàn)樗鄙俚诙€(gè)參數(shù)。每次在排序期間調(diào)用add()時(shí)，它一次只從列表中接收一個(gè)元素：

>>> def add(x, y):
...     return x + y
... 
>>> values_to_add = [1, 2, 3]
>>> sorted(values_to_add, key=add)
Traceback (most recent call last):
  File "", line 1, in 
TypeError: add() missing 1 required positional argument: 'y'

第二個(gè)限制是與key一起使用的函數(shù)必須能夠處理iterable中的所有值。 例如，有一個(gè)數(shù)字列表，表示為要在sorted中使用的字符串，而key將嘗試將它們轉(zhuǎn)換為使用int。如果iterable中的值不能轉(zhuǎn)換為整數(shù)，則該函數(shù)將失敗：

>>> values_to_cast = ['1', '2', '3', 'four']
>>> sorted(values_to_cast, key=int)
Traceback (most recent call last):
  File "", line 1, in 
ValueError: invalid literal for int() with base 10: 'four'

作為字符串的每個(gè)數(shù)值都可以轉(zhuǎn)換為int，但是four不能。這會(huì)導(dǎo)致引發(fā)ValueError并解釋four無(wú)法轉(zhuǎn)換為int，因?yàn)樗鼰o(wú)效。

key功能非常強(qiáng)大，因?yàn)閹缀跞魏蝺?nèi)置或用戶定義的函數(shù)都可用于操作輸出順序。

如果排序要求是按每個(gè)字符串中的最后一個(gè)字母排序可迭代（如果字母相同，然后使用下一個(gè)字母），則可以定義函數(shù)，然后在排序中使用。下面的示例定義了一個(gè)函數(shù)，該函數(shù)反轉(zhuǎn)傳遞給它的字符串，然后該函數(shù)用作鍵的參數(shù)：

>>> def reverse_word(word):
...     return word[::-1]
...
>>> words = ['banana', 'pie', 'Washington', 'book']
>>> sorted(words, key=reverse_word)
['banana', 'pie', 'book', 'Washington']

word[::-1]切片語(yǔ)法用于反轉(zhuǎn)字符串。每個(gè)元素都會(huì)應(yīng)用reverse_word()，排序順序?qū)⒒诤笙騿卧~中的字符。

當(dāng)然，也可以使用key參數(shù)中定義的lambda函數(shù)，而不是編寫(xiě)?yīng)毩⒑瘮?shù)。 lambda匿名函數(shù)：1）必須內(nèi)聯(lián)定義；2）沒(méi)有名字；3）不能包含statement；4）像函數(shù)一樣執(zhí)行。

在下面的示例中，key被定義為沒(méi)有名稱(chēng)的lambda，lambda采用的參數(shù)是x，然后x [:: -1]是將對(duì)參數(shù)執(zhí)行的操作：

>>> words = ['banana', 'pie', 'Washington', 'book']
>>> sorted(words, key=lambda x: x[::-1])
['banana', 'pie', 'book', 'Washington']

在每個(gè)元素上調(diào)用x [::-1]并反轉(zhuǎn)該單詞。然后將反轉(zhuǎn)的輸出用于排序，但仍返回原始單詞。 如果需求發(fā)生變化，要求順序也應(yīng)該反轉(zhuǎn)，那么reverse關(guān)鍵字可以與key參數(shù)一起使用：

>>> words = ['banana', 'pie', 'Washington', 'book']
>>> sorted(words, key=lambda x: x[::-1], reverse=True)
['Washington', 'book', 'pie', 'banana']

當(dāng)需要基于屬性對(duì)類(lèi)對(duì)象進(jìn)行排序時(shí)，lambda函數(shù)也很有用。如果有一組學(xué)生并需要按最終成績(jī)（從最高到最低）對(duì)其進(jìn)行排序，則可以使用lambda從該課程中獲取成績(jī)屬性：

>>> from collections import namedtuple

>>> StudentFinal = namedtuple('StudentFinal', 'name grade')
>>> bill = StudentFinal('Bill', 90)
>>> patty = StudentFinal('Patty', 94)
>>> bart = StudentFinal('Bart', 89)
>>> students = [bill, patty, bart]
>>> sorted(students, key=lambda x: getattr(x, 'grade'), reverse=True)
[StudentFinal(name='Patty', grade=94), StudentFinal(name='Bill', grade=90), StudentFinal(name='Bart', grade=89)]

此示例使用namedtuple生成具有name和grade屬性的類(lèi)。 lambda在每個(gè)元素上調(diào)用getattr()并返回grade的值。 reverse設(shè)置為T(mén)rue以使升序輸出轉(zhuǎn)為降序，以便首先排序最高等級(jí)。

當(dāng)在sorted()上同時(shí)使用key和reverse關(guān)鍵字參數(shù)時(shí)，如何進(jìn)行排序的可能性是無(wú)窮無(wú)盡的。當(dāng)對(duì)一個(gè)小函數(shù)使用基本lambda時(shí)，代碼可以保持干凈和簡(jiǎn)短，或者可以編寫(xiě)一個(gè)全新的函數(shù)導(dǎo)入，并在key參數(shù)中使用它。

使用.sort()排序值

名稱(chēng)相似的.sort()與sorted()內(nèi)置函數(shù)有著很大的不同。雖然它們或多或少都可以完成相同的事情，但list.sort()的help()文檔突出顯示了.sort()和sorted()之間最重要的兩個(gè)區(qū)別：

>>> # Python2
Help on method_descriptor:

sort(...)
    L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
    cmp(x, y) -> -1, 0, 1

>>> # Python3
>>> help(list.sort)
Help on method_descriptor:

sort(...)
    L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*

首先，sort是列表類(lèi)的一種方法，只能與列表一起使用。它不是傳遞給它的迭代的內(nèi)置函數(shù)。其次，sort返回None并修改值。我們來(lái)看看代碼中這兩種差異的影響：

>>> values_to_sort = [5, 2, 6, 1]
>>> # 嘗試調(diào)用像使用sorted()調(diào)用sort()
>>> sort(values_to_sort)
Traceback (most recent call last):
  File "", line 1, in 
NameError: name 'sort' is not defined

>>> # 嘗試在一個(gè)元組上使用 .sort()
>>> tuple_val = (5, 1, 3, 5)
>>> tuple_val.sort()
Traceback (most recent call last):
  File "", line 1, in 
AttributeError: 'tuple' object has no attribute 'sort'

>>> # 排序列表并且賦值給新的變量
>>> sorted_values = values_to_sort.sort()
>>> print(sorted_values)
None
>>> # 打印原始變量
>>> print(values_to_sort)
[1, 2, 5, 6]

與此代碼示例中的sorted()相比，sort()操作的方式有一些非常顯著的差異：

\1. sort()不產(chǎn)生有序輸出，因此對(duì)新變量的賦值僅傳遞None類(lèi)型。

\2. values_to_sort列表已就地更改，并且不以任何方式維持原始順序。

這些差異使得.sort()和sorted()絕對(duì)不能在代碼中互換，如果以錯(cuò)誤的方式使用它們，它們會(huì)產(chǎn)生意想不到的結(jié)果。

.sort()具有相同的key 和reverse可選關(guān)鍵字參數(shù)，這些參數(shù)產(chǎn)生與sorted()相同的強(qiáng)大功能。在這里，可以按第三個(gè)單詞的第二個(gè)字母對(duì)短語(yǔ)列表進(jìn)行排序，然后反向返回列表：

>>> phrases = ['when in rome', 
...     'what goes around comes around', 
...     'all is fair in love and war'
...     ]
>>> phrases.sort(key=lambda x: x.split()[2][1], reverse=True)
>>> phrases
['what goes around comes around', 'when in rome', 'all is fair in love and war']

何時(shí)使用sorted和.sort?

我們已經(jīng)看到了sorted()和.sort()之間的區(qū)別，但我們什么時(shí)候使用？該使用哪個(gè)？

假設(shè)有一場(chǎng)5k比賽即將舉行：第一屆年度Python 5k。需要獲取和分類(lèi)來(lái)自比賽的數(shù)據(jù)，參賽者的號(hào)碼和完成比賽所需的秒數(shù)：

>>> from collections import namedtuple
>>> Runner = namedtuple('Runner', 'bibnumber duration')

當(dāng)參賽者越過(guò)終點(diǎn)線時(shí)，每個(gè)參賽者將被添加到名為參賽者的列表中。在5k比賽中，并非所有參賽者同時(shí)越過(guò)起跑線，所以第一個(gè)越過(guò)終點(diǎn)線的人可能實(shí)際上不是最快的人：

>>> runners = []
>>> runners.append(Runner('2528567', 1500))
>>> runners.append(Runner('7575234', 1420))
>>> runners.append(Runner('2666234', 1600))
>>> runners.append(Runner('2425234', 1490))
>>> runners.append(Runner('1235234', 1620))
>>> # Thousands and Thousands of entries later...
>>> runners.append(Runner('2526674', 1906))

每次參賽者越過(guò)終點(diǎn)線時(shí)，他們的號(hào)碼號(hào)和他們的總持續(xù)時(shí)間（以秒為單位）都會(huì)添加到跑步者。

現(xiàn)在，負(fù)責(zé)處理結(jié)果數(shù)據(jù)的盡職程序員看到了這個(gè)列表，知道前5名最快的參與者是獲得獎(jiǎng)品的獲勝者，剩下的參賽者將按最快的時(shí)間進(jìn)行排序。

賽事中沒(méi)有提到通過(guò)不同屬性進(jìn)行多類(lèi)型的排序要求，也沒(méi)有提到將列表在某處存儲(chǔ)，只需按持續(xù)時(shí)間排序并獲取持續(xù)時(shí)間最短的五個(gè)參與者：

>>> runners.sort(key=lambda x: getattr(x, 'duration'))
>>> top_five_runners = runners[:5]

程序員選擇在key參數(shù)中使用lambda來(lái)獲取每個(gè)參賽者的duration屬性，并使用.sort()對(duì)運(yùn)行程序進(jìn)行排序。在對(duì)參賽者進(jìn)行排序后，前5個(gè)元素存儲(chǔ)在top_five_runners中。

比賽總監(jiān)過(guò)來(lái)告訴程序員，由于目前發(fā)布的Python是3.7，他們決定每隔37位越過(guò)終點(diǎn)線的人將獲得一個(gè)免費(fèi)的健身包。這時(shí)候，程序員開(kāi)始出汗，因?yàn)閰①愓呙麊我驯徊豢赡孓D(zhuǎn)地改變。沒(méi)有辦法按照他們完成的順序恢復(fù)原始的參賽者名單，并找到這些人。

如果你正在處理重要數(shù)據(jù)，甚至可能需要恢復(fù)原始數(shù)據(jù)，那么.sort()不是最佳選擇。相反，如果數(shù)據(jù)是副本，是不重要的工作數(shù)據(jù)，或者沒(méi)有人會(huì)在意失不失去它，那么.sort()可以是一個(gè)很好的選擇。

因此，可以用sorted()，使用相同的lambda對(duì)runners進(jìn)行排序：

>>> runners_by_duration = sorted(runners, key=lambda x: getattr(x, 'duration'))
>>> top_five_runners = runners_by_duration[:5]

在這個(gè)帶有sorted()的場(chǎng)景中，原始的參賽者列表仍然完好無(wú)損并且沒(méi)有被覆蓋，并且每三十七人越過(guò)終點(diǎn)線的即興要求可以通過(guò)與原始值互動(dòng)來(lái)完成：

>>> every_thirtyseventh_runners = runners[::37]

關(guān)于Python中sorted與sort用法就分享到這里了，希望以上內(nèi)容可以對(duì)大家有一定的幫助，可以學(xué)到更多知識(shí)。如果覺(jué)得文章不錯(cuò)，可以把它分享出去讓更多的人看到。