Previous Page

Up One Level

Next Page

Python指南

Contents

向前: 4. 深入流程控制 向上: Python 指南 向后: 6. 模塊


子目錄



 
5.
數據結構

本章節深入講述一些你已經學習過的東西,并且還加入了新的內容。

 
5.1
深入鏈表

鏈表類型有很多方法,這里是鏈表類型的所有方法:

append(

x)

把一個元素添加到鏈表的結尾,相當于 a[len(a):] = [x]

extend(

L)

通過添加指定鏈表的所有元素來擴充鏈表,相當于 a[len(a):] = L

insert(

i, x)

在指定位置插入一個元素。第一個參數是準備插入到其前面的那個元素的索引,例如 a.insert(0, x) 會插入到整個鏈表之前,而 a.insert(len(a), x) 相當于 a.append(x)

remove(

x)

刪除鏈表中值為x的第一個元素。如果沒有這樣的元素,就會返回一個錯誤。

pop(

[i])

從鏈表的指定位置刪除元素,并將其返回。如果沒有指定索引,a.pop() 返回最后一個元素。元素隨即從鏈表中被刪除。(方法中i兩邊的方括號表示這個參數是可選的,而不是要求你輸入一對方括號,你會經常在Python 庫參考手冊中遇到這樣的標記。)

index(

x)

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

count(

x)

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

sort(

)

對鏈表中的元素進行適當的排序。

reverse(

)

倒排鏈表中的元素。

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

>>> a = [66.6, 333, 333, 1, 1234.5]
>>> print a.count(333), a.count(66.6), a.count('x')
2 1 0
>>> a.insert(2, -1)
>>> a.append(333)
>>> a
[66.6, 333, -1, 333, 1, 1234.5, 333]
>>> a.index(333)
1
>>> a.remove(333)
>>> a
[66.6, -1, 333, 1, 1234.5, 333]
>>> a.reverse()
>>> a
[333, 1234.5, 1, 333, -1, 66.6]
>>> a.sort()
>>> a
[-1, 1, 66.6, 333, 333, 1234.5]

 
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
把鏈表當作隊列使用

你也可以把鏈表當做隊列使用,隊列是這樣的數據結構,最先進入的元素最先釋放(先進先出)。使用 append()方法可以把元素添加到隊列最后,以0為參數調用 pop() 方法可以把最先進入的元素釋放出來。例如:

>>> queue = ["Eric", "John", "Michael"]
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.pop(0)
'Eric'
>>> queue.pop(0)
'John'
>>> queue
['Michael', 'Terry', 'Graham']

 
5.1.3
函數化編程工具

對于鏈表來講,有三個內置函數非常有用:filter() map()reduce()

filter(function, sequence)” 返回一個序列(sequence),包括了給定序列中所有調用function(item)后返回值為true的元素。(如果可能的話,會返回相同的類型)。例如,以下程序可以計算部分素數:

>>> 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做為一個函數傳入,則直接返回參數做為替代。

組合這兩種情況,我們會發現“map(None, list1, list2)”是把一對序列變成元素對序列的便捷方式。例如:

>>> seq = range(8)
>>> def square(x): return x*x
...
>>> map(None, seq, map(square, seq))
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25), (6, 36), (7, 49)]

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

>>> 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():因為合計數值是一個通用的需求,在新的2.3版中,提供了內置的 sum(sequence) 函數。

5.1.4 鏈表推導式

鏈表推導式提供了一個創建鏈表的簡單途徑,無需使用 map() filter() 以及 lambda。 返回鏈表的定義通常要比創建這些鏈表更清晰。每一個鏈表推導式包括在一個for語句之后的表達式,零或多個forif語句。返回值是由forif子句之后的表達式得到的元素組成的鏈表。如果想要得到一個元組,必須要加上括號。

>>> freshfruit = ['  banana', '  loganberry ', 'passion fruit  ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
>>> vec = [2, 4, 6]
>>> [3*x for x in vec]
[6, 12, 18]
>>> [3*x for x in vec if x > 3]
[12, 18]
>>> [3*x for x in vec if x < 2]
[]
>>> [[x,x**2] for x in vec]
[[2, 4], [4, 16], [6, 36]]
>>> [x, x**2 for x in vec]      # error - parens required for tuples
  File "<stdin>", line 1, in ?
    [x, x**2 for x in vec]
               ^
SyntaxError: invalid syntax
>>> [(x, x**2) for x in vec]
[(2, 4), (4, 16), (6, 36)]
>>> vec1 = [2, 4, 6]
>>> vec2 = [4, 3, -9]
>>> [x*y for x in vec1 for y in vec2]
[8, 6, -18, 16, 12, -36, 24, 18, -54]
>>> [x+y for x in vec1 for y in vec2]
[6, 5, -7, 8, 7, -5, 10, 9, -3]
>>> [vec1[i]*vec2[i] for i in range(len(vec1))]
[8, 12, -54]

為使鏈表推導式匹配for循環的行為,可以在推導之外保留循環變量:

>>> x = 100                     # this gets overwritten
>>> [x**3 for x in range(5)]
[0, 1, 8, 27, 64]
>>> x                           # the final value for range(5)
4

 
5.2 del
語句

有一個方法可從鏈表中刪除指定索引的元素:del語句。這個方法也可以從鏈表中刪除切片(之前我們是把一個空鏈表賦給切片)。例如:

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

del 也可以用于刪除整個變量:

>>> del a

此后再引用這個名字會發生錯誤(至少要到給它賦另一個值為止)。后面我們還會發現del的其它用法。

 
5.3
元組(Tuples) 和序列(Sequences

我們知道鏈表和字符串有很多通用的屬性,例如索引和切片操作。它們是序列類型中的兩種。因為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!' 元組封裝(sequence packing的一個例子:值 12345 54321 'hello!' 被封裝進元組。其逆操作可能是這樣:

>>> x, y, z = t

這個調用被稱為序列拆封非常合適。序列拆封要求左側的變量數目與序列的元素個數相同。要注意的是可變參數(multiple assignment

)其實只是元組封裝和序列拆封的一個結合!

這里有一點不對稱:封裝多重參數通常會創建一個元組,而拆封操作可以作用于任何序列。

 
5.4
字典(Dictionaries

另一個非常有用的Python內建數據類型是字典(Dictionaries。字典在某些語言中可能稱為“聯合內存”(``associative memories'')或“聯合數組”(``associative arrays'')。序列是以連續的整數為索引,與此不同的是,字典以關鍵字為索引,關鍵字可以是任意不可變類型,通常用字符串或數值。如果元組中只包含字符串和數字,它可以做為關鍵字,如果它直接或間接的包含了可變對象,就不能當做關鍵字。不能用鏈表做關鍵字,因為鏈表可以用它們的 append() extend() 方法,或者用切片、或者通過檢索變量來即時改變。

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

字典的主要操作是依據關鍵字來存儲和析取值。也可以用del來刪除關鍵字:值對。如果你用一個已經存在的關鍵字存儲值,以前為該關鍵字分配的值就會被遺忘。試圖析取從一個不存在的關鍵字中讀取值會導致錯誤。

字典的keys() 方法返回由所有關鍵字組成的鏈表,該鏈表的順序不定(如果你需要它有序,只能調用關鍵字鏈表的sort()方法)。使用字典的 has_key() 方法可以檢查字典中是否存在某一關鍵字。

這是一個關于字典應用的小示例:

>>> 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']
>>> tel.has_key('guido')
True

鏈表中存儲關鍵字-值對元組的話,字典可以從中直接構造。關鍵字-值對來自一個模式時,可以用鏈表推導式簡單的表達關鍵字-值鏈表。

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

 
5.5
循環技巧

在字典中循環時,關鍵字和對應的值可以使用 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 %s?  It is %s.' % (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.

 
5.6
深入條件控制

用于whileif語句的條件包括了比較之外的操作符。

innot比較操作符審核值是否在一個區間之內。操作符isis not比較兩個對象是否相同; 這只和諸如鏈表這樣的可變對象有關。所有的比較操作符具有相同的優先級,低于所有的數值操作。

比較操作可以傳遞。例如 a < b == c 審核是否a小于bb等于c

比較操作可以通過邏輯操作符andor組合,比較的結果可以用not來取反義。這些操作符的優先級又低于比較操作符,在它們之中,not具有最高的優先級,or的優先組最低,所以A and not B or C 等于 (A and (not B)) or C。當然,表達式可以用期望的方式表示。

邏輯操作符and or 也稱作短路操作符:它們的參數從左向右解析,一旦結果可以確定就停止。例如,如果AC為真而B為假,A and B and C 不會解析C。作用于一個普通的非邏輯值時,短路操作符的返回值通常是最后一個變量。

可以把比較或其它邏輯表達式的返回值賦給一個變量,例如:

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

需要注意的是PythonC不同,內部表達式不能分配值。C 程序員經常對此抱怨,不過它避免了一類在C程序中司空見慣的錯誤:想要在解析式中使==時誤用了=操作符。

 
5.7
比較序列和其它類型

序列對象可以與相同類型的其它對象比較。 比較操作按字典序進行:首先比較前兩個元素,如果不同,就決定了比較的結果;如果相同,就比較后兩個元素,依此類推,直到所有序列都完成比較。如果兩個元素本身就是同樣類型的序列,就遞歸字典序比較。如果兩個序列的所有子項都相等,就認為序列相等。如果一個序列是另一個序列的初始子序列,較短的一個序列就小于另一個。字符串的字典序按照單字符的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)等等。數值類型比較時會統一它們的數據類型,所以0等于0.0,等等。5.1



注釋

... etc.5.1
不同類型對象的比較規則不依賴于此,它們有可能會在Python語言的后繼版本中改變。

Previous Page

Up One Level

Next Page

Python 指南

Contents

向前: 4. 深入流程控制 向上: Python 指南 向后: 6. 模塊


Release 2.3, documentation updated on July 29, 2003.

See About this document... for information on suggesting changes.
漏洞目錄, @ssv 2019足球国家队排名