Python 列表 · ZetCode 中文系列教程

# Python 列表 > 原文： [http://zetcode.com/lang/python/lists/](http://zetcode.com/lang/python/lists/) 在 Python 編程教程的這一部分中，我們將更詳細地介紹 Python 列表。 ## Python 列表定義列表是值的有序集合。它可以包含各種類型的值。列表是可變容器。這意味著我們可以添加值，刪除值或修改現有值。 Python 列表表示有限序列的數學概念。列表的值稱為列表的項目或元素。列表可以多次包含相同的值。每次出現都被視為不同的項目。 ## Python 列表索引列表元素可以通過其索引進行訪問。第一個元素的索引為 0，最后一個元素的索引為 -1。 `simple.py` ```py #!/usr/bin/env python # simple.py nums = [1, 2, 3, 4, 5] print(nums) ``` 這是一個包含五個元素的簡單列表。該列表由方括號`[]`分隔。列表的元素由逗號分隔。列表的內容將打印到控制臺。 ```py $ ./simple.py [1, 2, 3, 4, 5] ``` 這是示例的輸出。列表可以包含各種數據類型的元素。 `various_types.py` ```py #!/usr/bin/env python # various_types.py class Being: pass objects = [1, -2, 3.4, None, False, [1, 2], "Python", (2, 3), Being(), {}] print(objects) ``` 在示例中，我們創建一個對象列表。它包含數字，布爾值，另一個列表，字符串，元組，自定義對象和字典。 ```py $ ./various_types.py [1, -2, 3.4, None, False, [1, 2], 'Python', (2, 3), <__main__.Being instance at 0x7f653577f6c8>, {}] ``` 這是輸出。 ## Python 列表初始化有時我們需要預先初始化一個列表以具有特定數量的元素。 `initialization.py` ```py #!/usr/bin/env python n1 = [0 for i in range(15)] n2 = [0] * 15 print(n1) print(n2) n1[0:11] = [10] * 10 print(n1) ``` 在此示例中，我們使用列表推導和*運算符初始化了兩個列表。 ```py n1 = [0 for i in range(15)] n2 = [0] * 15 ``` 這兩個列表被初始化為十五個零。 ```py n1[0:11] = [10] * 10 ``` 前十個值將替換為 10s。 ```py $ ./initialization.py [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 0, 0, 0, 0] ``` 這是示例輸出。 ## Python 列表函數 `list()`函數從可迭代對象創建列表。可迭代的對象可以是序列，支持迭代的容器或迭代器對象。如果未指定任何參數，則創建一個新的空列表。 `list_fun.py` ```py #!/usr/bin/env python # list_fun.py a = [] b = list() print(a == b) print(list((1, 2, 3))) print(list("ZetCode")) print(list(['Ruby', 'Python', 'Perl'])) ``` 在示例中，我們創建一個空列表，一個元組列表，一個字符串和另一個列表。 ```py a = [] b = list() ``` 這是創建空列表的兩種方法。 ```py print(a == b) ``` 該行打印`True`。這證實了`a`和`b`相等。 ```py print(list((1, 2, 3))) ``` 我們從 Python 元組創建一個列表。 ```py print(list("ZetCode")) ``` 該行從字符串生成列表。 ```py print(list(['Ruby', 'Python', 'Perl'])) ``` 最后，我們創建一個字符串列表的副本。 ```py $ ./list_fun.py True [1, 2, 3] ['Z', 'e', 't', 'C', 'o', 'd', 'e'] ['Ruby', 'Python', 'Perl'] ``` 這是示例輸出。 ## Python 列表操作以下代碼顯示了一些基本的列表操作。 `list_oper.py` ```py #!/usr/bin/env python # list_oper.py n1 = [1, 2, 3, 4, 5] n2 = [3, 4, 5, 6, 7] print(n1 == n2) print(n1 + n2) print(n1 * 3) print(2 in n1) print(2 in n2) ``` 我們定義了兩個整數列表。我們在這些列表上使用一些運算符。 ```py print(n1 == n2) ``` 列表的內容與`==`運算符進行比較。由于元素不同，該行打印`False`。 ```py print(n1 + n2) ``` 添加`n1`和`n2`列表以形成新列表。新列表包含兩個列表的所有元素。 ```py print(n1 * 3) ``` 我們在列表上使用乘法運算符。它重復元素 n 次；在我們的情況下是三遍。 ```py print(2 in n1) ``` 我們使用`in`運算符來找出列表中是否存在該值。它返回布爾值`True`或`False`。 ```py $ ./lists.py False [1, 2, 3, 4, 5, 3, 4, 5, 6, 7] [1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5] True False ``` 運行示例將給出此輸出。 ## Python 序列函數序列函數可用于任何序列類型，包括列表。 `sequence_funs.py` ```py #!/usr/bin/env python # sequence_funs.py n = [1, 2, 3, 4, 5, 6, 7, 8] print("There are {0} items".format(len(n))) print("Maximum is {0}".format(max(n))) print("Minimum is {0}".format(min(n))) print("The sum of values is {0}".format(sum(n))) ``` 在上面的示例中，我們具有四個函數：`len()`，`max()`，`min()`和`sum()`。 ```py print("There are {0} items".format(len(n))) ``` `len()`函數返回列表的大小。列表中元素的數量。 ```py print("Maximum is {0}".format(max(n))) print("Minimum is {0}".format(min(n))) ``` `max()`和`min()`函數返回列表的最大值和最小值。 ```py print("The sum of values is {0}".format(sum(n))) ``` `sum()`函數計算`n`列表中數字的總和。 ```py $ ./sequence_funs.py There are 8 items Maximum is 8 Minimum is 1 The sum of values is 36 ``` 這是輸出。 ## Python 添加列表元素本節將顯示如何將元素添加到 Python 列表中。 `adding.py` ```py #!/usr/bin/env python # adding.py langs = [] langs.append("Python") langs.append("Perl") print(langs) langs.insert(0, "PHP") langs.insert(2, "Lua") print(langs) langs.extend(("JavaScript", "ActionScript")) print(langs) ``` 我們可以通過三種方法將新元素添加到列表中：`append()`，`insert()`和`extend()`。 ```py langs = [] ``` 創建一個空列表。 ```py langs.append("Python") langs.append("Perl") ``` `append()`方法將一個項目添加到列表的末尾；我們附加兩個字符串。 ```py langs.insert(0, "PHP") langs.insert(2, "Lua") ``` `insert()`方法將元素放置在索引號指示的特定位置。 `"PHP"`字符串插入第一個位置，`"Lua"`字符串插入第三個位置。請注意，列表索引號從零開始。 ```py langs.extend(("JavaScript", "ActionScript")) ``` `extend()`方法將值的序列添加到列表的末尾。在我們的例子中，兩個 Python 元組字符串附加在列表的末尾。 ```py $ ./adding.py ['Python', 'Perl'] ['PHP', 'Python', 'Lua', 'Perl'] ['PHP', 'Python', 'Lua', 'Perl', 'JavaScript', 'ActionScript'] ``` 這是示例輸出。 ## IndexError 列表下標超出范圍時，將引發`IndexError`。 `index_error.py` ```py #!/usr/bin/env python # index_error.py n = [1, 2, 3, 4, 5] try: n[0] = 10 n[6] = 60 except IndexError as e: print(e) ``` 在腳本中，我們定義了一個包含五個整數的列表。這些元素的索引分別為 0、1、2、3 和 4。使用較大的索引會導致錯誤。 ```py n[6] = 60 ``` 索引 6 超出了我們的列表范圍。拋出`IndexError`。 ```py except IndexError as e: print(e) ``` 我們使用`except`子句捕獲錯誤。在子句的正文中，我們顯示錯誤消息。 ```py $ ./index_error.py list assignment index out of range ``` 這是示例輸出。 ## TypeError 如果元組的索引不是純整數，則會拋出`TypeError`。 `type_error.py` ```py #!/usr/bin/env python # type_error.py n = [1, 2, 3, 4, 5] try: print(n[1]) print(n['2']) except TypeError as e: print("Error in file {0}".format( __file__)) print("Message: {0}".format(e)) ``` 本示例拋出一個`TypeError`。 ```py print(n['2']) ``` 列表索引必須是整數。其他類型以錯誤結尾。 ```py except TypeError as e: print("Error in file {0}".format( __file__)) print("Message: {0}".format(e)) ``` 在`except`塊中，我們打印發生異常的文件名和消息字符串。 ```py $ ./typeerror.py 2 Error in file ./typeerror.py Message: list indices must be integers, not str ``` 這是示例輸出。 ## 從 Python 列表中刪除元素以前，我們已將項目添加到列表中。現在，我們將從列表中刪除它們。 `removing.py` ```py #!/usr/bin/env python # removing.py langs = ["Python", "Ruby", "Perl", "Lua", "JavaScript"] print(langs) lang = langs.pop(3) print("{0} was removed".format(lang)) lang = langs.pop() print("{0} was removed".format(lang)) print(langs) langs.remove("Ruby") print(langs) ``` `pop()`方法刪除并返回具有指定索引的元素，如果沒有給出索引號，則返回最后一個元素。 `remove()`方法從列表中刪除特定項目。 ```py lang = langs.pop(3) print("{0} was removed".format(lang)) ``` 我們刪除具有索引 3 的元素。`pop()`方法返回已刪除元素的名稱；它被打印到控制臺。 ```py lang = langs.pop() print("{0} was removed".format(lang)) ``` 列表中的最后一個元素，即`"JavaScript"`字符串，從列表中刪除。 ```py langs.remove("Ruby") ``` 此行從`langs`列表中刪除`"Ruby"`字符串。 ```py ['Python', 'Ruby', 'Perl', 'Lua', 'JavaScript'] Lua was removed JavaScript was removed ['Python', 'Ruby', 'Perl'] ['Python', 'Perl'] ``` 從腳本的輸出中，我們可以看到所描述方法的效果。 `del`關鍵字也可用于刪除列表元素。 `removing2.py` ```py #!/usr/bin/env python # removing2.py langs = ["Python", "Ruby", "Perl", "Lua", "JavaScript"] print(langs) del langs[1] print(langs) #del langs[15] del langs[:] print(langs) ``` 我們有一個字符串列表。我們使用`del`關鍵字刪除列表元素。 ```py del langs[1] ``` 我們從列表中刪除第二個字符串。它是`"Ruby"`字符串。 ```py #del langs[15] ``` 我們只能刪除現有元素。如果取消注釋代碼行，我們將收到`IndexError`消息。 ```py del langs[:] ``` 在這里，我們從列表中刪除所有剩余的元素。 `[:]`字符表示列表的所有項目。 ```py $ ./removing2.py ['Python', 'Ruby', 'Perl', 'Lua', 'JavaScript'] ['Python', 'Perl', 'Lua', 'JavaScript'] [] ``` 這是示例輸出。 ## Python 修改列表元素在下一個示例中，我們將修改列表元素。 `modifying.py` ```py #!/usr/bin/env python # modifying.py langs = ["Python", "Ruby", "Perl"] langs.pop(2) langs.insert(2, "PHP") print(langs) langs[2] = "Perl" print(langs) ``` 在示例中，我們兩次修改了`langs`列表的第三個元素。 ```py langs.pop(2) langs.insert(2, "PHP") ``` 修改元素的一種方法是將其刪除，然后將另一個元素放置在同一位置。 ```py langs[2] = "Perl" ``` 另一種方法更簡單。我們在給定位置分配一個新元素。現在，在第三個位置再次有`"Perl"`字符串。 ```py $ ./modifying.py ['Python', 'Ruby', 'PHP'] ['Python', 'Ruby', 'Perl'] ``` 這是示例輸出。 ## Python 復制列表我們可以通過多種方式在 Python 中復制列表。我們將提及其中的一些。 `copying.py` ```py #!/usr/bin/env python # copying.py import copy w = ["Python", "Ruby", "Perl"] c1 = w[:] c2 = list(w) c3 = copy.copy(w) c4 = copy.deepcopy(w) c5 = [e for e in w] c6 = [] for e in w: c6.append(e) c7 = [] c7.extend(w) print(c1, c2, c3, c4, c5, c6, c7) ``` 我們列出了三個字符串。我們將列表復制了七次。 ```py import copy ``` 我們導入`copy`模塊，其中有兩種復制方法。 ```py c1 = w[:] ``` 使用切片語法復制列表。 ```py c2 = list(w) ``` 當`list()`函數將列表作為參數時，它會創建一個列表副本。 ```py c3 = copy.copy(w) c4 = copy.deepcopy(w) ``` `copy()`方法產生列表的淺表副本。 `deepcopy()`產生列表的深層副本。 ```py c5 = [e for e in w] ``` 使用列表推導創建字符串的副本。 ```py c6 = [] for e in w: c6.append(e) ``` 由`for`循環創建的副本。 ```py c7 = [] c7.extend(w) ``` `extend()`方法也可用于創建副本。 ```py $ ./copying.py ['Python', 'Ruby', 'Perl'] ['Python', 'Ruby', 'Perl'] ['Python', 'Ruby', 'Perl'] ['Python', 'Ruby', 'Perl'] ['Python', 'Ruby', 'Perl'] ['Python', 'Ruby', 'Perl'] ['Python', 'Ruby', 'Perl'] ``` 使用不同的技術創建了一個字符串列表的七個副本。 ## Python 索引列表元素 Python 列表中的元素可以通過其索引進行訪問。索引號是整數；他們從零開始。索引可以是負數；負索引是指列表末尾的元素。列表中的第一項具有索引 0，最后一項具有-1。 `indexing.py` ```py #!/usr/bin/env python # indexing.py n = [1, 2, 3, 4, 5, 6, 7, 8] print(n[0]) print(n[-1]) print(n[-2]) print(n[3]) print(n[5]) ``` 我們可以通過其索引訪問列表的元素。索引位于列表名稱后方括號`[]`之間。 ```py print(n[0]) print(n[-1]) print(n[-2]) ``` 這三行將打印列表的第一，最后和最后一個項目。 ```py print(n[3]) print(n[5]) ``` 兩行顯示列表的第四和第六個元素。 ```py $ ./indexing.py 1 8 7 4 6 ``` 這是示例輸出。 `index(e, start, end)`方法查找特定元素并返回其最低索引。 `start`和`end`是可選參數，它們將搜索限制到給定的邊界。 `indexing2.py` ```py #!/usr/bin/env python # indexing2.py n = [1, 2, 3, 4, 1, 2, 3, 1, 2] print(n.index(1)) print(n.index(2)) print(n.index(1, 1)) print(n.index(2, 2)) print(n.index(1, 2, 5)) print(n.index(3, 4, 8)) ``` `index()`方法的代碼示例。 ```py print(n.index(1)) print(n.index(2)) ``` 這兩行顯示 n 列表中最左邊的 1、2 值的索引。 ```py print(n.index(1, 1)) print(n.index(2, 2)) ``` 在這里，我們在指定索引之后搜索值 1 和 2。 ```py print(n.index(1, 2, 5)) ``` 在這里，我們在索引為 2 和 5 的值之間搜索值 1。 ```py $ ./indexing2.py 0 1 4 5 4 6 ``` 這是示例輸出。 ## Python 切片列表列表切片是一種從列表中提取某些元素并將其形成另一個列表的操作。可能具有不同數量的索引和不同的索引范圍。列表切片的語法如下： ```py [start:end:step] ``` 語法的開始，結束，步驟部分是整數。它們每個都是可選的。它們可以是正面的也可以是負面的。具有結束索引的值不包括在切片中。 `slice.py` ```py #!/usr/bin/env python # slice.py n = [1, 2, 3, 4, 5, 6, 7, 8] print(n[1:5]) print(n[:5]) print(n[1:]) print(n[:]) ``` 我們從八個整數的列表中創建四個切片。 ```py print(n[1:5]) ``` 第一個切片的索引值為 1、2、3 和 4。新形成的列表為`[2, 3, 4, 5]`。 ```py print(n[:5]) ``` 如果省略起始索引，則假定默認值為 0。切片為`[1, 2, 3, 4, 5]`。 ```py print(n[1:]) ``` 如果省略了結束索引，則采用-1 默認值。在這種情況下，切片將所有值帶到列表的末尾。 ```py print(n[:]) ``` 甚至兩個索引都可以忽略。此語法創建列表的副本。 ```py $ ./slice.py [2, 3, 4, 5] [1, 2, 3, 4, 5] [2, 3, 4, 5, 6, 7, 8] [1, 2, 3, 4, 5, 6, 7, 8] ``` 示例的輸出。切片語法中的第三個索引是步驟。它允許我們從列表中獲取第 n 個值。 `slice2.py` ```py #!/usr/bin/env python # slice2.py n = [1, 2, 3, 4, 5, 6, 7, 8] print(n[1:9:2]) print(n[::2]) print(n[::1]) print(n[1::3]) ``` 我們使用`step`值形成四個新列表。 ```py print(n[1:9:2]) ``` 在這里，我們創建一個切片，該切片具有從 n 列表開始的每個第二元素，從第二個元素開始，以第八個元素結束。新列表具有以下元素：`[2, 4, 6, 8]`。 ```py print(n[::2]) ``` 在這里，我們通過獲取列表開頭到結尾的每個第二個值來構建切片。 ```py print(n[::1]) ``` 這將創建一個列表的副本。 ```py print(n[1::3]) ``` 切片具有第二個元素，從第二個元素到列表的末尾。 ```py $ ./slice2.py [2, 4, 6, 8] [1, 3, 5, 7] [1, 2, 3, 4, 5, 6, 7, 8] [2, 5, 8] ``` 示例的輸出。索引可以是負數。負索引是指列表末尾的值。最后一個元素的索引為-1，最后一個元素的索引為-2，依此類推。負數較小的索引必須在語法中排在首位。這意味著我們寫`[-6, -2]`而不是`[-2, -6]`。后者返回一個空列表。 `slice3.py` ```py #!/usr/bin/env python # slice3.py n = [1, 2, 3, 4, 5, 6, 7, 8] print(n[-4:-1]) print(n[-1:-4]) print(n[-5:]) print(n[-6:-2:2]) print(n[::-1]) ``` 在此腳本中，我們形成五個列表。我們還使用負索引號。 ```py print(n[-4:-1]) print(n[-1:-4]) ``` 第一行返回`[5, 6, 7]`，第二行返回一個空列表。較低的索引必須先于較高的索引。 ```py print(n[::-1]) ``` 這將創建一個反向列表。 ```py $ ./slice3.py [5, 6, 7] [] [4, 5, 6, 7, 8] [3, 5] [8, 7, 6, 5, 4, 3, 2, 1] ``` 示例的輸出。上面提到的語法可以在分配中使用。賦值的右側必須有一個可迭代的對象。 `slice4.py` ```py #!/usr/bin/env python # slice4.py n = [1, 2, 3, 4, 5, 6, 7, 8] n[0] = 10 n[1:3] = 20, 30 n[3::1] = 40, 50, 60, 70, 80 print(n) ``` 我們有八個整數的列表。我們使用切片語法將元素替換為新值。 ## 遍歷 Python 列表本節將指出在 Python 中遍歷列表的三種基本方法。 `traverse.py` ```py #!/usr/bin/env python # traverse.py n = [1, 2, 3, 4, 5] for e in n: print(e, end=" ") print() ``` 第一個是遍歷列表的最直接方法。 ```py n = [1, 2, 3, 4, 5] ``` 我們有一個數字列表。列表中有五個整數。 ```py for e in n: print(e, end=" ") ``` 使用`for`循環，我們一張一張地瀏覽列表，然后將當前元素打印到控制臺。 ```py $ ./traverse.py 1 2 3 4 5 ``` 這是腳本的輸出。整數將打印到終端。第二個示例更為詳細。 `traverse2.py` ```py #!/usr/bin/env python # traverse2.py n = [1, 2, 3, 4, 5] i = 0 s = len(n) while i < s: print(n[i], end=" ") i = i + 1 print() ``` 我們正在使用`while`循環遍歷列表。 ```py i = 0 l = len(n) ``` 首先，我們需要定義一個計數器并找出列表的大小。 ```py while i < s: print(n[i], end=" ") i = i + 1 ``` 在這兩個數字的幫助下，我們遍歷列表并將每個元素打印到終端。 `enumerate()`內置函數為我們提供了循環中列表的索引和值。 `traverse3.py` ```py #!/usr/bin/env python # traverse3.py n = [1, 2, 3, 4, 5] print(list(enumerate(n))) for e, i in enumerate(n): print("n[{0}] = {1}".format(e, i)) ``` 在示例中，我們打印值和值的索引。 ```py $ ./traverse3.py [(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)] n[0] = 1 n[1] = 2 n[2] = 3 n[3] = 4 n[4] = 5 ``` 運行腳本。 ## Python 計數列表元素有時對列表元素進行計數很重要。為此，Python 具有`count()`方法。 `counting.py` ```py #!/usr/bin/env python # counting.py n = [1, 1, 2, 3, 4, 4, 4, 5] print(n.count(4)) print(n.count(1)) print(n.count(2)) print(n.count(6)) ``` 在此示例中，我們計算`n`列表中幾個數字的出現次數。 ```py n = [1, 1, 2, 3, 4, 4, 4, 5] ``` 我們有一個整數列表。整數 1 和 4 多次出現。 ```py print(n.count(4)) print(n.count(1)) print(n.count(2)) print(n.count(6)) ``` 使用`count()`方法，我們發現 4、1、2 和 6 個數字的出現。 ```py $ ./counting.py 3 2 1 0 ``` 數字 4 出現 3 次，1 次兩次，2 次一次以及 6 在列表中不存在。 ## Python 嵌套列表可以將列表嵌套到另一個列表中。使用嵌套列表，將創建一個新維度。要訪問嵌套列表，需要附加的方括號`[]`。 `nested.py` ```py #!/usr/bin/env python # nested.py nums = [[1, 2], [3, 4], [5, 6]] print(nums[0]) print(nums[1]) print(nums[2]) print(nums[0][0]) print(nums[0][1]) print(nums[1][0]) print(nums[2][1]) print(len(nums)) ``` 在示例中，我們有三個嵌套列表，每個嵌套列表包含兩個元素。 ```py print(nums[0]) print(nums[1]) print(nums[2]) ``` nums 列表的三個嵌套列表將打印到控制臺。 ```py print(nums[0][0]) print(nums[0][1]) ``` 在這里，我們打印第一個嵌套列表的兩個元素。 `nums[0]`引用第一個嵌套列表； `nums[0][0]`引用第一個嵌套列表的第一個元素，即 1。 ```py print(len(nums)) ``` 該行顯示 3。每個嵌套列表都計為一個元素。不考慮其內部元素。 ```py $ ./nested.py [1, 2] [3, 4] [5, 6] 1 2 3 6 3 ``` 這是示例輸出。第二個示例具有其他維度。 `nested2.py` ```py #!/usr/bin/env python # nested2.py nums = [[1, 2, [3, 4, [5, 6]]]] print(nums[0]) print(nums[0][2]) print(nums[0][2][2]) print(nums[0][0]) print(nums[0][2][1]) print(nums[0][2][2][0]) ``` 在示例中，`[5, 6]`列表嵌套到`[3, 4, ...]`列表中，`[3, 4, [4, 6]]`嵌套到`[1, 2, ...]`列表中，最終是`nums`列表的元素。 ```py print(nums[0]) print(nums[0][2]) print(nums[0][2][2]) ``` 這三行將嵌套列表打印到控制臺。 ```py print(nums[0][0]) print(nums[0][2][1]) print(nums[0][2][2][0]) ``` 在此訪問三個元素。引用內部列表時，需要其他方括號`[]`。 ```py $ ./nested2.py [1, 2, [3, 4, [5, 6]]] [3, 4, [5, 6]] [5, 6] 1 4 5 ``` 這是示例輸出。 ## Python 排序列表在本節中，我們對列表元素進行排序。 Python 具有用于執行排序的內置列表方法`sort()`和`sorted()`函數。 `sorting.py` ```py #!/usr/bin/env python # sorting.py n = [3, 4, 7, 1, 2, 8, 9, 5, 6] print(n) n.sort() print(n) n.sort(reverse=True) print(n) ``` 在代碼示例中，我們有一個未排序整數的列表。我們使用`sort()`方法對元素進行排序。該方法對元素進行原位排序；原始列表已修改。 ```py n.sort() ``` `sort()`方法以升序對元素進行排序。 ```py n.sort(reverse=True) ``` 將反向參數設置為`True`時，列表以降序排序。 ```py $ ./sorting.py [3, 4, 7, 1, 2, 8, 9, 5, 6] [1, 2, 3, 4, 5, 6, 7, 8, 9] [9, 8, 7, 6, 5, 4, 3, 2, 1] ``` 在輸出中，我們可以看到原始列表，即按升序和降序排序的列表。如果我們不想更改原始列表，可以使用`sorted`函數。此函數創建一個新的排序列表。 `sorting2.py` ```py #!/usr/bin/env python # sorting2.py n = [3, 4, 1, 7, 2, 5, 8, 6] print(n) print(sorted(n)) print(n) ``` 在示例中，我們使用`sorted()`函數對列表的元素進行排序。 ```py $ ./sorting2.py [3, 4, 1, 7, 2, 5, 8, 6] [1, 2, 3, 4, 5, 6, 7, 8] [3, 4, 1, 7, 2, 5, 8, 6] ``` 從腳本的輸出中，我們可以看到原始列表沒有被修改。 `sort()`方法具有可選的`key`參數。該參數指定在進行比較之前在每個列表元素上要調用的函數。 `sorting3.py` ```py #!/usr/bin/env python # sorting3.py words = ["big", "Blue", "seven", "glass", "Green", "after", "Anctartica"] words.sort() print(words) words.sort(key=str.lower) print(words) ``` 該示例產生區分大小寫和不區分大小寫的字符串比較。 ```py words.sort(key=str.lower) ``` 為了創建不區分大小寫的比較，我們將`str.lower`函數添加到`key`參數中。 ```py $ ./sorting3.py ['Anctartica', 'Blue', 'Green', 'after', 'big', 'glass', 'seven'] ['after', 'Anctartica', 'big', 'Blue', 'glass', 'Green', 'seven'] ``` 這是示例輸出。如果要對 Unicode 字符串進行排序，我們需要做其他工作。 `sorting_locale.py` ```py #!/usr/bin/env python import locale from functools import cmp_to_key w = [u'zem', u'?tebot', u'rum', u'?elezo', u'prameň', u"sob"] locale.setlocale(locale.LC_COLLATE, ('sk_SK', 'UTF8')) w.sort(key=cmp_to_key(locale.strcoll)) for e in w: print(e) ``` 我們有六個 unicode 字符串的列表。我們更改語言環境設置，以根據當前語言選項對字符串進行排序。 ```py import locale from functools import cmp_to_key ``` 我們導入`locale`模塊和`cmp_to_key`轉換函數。 ```py w = [u'zem', u'?tebot', u'rum', u'?elezo', u'prameň', u"sob"] ``` 這是六個字符串的列表。字符串使用斯洛伐克語，并帶有一些變音標記。它們在正確排序字符方面發揮作用。 ```py locale.setlocale(locale.LC_COLLATE, ('sk_SK', 'UTF8')) ``` 我們為斯洛伐克語設置了語言環境。 ```py w.sort(key=cmp_to_key(locale.strcoll)) ``` 我們對列表進行排序。 `locale.strcoll`根據當前`LC_COLLATE`設置比較兩個字符串。 `cmp_to_key`函數將`old-style`比較函數轉換為鍵函數。 ```py for e in w: print(e) ``` 我們將已排序的單詞打印到控制臺。 ```py $ ./sorting_locale.py prameň rum sob ?tebot zem ?elezo ``` 元素已正確排序。考慮了斯洛伐克字母的細節。 ## Python 反轉列表元素我們可以在 Python 中以幾種方式反轉列表中的元素。反向元素不應與反向排序混淆。 `reversing.py` ```py #!/usr/bin/env python # reversing.py a1 = ["bear", "lion", "tiger", "eagle"] a2 = ["bear", "lion", "tiger", "eagle"] a3 = ["bear", "lion", "tiger", "eagle"] a1.reverse() print(a1) it = reversed(a2) r = list() for e in it: r.append(e) print(r) print(a3[::-1]) ``` 在示例中，我們有三個相同的字符串列表。我們以三種不同的方式反轉元素。 ```py a1.reverse() ``` 第一種方法是使用`reverse()`方法。 ```py it = reversed(a2) r = list() for e in it: r.append(e) ``` `reversed()`函數返回一個反向迭代器。我們在`for`循環中使用迭代器，并創建一個新的反向列表。 ```py print(a3[::-1]) ``` 第三種方法是使用`slice`語法反轉列表，其中`step`參數設置為-1。 ```py $ ./reversing.py ['eagle', 'tiger', 'lion', 'bear'] ['eagle', 'tiger', 'lion', 'bear'] ['eagle', 'tiger', 'lion', 'bear'] ``` 三個列表全部顛倒了。 ## Python 列表推導式列表推導式是一種基于現有列表創建列表的語法結構。語法受集合的數學符號的影響。 Python 語法受 Haskell 編程語言啟發。 ```py L = [expression for variable in sequence [if condition]] ``` 上面的偽代碼顯示了列表推導式的語法。列表推導式會創建一個新列表。它基于現有列表。 `for`循環遍歷整個序列。對于每個循環，如果滿足條件，則對表達式進行求值。如果計算出該值，它將被添加到新列表中。條件是可選的。在可以使用`map()`和`filter()`和/或嵌套循環的情況下，列表推導式為創建列表提供了一種更簡潔的方法。 `list_comprehension.py` ```py #!/usr/bin/env python # list_comprehension.py a = [1, 2, 3, 4, 5, 6, 7, 8, 9] b = [e for e in a if e % 2] print(b) ``` 在示例中，我們定義了一個數字列表。在列表推導式的幫助下，我們創建了一個新的數字列表，這些數字不能除以 2 而沒有余數。 ```py a = [1, 2, 3, 4, 5, 6, 7, 8, 9] ``` 這是九個整數的列表。 ```py b = [e for e in a if e % 2] ``` 這里我們有列表推導式。在`for e in a`循環中，獲取列表的每個元素。然后測試`if e % 2`條件。如果滿足條件，則對表達式求值。在我們的例子中，表達式是一個純`e`，它直接使用元素。最后，元素被添加到列表中。 ```py $ ./list_comprehension.py [1, 3, 5, 7, 9] ``` 示例輸出。列表中的數字不能除以 2，不能有余數。在第二個示例中，我們將列表推導式與傳統的`for`循環進行了比較。 `list_comprehension2.py` ```py #!/usr/bin/env python # list_comprehension2.py lang = "Python" a = [] for e in lang: a.append(ord(e)) b = [ord(e) for e in lang] print(a) print(b) ``` 在示例中，我們有一個字符串。我們要創建字符串字母的 ASCII 整數代碼的列表。 ```py a = [] for e in lang: a.append(ord(e)) ``` 我們使用`for`循環創建這樣的列表。 ```py b = [ord(e) for e in lang] ``` 這里使用列表推導產生相同的結果。注意，省略了`if`條件。它是可選的。 ```py $ ./list_comprehension2.py [80, 121, 116, 104, 111, 110] [80, 121, 116, 104, 111, 110] ``` 這是示例輸出。您可以在 [Python 列表推導](/articles/pythonlistcomprehensions/)教程中找到有關列表推導的更多信息。 ## Python 映射和過濾器函數 `map()`和`filter()`函數是可在所有列表項上使用的質量函數。它們是 Python 語言內置的函數編程的一部分。今天，建議盡可能使用列表推導代替這些函數。 `map_fun.py` ```py #!/usr/bin/env python # map_fun.py def to_upper(s): return s.upper() words = ["stone", "cloud", "dream", "sky"] words2 = list(map(to_upper, words)) print(words2) ``` `map()`函數將特定函數應用于列表的每個元素。 ```py def to_upper(s): return s.upper() ``` 這是將應用于每個列表元素的函數的定義。它在給定的字符串上調用`upper()`字符串方法。 ```py words = ["stone", "cloud", "dream", "sky"] ``` 這是字符串列表。 ```py words2 = map(to_upper, words) print(words2) ``` `map()`函數將`to_upper()`函數應用于單詞列表的每個字符串元素。形成一個新列表并返回。我們將其打印到控制臺。 ```py $ ./map_fun.py ['STONE', 'CLOUD', 'DREAM', 'SKY'] ``` 列表中的每一項均以大寫字母表示。 `filter()`函數從列表的那些元素中為函數返回`true`的列表構造一個列表。 `filter_fun.py` ```py #!/usr/bin/env python # filter_fun.py def positive(x): return x > 0 n = [-2, 0, 1, 2, -3, 4, 4, -1] print(list(filter(positive, n))) ``` 演示`filter()`函數的示例。它將創建一個僅具有正值的新列表。它將濾除所有負值和 0。 ```py def positive(x): return x > 0 ``` 這是`filter()`函數使用的函數的定義。返回`True`或`False`。返回布爾值的函數稱為謂詞。 ```py $ ./filter_fun.py [1, 2, 4, 4] ``` `filter_fun.py`腳本的輸出。在 Python 教程的這一部分中，我們描述了 Python 列表。