python的sort函數(shù)與sorted函數(shù)排序問題小結(jié)

更新時間：2023年07月05日 08:41:06 作者：wancy

sort函數(shù)用于列表的排序，更改原序列而sorted用于可迭代對象的排序（包括列表），返回新的序列，這篇文章主要介紹了python的sort函數(shù)與sorted函數(shù)排序,需要的朋友可以參考下

1. sort函數(shù)

　　sort函數(shù)為python內(nèi)置的列表排序高階函數(shù),所謂高階函數(shù)，也就是參數(shù)為函數(shù)或返回值為函數(shù)。

　　先看個簡單的例子：

# 數(shù)字列表的排序示例
nums = [5, 2, 9, 1, 7]
nums.sort()
print(nums)  # 輸出：[1, 2, 5, 7, 9]

　　可以發(fā)現(xiàn)排序后，改變了原列表的順序。而且sort()函數(shù)沒有返回值，或者說返回值是None。再看sort函數(shù)的語法：

　　sort函數(shù)的語法是：list.sort(key=None, reverse=False)。

　　參數(shù)說明：

　　key：指定用于排序的函數(shù)，可以指定一個函數(shù)，這個函數(shù)接受一個參數(shù)并返回一個用于排序的關(guān)鍵字，默認(rèn)為None，表示按照列表的元素排序，但是要求每個元素的數(shù)據(jù)類型相同。

　　reverse：如果為True，則列表會以降序排序，默認(rèn)為False，即升序排序。

nums = [5, 2, 9, 1, 7]
nums.sort(reverse=True)
print(nums)  # 輸出：[9, 7, 5, 2, 1]
#如果是字符，元素就應(yīng)該統(tǒng)一全部是字符，按照編碼大小比較。
nums = ['5', '2', '9','T' '1', '7','!','t','1']
nums.sort(reverse=True)
print(nums)  # 輸出：['t', 'T1', '9', '7', '5', '2', '1', '!']

　　如果每個元素為列表或元組、字典，在key=None的情況下又該如何比較大小呢?

當(dāng)key=None時：

元素為列表的列表排序

　　講解元素為列表的列表之前先看個代碼：

list01=[3,1]
list02=[0,1,1]
print(list01&gt;list02)#True

　　可以看到是先比較兩個列表元素的第一個，顯然3>0，運算結(jié)果是True（如果相等，繼續(xù)比較后面的，注意，并不是比較列表的長度大小）。

　　再看下面例子：

# 比較時,相互比較的元素數(shù)據(jù)類型要相同，否則報錯
list01=[3,1]
list02=['0',1,1]
print(list01&gt;list02)#報錯報錯報錯TypeError: '&gt;' not supported between instances of 'int' and 'str'

　　還有一種特殊的例子：

list01=[3,1]
list02=[0,'1',1]
print(list01&gt;list02)#True

　　這種情況不會報錯，因為比較第一個元素時，已經(jīng)能分出大小了。

　　元素為列表的排序先看2個例子，再分析。

lst1=[[0,1],[1,1,2]]
lst2=[[1,1],[0,2]]
print(lst1&gt;lst2)#False
lst1=[[1,1],[1,1,2]]
lst2=[[1,1],[2,2]]
print(lst1&gt;lst2)#False

　　所以，當(dāng)元素為列表時，依然按照前面的方法比較大小，lst中的第一個元素[0,1]和lst中的第一個元素[1,1]比較大小，[0,1]與[1,1]比較大小再次按照列表的比較大小規(guī)則即可。下面為key=None時,調(diào)用sort后的排序例子。

mylist = [[1, 1, 0], [2, 0], [1, 2], [1, 1], [2, 0, 3], [3], [2], [1, 2, 3, 4, 5]]
 mylist.sort()
 print(mylist)#[[1, 1], [1, 1, 0], [1, 2], [1, 2, 3, 4, 5], [2], [2, 0], [2, 0, 3], [3]]

　　通過上面例子可以發(fā)現(xiàn)，當(dāng)key=None時，排序規(guī)則和列表的簡單排序一樣，比如[1,1,0]>[1,1]，前面兩個元素相等時，就看長度，長度大的大。

元素為元組的列表

　　先說元組，由于sort是對原址排序，而元組內(nèi)部不可修改，所以直接對元組是不能排序的。但是，我們的數(shù)據(jù)類型是列表，列表的每一個元素是元組，由于整體是列表類型，當(dāng)然可以調(diào)用sort函數(shù)排序了。先看元組如何比較大?。?/p>

print((4,2)&gt;(2,3))#True
print((4,2)&gt;(2,2,1))#True

　　也就是說元組比較大小和簡單列表比較大小的規(guī)則相同。

tuple1=[(4,2),(2,3),(3,1)]
tuple1.sort()
print(tuple1)#[(2, 3), (3, 1), (4, 2)]

元素為字典的列表

　　先看個例子:

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 2, 'a': 1}
dict3 = {'a': 1, 'b': 3}
print(dict1 == dict2)  # True，與順序無關(guān)
print(dict1 == dict3)  # False
print(dict1 &gt; dict3)  # 報錯TypeError: '&gt;' not supported between instances of 'dict' and 'dict'

　　兩個字典不能直接比較大小，==（調(diào)用了__eq__()函數(shù)）是比較內(nèi)容是不是一樣的。所以元素為字典的列表是不能直接調(diào)用sort函數(shù)排序的。

當(dāng)key不為None:

　　按照自定義的規(guī)則進行排序。我們需要給key傳入一個函數(shù)作為參數(shù)，按照函數(shù)的規(guī)則進行排序。這個函數(shù)接受一個參數(shù)并返回一個用于排序的關(guān)鍵字。具體是什么意思呢？先看個簡單的例子：

lst=[[1, 2], [1, 1], [2, 0], [6, 3,0], [1, 2,3]]
def sort_by_first_element(lst):
    return lst[0]
lst.sort(key=sort_by_first_element)
print(lst)#[[1, 2], [1, 1], [1, 2, 3], [2, 0], [6, 3, 0]]

　　將參數(shù)傳入給了sort函數(shù)的key,觀察排序的結(jié)果，可以發(fā)現(xiàn)上面代碼元素的排序是按照每個元素(仍然是列表)的第一個元素進行比較大小的，不比較第二個元素，若第一個元素相等，則兩個元素相等，不改變順序，比如[1,2]與[1,1]按照排序規(guī)則是相等的。進一步，觀察sort_by_first_element這個函數(shù)，返回值是lst[0]。似乎返回的是[1,2]。又是怎么做到比較每一個元素（列表）的第一個元素的呢？仔細(xì)思考，sort_by_first_element(lst):中的lst其實是形參，另外，可以發(fā)現(xiàn)一定是sort函數(shù)內(nèi)部實現(xiàn)了排序，其根據(jù)給定原始列表信息lst及函數(shù)sort_by_first_element返回值是能實現(xiàn)排序結(jié)果的，也就是說想要返回元素的第一個元素，那么sort_by_first_element(lst)中的lst可能傳入?yún)?shù)時像這樣：sort_by_first_element(lst[0]),sort_by_first_element(lst[1])等，再返回lst[0]時，就真正做到了返回元素的第一個元素。這里用自己的方法實現(xiàn)一下sort函數(shù)（猜測python內(nèi)部可能采用了快速排序用C語言實現(xiàn)了sort函數(shù)，實現(xiàn)排序）。代碼如下：

"""
MyLIst類定義了sort方法用于對列表排序
"""
class MyList:
    def __init__(self, mylist=None):
        """
        :param mylist: 傳入一個列表
        """
        self.mylist = mylist
    def sort(self, key=None):  # key傳入函數(shù)名
        print("對象調(diào)用了MyList類里面的sort方法")
        lst = []
        for item in self.mylist:
            lst.append(item)
        print("排序前:", lst)
        # 冒泡排序
        try:
            for i in range(len(self.mylist) - 1):  # [0,長度-1)，只需要循環(huán)  長度-1 次就能排序完，最后一個元素可以不用排序
                for j in range(0, len(self.mylist) - 1 - i):
                    if key(self.mylist[j]) &gt; key(self.mylist[j + 1]):
                        self.mylist[j], self.mylist[j + 1] = self.mylist[j + 1], self.mylist[j]  # python的語法支持這種交換
        except Exception as e:
            print(e)
            print("可能是索引越界了")
    def __str__(self):
        return str(self.mylist)
def sort_by_first_element(lst):
    return lst[0]
def sort_by_second_element(lst):
    return lst[1]
if __name__ == '__main__':
    mylist=MyList([[1, 1, 0], [2, 0],[1, 2], [1, 1], [2, 0, 3]])
    mylist.sort(key=sort_by_first_element)#對第一個元素進行排序
    print("排序后" ':',end=' ')
    print(mylist)#調(diào)用__str__()
    mylist2 = MyList([[1, 1, 0], [2, 0], [1, 2], [1, 1], [2, 0, 3]])
    #或者傳入lambda匿名函數(shù)
    mylist2.sort(key=lambda e:e[1])#對第二個元素進行排序，相當(dāng)于 mylist.sort(key=sort_by_second_element)
    print("排序后" ':', end=' ')
    print(mylist2)

　　運行結(jié)果：

　　key后面?zhèn)魅雔ambda匿名函數(shù)，更簡潔。我們可以改變key傳入的函數(shù)，來改變排序規(guī)則，下面給一個自定義按長度實現(xiàn)排序的例子：

mylist=[[1, 1, 0], [2, 0],[1, 2], [1, 1], [2, 0, 3],[3],[2],[1,2,3,4,5]]
mylist.sort(key=lambda e:len(e))#對第一個元素進行排序
print(mylist)#[[3], [2], [2, 0], [1, 2], [1, 1], [1, 1, 0], [2, 0, 3], [1, 2, 3, 4, 5]]

　　根據(jù)字典的值對列表進行排序:

lst = [{'name': 'Alice', 'age': 25},
       {'name': 'Bob', 'age': 30},
       {'name': 'Charlie', 'age': 20}]
# 使用sort方法排序（原址排序）
lst.sort(key=lambda x: x['age'])#改變原列表順序
print(lst)  # 輸出：[{'name': 'Charlie', 'age': 20}, {'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30}]

2. sorted函數(shù)

　　sorted函數(shù)也是Python內(nèi)置的一個函數(shù)，用于對可迭代對象進行排序操作。它的基本用法如下：

　　sorted(iterable, key=None, reverse=False)

　　參數(shù)：

　　iterable：可迭代對象，比如列表、元組、字符串等。

　　key：可選參數(shù)，用于指定排序的關(guān)鍵字函數(shù)，它接收一個參數(shù)并返回一個用于排序的關(guān)鍵字。如果不指定該參數(shù)，則默認(rèn)按照元素的自然順序排序。

　　reverse：可選參數(shù)，為一個布爾值，默認(rèn)為False，表示升序排序。如果設(shè)置為True，則表示降序排序。

　　返回值：返回一個新的已排序的列表。

lst = [5, 2, 9, 1, 8]
sorted_lst = sorted(lst)
print(sorted_lst)  # 輸出：[1, 2, 5, 8, 9]，沒有改變lst的元素順序
str = "hello"
sorted_str = sorted(str)
print(sorted_str)  # 輸出：['e', 'h', 'l', 'l', 'o']
#注意并沒有改變原來str字符串的序列順序，而且字符串本身也不能改變

　　看一個key不為None的例子

lst = [{'name': 'Alice', 'age': 25},
       {'name': 'Bob', 'age': 30},
       {'name': 'Charlie', 'age': 20}]
# 使用sorted函數(shù)排序
sorted_lst = sorted(lst, key=lambda x: x['age'])#返回新的列表，不改變原列表順序
print(sorted_lst)  # 輸出：[{'name': 'Charlie', 'age': 20}, {'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30}]

小結(jié)：sort函數(shù)用于列表的排序，更改原序列。而sorted用于可迭代對象的排序（包括列表），返回新的序列；注意，如果元素逐個比較相等時，就比較長度，比如：[1,1]<[1,1,0];常用高階函數(shù)除了sort、sorted之外，還有map、filter、max等。sorted函數(shù)，sorted函數(shù)內(nèi)部是C語言快速排序，運行快，返回修改后的新列表，不改變原列表的順序。

到此這篇關(guān)于python的sort函數(shù)與sorted函數(shù)排序的文章就介紹到這了,更多相關(guān)python的sort函數(shù)與sorted函數(shù)排序內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: