python數據結構

 

. 數據結構¶

 

.1. 深刻列表¶

鏈表類型有不少方法，這裏是鏈表類型的全部方法:

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. index ( x )

返回鏈表中第一個值爲 x 的元素的索引。若是沒有匹配的元素就會返回一個錯誤。

list. count ( x )

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

list. sort ( )

對鏈表中的元素就地進行排序。

list. reverse ( )

就地倒排鏈表中的元素。

下面這個示例演示了鏈表的大部分方法

>>> 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]

.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]

.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'])

.1.3. 函數式編程工具¶

對於鏈表來說，有三個內置函數很是有用： filter(), map(), 和 reduce() 。

filter(function, sequence) 返回一個sequence（序列），包括了給定序列中全部調用 function(item) 後返回值爲true的元素。（若是可能的話，會返回相同的類型）。若是該 序列 （sequence） 是一個 string （字符串）或者 tuple （元組），返回值一定是同一類型，不然，它老是 list 。例如，如下程序能夠計算部分素數

>>> def f(x): return x % 2 != 0 and x % 3 != 0
...
>>> filter(f, range(2, 25))
[5, 7, 11, 13, 17, 19, 23]

map(function, sequence) 爲每個元素依次調用 function(item) 並將返回值組成一個鏈表返回。例如，如下程序計算立方

>>> def cube(x): return x*x*x
...
>>> map(cube, range(1, 11))
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]

能夠傳入多個序列，函數也必需要有對應數量的參數，執行時會依次用各序列上對應的元素來調用函數（若是某些序列比其它的短，就用 None 來代替）。若是把 None 作爲一個函數傳入，則直接返回參數作爲替代。例如

>>> seq = range(8)
>>> def add(x, y): return x+y
...
>>> map(add, seq, seq)
[0, 2, 4, 6, 8, 10, 12, 14]

reduce(func, sequence) 返回一個單值，它是這樣構造的：首先以序列的前兩個元素調用函數 function ，再以返回值和第三個參數調用，依次執行下去。例如，如下程序計算 1 到 10 的整數之和

>>> def add(x,y): return x+y
...
>>> reduce(add, range(1, 11))
55

若是序列中只有一個元素，就返回它，若是序列是空的，就拋出一個異常。

能夠傳入第三個參數作爲初始值。若是序列是空的，就返回初始值，不然函數會先接收初始值和序列的第一個元素，而後是返回值和下一個元素，依此類推。例如

>>> def sum(seq):
...     def add(x,y): return x+y
...     return reduce(add, seq, 0)
...
>>> sum(range(1, 11))
55
>>> sum([])
0

不要像示例中這樣定義 sum() ：由於合計數值是一個通用的需求，早已有內置的 sum(sequence) 函數，很是好用。

New in version 2.3.

.1.4. 列表推導式¶

列表推導式爲從序列中建立列表提供了一個簡單的方法。 普通的應用程式經過將一些操做應用於序列的每一個成員並經過返回的元素建立列表，或者經過知足特定條件的元素建立子序列。

例如, 假設咱們建立一個squares列表, 能夠像下面方式

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

咱們一樣可以達到目的採用下面的方式

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

這也至關於 squares = map(lambda x: x**2, 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 語句的順序。

若是想要獲得一個元組，必需要加上括號

>>> 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: 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']

.1.4.1. 嵌套的列表推導式¶

列表推導式能夠嵌套。

考慮如下的 3x4 矩陣， 一個列表中包含三個長度爲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() 函數將會作的更好

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

更多關於本行中使用的星號（*）的說明，參考 參數列表的分拆 。

.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 的其它用法。

.3. 元組和序列¶

咱們知道鏈表和字符串有不少通用的屬性，例如索引和切割操做。它們是 序列 類型（參見 typesseq ）中的兩種。由於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))

如你所見，元組在輸出時老是有括號的，以便於正確表達嵌套結構。在輸入時能夠有或沒有括號，不過常常括號都是必須的（若是元組是一個更大的表達式的一部分）。

元組有不少用途。例如 (x, y) 座標對，數據庫中的員工記錄等等。元組就像字符串，不可改變：不能給元組的一個獨立的元素賦值（儘管你能夠經過聯接和切割來模擬）。還能夠建立包含可變對象的元組，例如鏈表。

一個特殊的問題是構造包含零個或一個元素的元組：爲了適應這種狀況，語法上有一些額外的改變。一對空的括號能夠建立空元組；要建立一個單元素元組能夠在值後面跟一個逗號（在括號中放入一個單值不夠明確）。醜陋，可是有效。例如

>>> 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 ）其實只是元組封裝和序列拆封的一個結合。

.4. 集合¶

Python 還包含了一個數據類型—— set （集合） 。集合是一個無序不重複元素的集。基本功能包括關係測試和消除重複元素。集合對象還支持 union（聯合），intersection（交），difference（差）和sysmmetric difference（對稱差集）等數學運算。

如下是一個簡單的演示

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> fruit = set(basket)               # create a set without duplicates
>>> fruit
set(['orange', 'pear', 'apple', 'banana'])
>>> 'orange' in fruit                 # fast membership testing
True
>>> 'crabgrass' in fruit
False

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

.5. 字典¶

另外一個很是有用的 Python 內建數據類型是 字典 （參見 typesmapping ）。字典在某些語言中可能稱爲 聯合內存 （ associative memories ）或 聯合數組 （ associative arrays ）。序列是以連續的整數爲索引，與此不一樣的是，字典以 關鍵字 爲索引，關鍵字能夠是任意不可變類型，一般用字符串或數值。若是元組中只包含字符串和數字，它能夠作爲關鍵字，若是它直接或間接的包含了可變對象，就不能當作關鍵字。不能用鏈表作關鍵字，由於鏈表能夠用索引、切割或者 append() 和 extend() 等方法改變。

理解字典的最佳方式是把它看作無序的鍵： 值對 （key:value pairs）集合，鍵必須是互不相同的（在同一個字典以內）。一對大括號建立一個空的字典： {} 。初始化鏈表時，在大括號內放置一組逗號分隔的鍵：值對，這也是字典輸出的方式。

字典的主要操做是依據鍵來存儲和析取值。也能夠用 del 來刪除鍵：值對（key:value）。若是你用一個已經存在的關鍵字存儲值，之前爲該關鍵字分配的值就會被遺忘。試圖從一個不存在的鍵中取值會致使錯誤。

字典的 keys() 方法返回由全部關鍵字組成的鏈表，該鏈表的順序不定（若是你須要它有序，只能調用關鍵字鏈表的 sorted() 方法）。能夠用 in 關鍵字檢查字典中是否存在某一關鍵字。

這裏有個字典用法的小例子

>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'sape': 4139, 'guido': 4127, 'jack': 4098}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'guido': 4127, 'irv': 4127, 'jack': 4098}
>>> tel.keys()
['guido', 'irv', 'jack']
>>> 'guido' in tel
True

鏈表中存儲關鍵字-值對元組的話，dict() 能夠從中直接構造字典。鍵-值對來自某個特定模式時，能夠用鏈表推導式簡單的生成關鍵字-值鏈表。:

>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'jack': 4098, 'guido': 4127}
>>> dict([(x, x**2) for x in (2, 4, 6)])     # use a list comprehension
{2: 4, 4: 16, 6: 36}

在入門指南後面的內容中，咱們將會學習更適於爲 dict() 構造器生成鍵值對的生成器表達式。

使用簡單字符串做爲關鍵字的話，一般用關鍵字參數更簡單

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

.6. 循環技巧¶

在字典中循環時，關鍵字和對應的值可使用 iteritems() 方法同時解讀出來。:

>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.iteritems():
...     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(xrange(1,10,2)):
...     print i
...
9
7
5
3
1

要按排序後的順序循環序列的話，使用 sorted() 函數，它不改動原序列，而是生成一個新的已排序的序列。:

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

.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 (notB)) 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 程序員常常對此抱怨，不過它避免了一類在 C 程序中司空見慣的錯誤：想要在解析式中使 == 時誤用了 = 操做符。

.8. 比較序列和其它類型¶

序列對象能夠與相同類型的其它對象比較。比較操做按 字典序 進行：首先比較前兩個元素，若是不一樣，就決定了比較的結果；若是相同，就比較後兩個元素，依此類推，直到全部序列都完成比較。若是兩個元素自己就是一樣類 型的序列，就遞歸字典序比較。若是兩個序列的全部子項都相等，就認爲序列相等。若是一個序列是另外一個序列的初始子序列，較短的一個序列就小於另外一個。字符 串的字典序按照單字符的 ASCII 順序。下面是同類型序列之間比較的一些例子

(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)

須要注意的是不一樣類型的對象比較是合法的。輸出結果是肯定而非任意的：類型按它們的名字排序。於是，一個鏈表（list）老是小於一個字符串（string），一個字符串（string）老是小於一個元組（tuple）等等。 [1] 數值類型比較時會統一它們的數據類型，因此0等於0.0，等等。