5. 資料結構

本章將更詳細地描述你已經學過的一些知識，並新增一些新內容。

5.1. 列表的更多用法

列表資料型別有一些更多的方法。以下是列表物件的所有方法

list.append(x)

將一個項新增到列表的末尾。類似於 a[len(a):] = [x]。

list.extend(iterable)

透過追加來自可迭代物件的所有項來擴充套件列表。類似於 a[len(a):] = iterable。

list.insert(i, x)

在給定的位置插入一個項。第一個引數是要在其之前插入元素的索引，因此 a.insert(0, x) 將在列表的開頭插入，而 a.insert(len(a), x) 等同於 a.append(x)。

list.remove(x)

從列表中刪除第一個值等於 x 的項。如果沒有這樣的項，它會引發一個 ValueError。

list.pop([i])

刪除列表中給定位置的項，並將其返回。如果未指定索引，則 a.pop() 刪除並返回列表中的最後一項。如果列表為空或索引超出列表範圍，它會引發一個 IndexError。

list.clear()

從列表中刪除所有項。類似於 del a[:]。

list.index(x[, start[, end]])

返回列表中第一個值等於 x 的項的從零開始的索引。如果沒有這樣的項，則引發一個 ValueError。

可選引數 start 和 end 的解釋方式與切片表示法相同，用於將搜尋限制為列表的特定子序列。返回的索引是相對於完整序列的開頭計算的，而不是 start 引數。

list.count(x)

返回 x 在列表中出現的次數。

list.sort(*, key=None, reverse=False)

就地對列表中的項進行排序（這些引數可用於排序自定義，請參閱 sorted() 以瞭解其解釋）。

list.reverse()

就地反轉列表的元素。

list.copy()

返回列表的淺複製。類似於 a[:]。

一個使用大多數列表方法的示例

>>> fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
>>> fruits.count('apple')
2
>>> fruits.count('tangerine')
0
>>> fruits.index('banana')
3
>>> fruits.index('banana', 4)  # Find next banana starting at position 4
6
>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']
>>> fruits.append('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> fruits.pop()
'pear'

你可能已經注意到，像 insert、remove 或 sort 這樣只修改列表的方法沒有列印返回值——它們返回預設的 None。[1] 這是 Python 中所有可變資料結構的設計原則。

你可能注意到的另一件事是，並非所有資料都可以排序或比較。例如，[None, 'hello', 10] 不會排序，因為整數不能與字串進行比較，而 None 不能與其他型別進行比較。此外，有些型別沒有定義的排序關係。例如，3+4j < 5+7j 不是有效的比較。

5.1.1. 將列表用作堆疊

列表方法使得將列表用作堆疊非常容易，其中最後新增的元素是第一個檢索的元素（“後進先出”）。要將一個項新增到堆疊的頂部，請使用 append()。要從堆疊頂部檢索一個項，請使用不帶顯式索引的 pop()。例如

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]

5.1.2. 將列表用作佇列

也可以將列表用作佇列，其中第一個新增的元素是第一個檢索的元素（“先進先出”）；但是，列表對於此目的效率不高。雖然從列表末尾追加和彈出速度很快，但從列表開頭進行插入或彈出速度很慢（因為所有其他元素都必須移動一個位置）。

要實現佇列，請使用 collections.deque，它的設計目的是可以快速地從兩端進行追加和彈出。例如

>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])

5.1.3. 列表推導式

列表推導式提供了一種建立列表的簡潔方法。常見的應用是建立新的列表，其中每個元素是將某些操作應用於另一個序列或可迭代物件的每個成員的結果，或者建立滿足特定條件的那些元素的子序列。

例如，假設我們要建立一個平方數的列表，如下所示

>>> squares = []
>>> for x in range(10):
...     squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

請注意，這會建立一個名為 x 的變數（或覆蓋它），該變數在迴圈完成後仍然存在。我們可以使用以下方法計算平方數列表而沒有任何副作用

squares = list(map(lambda x: x**2, range(10)))

或者，等效地

squares = [x**2 for x in range(10)]

它更簡潔且更具可讀性。

列表推導式由方括號組成，其中包含一個表示式，後跟一個 for 子句，然後是零個或多個 for 或 if 子句。結果將是一個新的列表，該列表是透過在它後面的 for 和 if 子句的上下文中計算表示式得出的。例如，如果兩個列表的元素不相等，則此列表推導式會將它們組合在一起

>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

它等同於

>>> combs = []
>>> for x in [1,2,3]:
...     for y in [3,1,4]:
...         if x != y:
...             combs.append((x, y))
...
>>> combs
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

請注意，for 和 if 語句的順序在這兩個程式碼片段中是相同的。

如果表示式是元組（例如，上一個示例中的 (x, y)），則必須將其用括號括起來。

>>> vec = [-4, -2, 0, 2, 4]
>>> # create a new list with the values doubled
>>> [x*2 for x in vec]
[-8, -4, 0, 4, 8]
>>> # filter the list to exclude negative numbers
>>> [x for x in vec if x >= 0]
[0, 2, 4]
>>> # apply a function to all the elements
>>> [abs(x) for x in vec]
[4, 2, 0, 2, 4]
>>> # call a method on each element
>>> freshfruit = ['  banana', '  loganberry ', 'passion fruit  ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
>>> # create a list of 2-tuples like (number, square)
>>> [(x, x**2) for x in range(6)]
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]
>>> # the tuple must be parenthesized, otherwise an error is raised
>>> [x, x**2 for x in range(6)]
  File "<stdin>", line 1
    [x, x**2 for x in range(6)]
     ^^^^^^^
SyntaxError: did you forget parentheses around the comprehension target?
>>> # flatten a list using a listcomp with two 'for'
>>> vec = [[1,2,3], [4,5,6], [7,8,9]]
>>> [num for elem in vec for num in elem]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

列表推導式可以包含複雜的表示式和巢狀函式

>>> from math import pi
>>> [str(round(pi, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']

5.1.4. 巢狀的列表推導式

列表推導式中的初始表示式可以是任何任意表達式，包括另一個列表推導式。

考慮以下示例，一個 3x4 的矩陣被實現為 3 個長度為 4 的列表的列表：

>>> matrix = [
...     [1, 2, 3, 4],
...     [5, 6, 7, 8],
...     [9, 10, 11, 12],
... ]

以下列表推導式將轉置行和列：

>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

正如我們在上一節中看到的，內部列表推導式是在其後的 for 語句的上下文中計算的，因此此示例等效於：

>>> transposed = []
>>> for i in range(4):
...     transposed.append([row[i] for row in matrix])
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

這反過來又等同於：

>>> transposed = []
>>> for i in range(4):
...     # the following 3 lines implement the nested listcomp
...     transposed_row = []
...     for row in matrix:
...         transposed_row.append(row[i])
...     transposed.append(transposed_row)
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

在實際應用中，你應該優先使用內建函式而不是複雜的流程語句。zip() 函式非常適合這種情況。

>>> list(zip(*matrix))
[(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]

有關此行中星號的詳細資訊，請參閱 解包引數列表。

5.2. del 語句

有一種方法可以根據索引而不是值從列表中刪除項：del 語句。這與返回值的 pop() 方法不同。del 語句還可用於從列表中刪除切片或清除整個列表（我們之前透過將空列表賦值給切片來實現）。例如：

>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]

del 也可以用於刪除整個變數：

>>> del a

此後引用名稱 a 會出錯（至少在為其分配另一個值之前）。我們稍後會發現 del 的其他用途。

5.3. 元組和序列

我們看到列表和字串有許多共同的屬性，例如索引和切片操作。它們是 序列 資料型別的兩個示例（請參閱 序列型別 — list, tuple, range）。由於 Python 是一種不斷發展的語言，因此可能會新增其他序列資料型別。還有另一種標準序列資料型別：元組。

元組由逗號分隔的多個值組成，例如：

>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> # Tuples may be nested:
>>> u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
>>> # Tuples are immutable:
>>> t[0] = 88888
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> # but they can contain mutable objects:
>>> v = ([1, 2, 3], [3, 2, 1])
>>> v
([1, 2, 3], [3, 2, 1])

如你所見，在輸出時，元組始終用括號括起來，以便正確解釋巢狀元組；它們可以在帶或不帶周圍括號的情況下輸入，儘管通常無論如何都需要括號（如果元組是較大表達式的一部分）。無法為元組的各個項賦值，但是可以建立包含可變物件的元組，例如列表。

雖然元組可能看起來與列表相似，但它們通常用於不同的情況和不同的目的。元組是 不可變的，並且通常包含透過解包（請參閱本節後面的內容）或索引（甚至在 namedtuples 的情況下透過屬性）訪問的異構元素序列。列表是 可變的，其元素通常是同質的，並透過迭代列表來訪問。

一個特殊的問題是構造包含 0 或 1 項的元組：語法有一些額外的怪癖來適應這些。空元組由一對空括號構造；包含一項的元組透過在值後加逗號來構造（僅用括號括起一個值是不夠的）。有點醜陋，但有效。例如：

>>> empty = ()
>>> singleton = 'hello',    # <-- note trailing comma
>>> len(empty)
0
>>> len(singleton)
1
>>> singleton
('hello',)

語句 t = 12345, 54321, 'hello!' 是 元組打包 的一個示例：值 12345、 54321 和 'hello!' 被打包到一個元組中。反向操作也是可能的：

>>> x, y, z = t

這被稱為，恰如其分地，序列解包，並且適用於右側的任何序列。序列解包要求等號左側的變數數與序列中的元素數相同。請注意，多重賦值實際上只是元組打包和序列解包的組合。

5.4. 集合

Python 還包括 集合 的資料型別。集合是一個無序的集合，沒有重複的元素。基本用途包括成員測試和消除重複條目。集合物件還支援數學運算，如並集、交集、差集和對稱差集。

可以使用花括號或 set() 函式來建立集合。注意：要建立一個空集，你必須使用 set()，而不是 {}；後者建立一個空字典，這是我們在下一節中討論的資料結構。

這是一個簡單的演示：

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # show that duplicates have been removed
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # fast membership testing
True
>>> 'crabgrass' in basket
False

>>> # Demonstrate set operations on unique letters from two words
>>>
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  # unique letters in a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # letters in a but not in b
{'r', 'd', 'b'}
>>> a | b                              # letters in a or b or both
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # letters in both a and b
{'a', 'c'}
>>> a ^ b                              # letters in a or b but not both
{'r', 'd', 'b', 'm', 'z', 'l'}

與 列表推導式 類似，也支援集合推導式：

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}

5.5. 字典

Python 中內建的另一種有用的資料型別是 字典（請參閱 對映型別 — dict）。字典有時在其他語言中被稱為“關聯儲存器”或“關聯陣列”。與透過數字範圍索引的序列不同，字典透過 鍵 索引，鍵可以是任何不可變型別；字串和數字始終可以是鍵。如果元組僅包含字串、數字或元組，則可以使用元組作為鍵；如果元組直接或間接包含任何可變物件，則不能將其用作鍵。你不能使用列表作為鍵，因為可以使用索引賦值、切片賦值或 append() 和 extend() 等方法就地修改列表。

最好將字典視為一組 鍵：值 對，要求鍵是唯一的（在一個字典中）。一對花括號建立一個空字典：{}。在花括號中放置一個逗號分隔的鍵值對列表會將初始鍵值對新增到字典中；這也是在輸出時寫入字典的方式。

字典的主要操作是儲存具有某個鍵的值，並提取給定鍵的值。也可以使用 del 刪除鍵值對。如果使用已使用的鍵進行儲存，則會忘記與該鍵關聯的舊值。使用不存在的鍵提取值是錯誤的。

在字典上執行 list(d) 會返回字典中使用的所有鍵的列表，按插入順序排列（如果你希望它排序，只需改用 sorted(d)）。要檢查單個鍵是否在字典中，請使用 in 關鍵字。

這是一個使用字典的小示例：

>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'jack': 4098, 'sape': 4139, 'guido': 4127}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'jack': 4098, 'guido': 4127, 'irv': 4127}
>>> list(tel)
['jack', 'guido', 'irv']
>>> sorted(tel)
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
>>> 'jack' not in tel
False

dict() 建構函式直接從鍵值對序列構建字典：

>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'guido': 4127, 'jack': 4098}

此外，可以使用字典推導式從任意鍵和值表示式建立字典：

>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}

當鍵是簡單的字串時，有時使用關鍵字引數指定對會更容易：

>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'guido': 4127, 'jack': 4098}

5.6. 迴圈技術

在遍歷字典時，可以使用 items() 方法同時檢索鍵和相應的值。

>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
...     print(k, v)
...
gallahad the pure
robin the brave

在遍歷序列時，可以使用 enumerate() 函式同時檢索位置索引和相應的值。

>>> for i, v in enumerate(['tic', 'tac', 'toe']):
...     print(i, v)
...
0 tic
1 tac
2 toe

要同時遍歷兩個或多個序列，可以使用 zip() 函式將條目配對。

>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
...     print('What is your {0}?  It is {1}.'.format(q, a))
...
What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue.

要以相反的順序遍歷序列，首先以正向指定序列，然後呼叫 reversed() 函式。

>>> for i in reversed(range(1, 10, 2)):
...     print(i)
...
9
7
5
3
1

要按排序順序遍歷序列，請使用 sorted() 函式，該函式返回一個新的排序列表，同時保持源不變。

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for i in sorted(basket):
...     print(i)
...
apple
apple
banana
orange
orange
pear

在序列上使用 set() 可以消除重複元素。將 sorted() 與 set() 結合使用是一種慣用方式，可以按排序順序遍歷序列的唯一元素。

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
...     print(f)
...
apple
banana
orange
pear

有時在迴圈遍歷列表時更改列表很誘人；但是，建立新列表通常更簡單、更安全。

>>> import math
>>> raw_data = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8]
>>> filtered_data = []
>>> for value in raw_data:
...     if not math.isnan(value):
...         filtered_data.append(value)
...
>>> filtered_data
[56.2, 51.7, 55.3, 52.5, 47.8]

5.7. 關於條件的更多資訊

while 和 if 語句中使用的條件可以包含任何運算子，而不僅僅是比較運算子。

比較運算子 in 和 not in 是成員檢測，用於確定一個值是否在一個容器中（或不在）。運算子 is 和 is not 比較兩個物件是否真的是同一個物件。所有比較運算子具有相同的優先順序，其優先順序低於所有數值運算子。

比較可以鏈式進行。例如，a < b == c 測試 a 是否小於 b，並且 b 是否等於 c。

比較可以使用布林運算子 and 和 or 組合，比較的結果（或任何其他布林表示式）可以使用 not 取反。這些運算子的優先順序低於比較運算子；在它們之間，not 的優先順序最高，or 的優先順序最低，因此 A and not B or C 等效於 (A and (not B)) or C。像往常一樣，可以使用括號來表達所需的組合方式。

布林運算子 and 和 or 是所謂的短路運算子：它們的引數從左到右進行求值，並且一旦確定結果就停止求值。例如，如果 A 和 C 為真，但 B 為假，則 A and B and C 不會求值表示式 C。當用作一般值而不是布林值時，短路運算子的返回值是最後一個被求值的引數。

可以將比較或其他布林表示式的結果賦值給變數。例如，

>>> string1, string2, string3 = '', 'Trondheim', 'Hammer Dance'
>>> non_null = string1 or string2 or string3
>>> non_null
'Trondheim'

請注意，在 Python 中，與 C 不同，表示式內部的賦值必須使用 海象運算子 := 顯式完成。這避免了 C 程式中常見的一類問題：在表示式中鍵入 = 時，本意是 ==。

5.8. 比較序列和其他型別

序列物件通常可以與相同序列型別的其他物件進行比較。比較使用字典順序：首先比較前兩個專案，如果它們不同，則確定比較的結果；如果它們相等，則比較接下來的兩個專案，依此類推，直到其中一個序列耗盡。如果要比較的兩個專案本身是相同型別的序列，則遞迴地執行字典比較。如果兩個序列的所有專案都比較相等，則認為這兩個序列相等。如果一個序列是另一個序列的初始子序列，則較短的序列較小。字串的字典順序使用 Unicode 程式碼點編號來排序各個字元。以下是一些相同型別序列之間比較的示例

(1, 2, 3)              < (1, 2, 4)
[1, 2, 3]              < [1, 2, 4]
'ABC' < 'C' < 'Pascal' < 'Python'
(1, 2, 3, 4)           < (1, 2, 4)
(1, 2)                 < (1, 2, -1)
(1, 2, 3)             == (1.0, 2.0, 3.0)
(1, 2, ('aa', 'ab'))   < (1, 2, ('abc', 'a'), 4)

請注意，如果物件具有適當的比較方法，則使用 < 或 > 比較不同型別的物件是合法的。例如，混合數值型別根據其數值進行比較，因此 0 等於 0.0，等等。否則，直譯器將引發 TypeError 異常，而不是提供任意的排序。

腳註

[1]

其他語言可能會返回已修改的物件，從而允許方法鏈式呼叫，例如 d->insert("a")->remove("b")->sort();。