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 刪除鍵:值對。如果您使用已在使用的鍵進行儲存，則與該鍵關聯的舊值將被遺忘。

透過下標 (d[key]) 提取不存在的鍵的值會引發 KeyError。為了避免在嘗試訪問可能不存在的鍵時出現此錯誤，請改用 get() 方法，如果鍵不在字典中，該方法將返回 None（或指定的預設值）。

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

這是一個使用字典的小例子

>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'jack': 4098, 'sape': 4139, 'guido': 4127}
>>> tel['jack']
4098
>>> tel['irv']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'irv'
>>> print(tel.get('irv'))
None
>>> 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'

請注意，與 C 不同，在 Python 中，表示式內部的賦值必須顯式使用 海象運算子 := 來完成。這避免了 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();。