Python学习：数据结构
本文來自：入門指南
開胃菜參考：開胃菜
使用Python解釋器：使用Python解釋器
本文對Python的簡介：Python簡介
Python流程介紹：深入Python流程
目錄：
- 目錄：
- 5. 數據結構
- 5.1. 關于列表更多的內容
- 5.1.1. 把列表當作堆棧使用
- 5.1.2. 把列表當作隊列使用
- 5.1.3. 列表推導式
- 5.1.4. 嵌套的列表推導式
- 5.2. del 語句
- 5.3. 元組和序列
- 5.4. 集合
- 5.5. 字典
- 5.6. 循環技巧
5. 數據結構
本章詳細討論了你已經學過的一些知識，同樣也添加了一些新內容。
5.1. 關于列表更多的內容
Python 的列表數據類型包含更多的方法。這里是所有的列表對象方法：
list.append(x)把一個元素添加到列表的結尾，相當于 a[len(a):] = [x]。list.extend(L)將一個給定列表中的所有元素都添加到另一個列表中，相當于 a[len(a):] = L。list.insert(i, x)在指定位置插入一個元素。第一個參數是準備插入到其前面的那個元素的索引，例如 a.insert(0, x) 會插入到整個列表之前，而 a.insert(len(a), x) 相當于 a.append(x)。list.remove(x)刪除列表中值為 x 的第一個元素。如果沒有這樣的元素，就會返回一個錯誤。list.pop([i])從列表的指定位置刪除元素，并將其返回。如果沒有指定索引，a.pop() 返回最后一個元素。元素隨即從列表中被刪除（方法中 i 兩邊的方括號表示這個參數是可選的，而不是要求你輸入一對方括號，你會經常在Python 庫參考手冊中遇到這樣的標記）。list.clear()從列表中刪除所有元素。相當于 del a[:]。list.index(x)返回列表中第一個值為 x 的元素的索引。如果沒有匹配的元素就會返回一個錯誤。list.count(x)返回 x 在列表中出現的次數。list.sort()對列表中的元素就地進行排序。list.reverse()就地倒排列表中的元素。list.copy()返回列表的一個淺拷貝。等同于 a[:]。下面這個示例演示了列表的大部分方法:
>>> a = [66.25, 333, 333, 1, 1234.5] >>> print(a.count(333), a.count(66.25), a.count('x')) 2 1 0 >>> a.insert(2, -1) >>> a.append(333) >>> a [66.25, 333, -1, 333, 1, 1234.5, 333] >>> a.index(333) 1 >>> a.remove(333) >>> a [66.25, -1, 333, 1, 1234.5, 333] >>> a.reverse() >>> a [333, 1234.5, 1, 333, -1, 66.25] >>> a.sort() >>> a [-1, 1, 66.25, 333, 333, 1234.5] >>> a.pop() 1234.5 >>> a [-1, 1, 66.25, 333, 333]也許大家會發現像 insert， remove 或者 sort 這些修改列表的方法沒有打印返回值–它們返回 None。 ?1 ?在 python 中對所有可變的數據類型這是統一的設計原則
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 列表, 可以像下面方式:
>>> squares = [] >>> for x in range(10): ... squares.append(x**2) ... >>> squares [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]注意這個 for 循環中的被創建(或被重寫)的名為 x 的變量在循環完畢后依然存在。使用如下方法，我們可以計算squares的值而不會產生任何的副作用:
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, in ?[x, x**2 for x in range(6)]^ SyntaxError: invalid syntax >>> # 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. 嵌套的列表推導式
列表解析中的第一個表達式可以是任何表達式，包括列表解析。
考慮下面由三個長度為 4 的列表組成的 3x4 矩陣:
>>> 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. 元組和序列
我們知道列表和字符串有很多通用的屬性，例如索引和切割操作。它們是 序列 類型（參見 Sequence Types — 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])如你所見，元組在輸出時總是有括號的，以便于正確表達嵌套結構。在輸入時可以有或沒有括號，不過經常括號都是必須的（如果元組是一個更大的表達式的一部分）。不能給元組的一個獨立的元素賦值（盡管你可以通過聯接和切割來模擬）。還可以創建包含可變對象的元組，例如列表。
雖然元組和列表很類似，它們經常被用來在不同的情況和不同的用途。元組有很多用途。例如 (x, y) 坐標對，數據庫中的員工記錄等等。元組就像字符串， 不可變的。通常包含不同種類的元素并通過分拆（參閱本節后面的內容) 或索引訪問（如果是 namedtuples，甚至可以通過屬性）。列表是 可變的 ，它們的元素通常是相同類型的并通過迭代訪問。
一個特殊的問題是構造包含零個或一個元素的元組：為了適應這種情況，語法上有一些額外的改變。一對空的括號可以創建空元組；要創建一個單元素元組可以在值后面跟一個逗號（在括號中放入一個單值不夠明確）。丑陋，但是有效。例如:
>>> empty = () >>> singleton = 'hello', # <-- note trailing comma >>> len(empty) 0 >>> len(singleton) 1 >>> singleton ('hello',)語句 t = 12345, 54321, ‘hello!’ 是 元組封裝 （tuple packing）的一個例子：值 12345 ， 54321 和 ‘hello!’ 被封裝進元組。其逆操作可能是這樣:
>>> x, y, z = t這個調用等號右邊可以是任何線性序列，稱之為 序列拆封 非常恰當。序列拆封要求左側的變量數目與序列的元素個數相同。要注意的是可變參數（multiple assignment ）其實只是元組封裝和序列拆封的一個結合。
5.4. 集合
Python 還包含了一個數據類型 —— set （集合）。集合是一個無序不重復元素的集。基本功能包括關系測試和消除重復元素。集合對象還支持 union（聯合），intersection（交），difference（差）和 sysmmetric difference（對稱差集）等數學運算。
大括號或 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 either a or b {'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 內建數據類型是 字典 （參見 Mapping Types — dict ）。字典在某些語言中可能稱為 聯合內存 （ associative memories ）或 聯合數組 （ associative arrays ）。序列是以連續的整數為索引，與此不同的是，字典以 關鍵字 為索引，關鍵字可以是任意不可變類型，通常用字符串或數值。如果元組中只包含字符串和數字，它可以做為關鍵字，如果它直接或間接的包含了可變對象，就不能當做關鍵字。不能用列表做關鍵字，因為列表可以用索引、切割或者 append() 和 extend() 等方法改變。
理解字典的最佳方式是把它看做無序的鍵： 值對 （key:value 對）集合，鍵必須是互不相同的（在同一個字典之內）。一對大括號創建一個空的字典： {} 。初始化列表時，在大括號內放置一組逗號分隔的鍵：值對，這也是字典輸出的方式。
字典的主要操作是依據鍵來存儲和析取值。也可以用 del 來刪除鍵：值對（key:value）。如果你用一個已經存在的關鍵字存儲值，以前為該關鍵字分配的值就會被遺忘。試圖從一個不存在的鍵中取值會導致錯誤。
對一個字典執行 list(d.keys()) 將返回一個字典中所有關鍵字組成的無序列表（如果你想要排序，只需使用 sorted(d.keys()) 2. ?使用 in 關鍵字（指Python語法）可以檢查字典中是否存在某個關鍵字（指字典
>
它支持支持成員測試以及迭代等操作，但是它的內容不是獨立的原始字典 – 它只是一個 視圖。
這里是使用字典的一個小示例:
dict() 構造函數可以直接從 key-value 對中創建字典:
>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)]) {'sape': 4139, 'jack': 4098, 'guido': 4127}此外，字典推導式可以從任意的鍵值表達式中創建字典:
>>> {x: x**2 for x in (2, 4, 6)} {2: 4, 4: 16, 6: 36}如果關鍵字都是簡單的字符串，有時通過關鍵字參數指定 key-value 對更為方便:
>>> dict(sape=4139, guido=4127, jack=4098) {'sape': 4139, 'jack': 4098, 'guido': 4127}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() 函數，它不改動原序列，而是生成一個新的已排序的序列:<div class="se-preview-section-delimiter"></div>basket = [‘apple’, ‘orange’, ‘apple’, ‘pear’, ‘orange’, ‘banana’]
for f in sorted(set(basket)):
… print(f)
…
apple
banana
orange
pear
words = [‘cat’, ‘window’, ‘defenestrate’]
for w in words[:]: # Loop over a slice copy of the entire list.
… if len(w) > 6:
… words.insert(0, w)
…
words
[‘defenestrate’, ‘cat’, ‘window’, ‘defenestrate’]
string1, string2, string3 = ”, ‘Trondheim’, ‘Hammer Dance’
non_null = string1 or string2 or string3
non_null
‘Trondheim’
(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 異常，而不是提供一個隨意的結果。
Footnotes
總結
以上是生活随笔為你收集整理的Python学习：数据结构的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Python学习：深入Python流程控
- 下一篇： cad在线转低版本_【设计专业干货】史上