python(二)列表與元組

一.序列(sequence):序列中每個元素分配一個序號--元素的位置,也稱爲索引.第一個索引是0,以此類推.Python有六種內建的序列(列表,元組,字符串,Unicode字符串，buffer對象與xrange對象)

列表與元組的主要區別在於，列表可以修改而元組則不能。也就是說如果要根據要求來添加元素，那麼列表會更好用，而序列不能修改的時候，元組全更合適。序列也可以包含其他的序列。

>>> edward = ['Edward Gumbe',42]
>>> john = ['John Smith',50]
>>> database = [edward,john]
>>> database
[['Edward Gumbe', 42], ['John Smith', 50]]

所有序列類型都可進行某些特定的操作：索引(indexing),分片(sliceing),加(adding),減(multiplying)以及檢查某個元素是否屬於序列的成員,此外還有計算序列的長度,找出最大元素和最小元素的內建函數.

1.1索引:所有的索引都是從0開始遞增,可以通過編號分別訪問,使用負數索引時,Python會從右邊,也就是從最後1個元素開始計數,最後一個元素的編號是-1.

>>> greeting = "Hello"
>>> greeting[0]
'H'
>>> greeting[3]
'l'
>>> greeting[-1]
'o' 

字符串字面值能夠直接使用索引而不需要一個變量引用它們.

>>> 'Hello'[1]
'e'
>>> fourth = raw_input("Year:")[3]
Year:2014
>>> fourth
'4'

1.2 分片 索引訪問單個元素,而分片操作訪問一定範圍內的元素,分片通過冒號相隔的2個索引來實現

>>> tag = '<a href="http://www.python.org">Python web site</a>'
>>> tag[9:30]
'http://www.python.org'
>>> tag[32:-4]
'Python web site'

分片操作對於提取序列的一部分是很有用的,而編號在這裏十分重要,第一個索引是需要提取的第一個元素的編號,而最後一個索引則是分片之後剩下部分的第1個元素的編號.

>>> numbers = [1,2,3,4,5,6,7,8,9,10]
>>> numbers[3:6]
[4, 5, 6]
>>> numbers[0:1]
[1]

總之:分片操作的實現需要提供兩個索引邊界,第1個索引是包含在分片內,而第2個則不包含在分片內.

>>> numbers[7:10]
[8, 9, 10]

索引10指向的是第11個元素--這個元素並不存在,卻是最後一個元素之後.

>>> numbers[-3:-1]
[8, 9]
>>> numbers[-3:0]
[]
>>> numbers[-3:]
[8, 9, 10]
>>> numbers[:3]
[1, 2, 3]
>>> numbers[:]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

只要分片中最左邊的索引比右邊的晚出現在序列中,結果就是一個空的序列,所以如果分片所得部分包括序列的結尾的元素,那麼只需置空最後一個元素即可.同樣適用於序列開始的元素
在分片的時候,分片的開始與結束需要進行指定,而另一個參數--步長(step length)--通常是隱匿設置,在普通中步長是1,

>>> numbers[::1]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> numbers[::2]
[1, 3, 5, 7, 9]
>>> numbers[::-2]
[10, 8, 6, 4, 2] 

當然步長不能爲0,那樣不會向下執行,但是步長可以是負數,即從左到左提取元素.

>>> numbers[1:10:-2]
[]
>>> numbers[10:1:-2]
[10, 8, 6, 4]

總結:開始點的元素包括中結果之中,而結束點的元素不在分片之內.當使用一個負數作爲步長時,必須讓開始大於結束點.對於一個正數步長,Python會從序列的頭部開始向右提取元素,直到最後一個元素,而對於負數步長,則是從序列的結尾部開始向左提到元素,直到第一個元素.

1.3 序列相加 

>>> [1,2,3]+[4,5,6]
[1, 2, 3, 4, 5, 6]
>>> 'Hello,'+'world!'
'Hello,world!'
>>> 'Hello,'+[1,2,3]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot concatenate 'str' and 'list' objects

列表與字符串是無法連接在一起的,儘管他們都是序列,簡單來說:2種相同類型的序列才能相加.

1,4相乘  用數字乘以一個序列會生成一個新的序列,在新的序列中,原來的序列被重複x次

>>> 'python'*5
'pythonpythonpythonpythonpython'
>>> [42]*10
[42, 42, 42, 42, 42, 42, 42, 42, 42, 42] 

空列表,None是Python內建值,它的含意是"這裏什麼都沒有",如果想被始化一個長度爲10的列表

>>> sequence = [None]*10
>>> sequence
[None, None, None, None, None, None, None, None, None, None]

1.5成員資格
檢查一個值是否在序列中,可以使用in運算符.這個運算符檢查某個條件是否爲真,然後返回相應的值:條件爲真返回true,條件爲假返回false.

>>> permission = 'rw'
>>> 'w' in permission
True
>>> 'x' in permission
False

1.6 長度,最小值與最大值

內建函數len,min與max非常有用.len返回序列中元素的數量,min與max返回序列中最大值與最小值.

>>> numbers = [12,42,52,13,99,85,25,75,100]
>>> len(numbers)
9
>>> min(numbers)
12
>>> max(numbers)
100

二,列表
2.1 list函數  字符串不能像列表一樣被修改,所以有時根據字符串創建列表會很有用.list適用與所有的序列,而不只是字符串

>>> list('Hello')
['H', 'e', 'l', 'l', 'o']

改變列表:元素賦值與刪除元素

>>> x = [1,1,1]
>>> x[1] = 3
>>> x
[1, 3, 1]
>>> del x[2]
>>> x
[1, 3] 

分片賦值:分片是一個非常強大的特性,而分片賦值則更加顯示它的強大.

>>> name = list('Perl')
>>> name
['P', 'e', 'r', 'l']
>>> name[2:]=list('ar')
>>> name
['P', 'e', 'a', 'r']
>>> name[3:]=list('john')
>>> name
['P', 'e', 'a', 'j', 'o', 'h', 'n']

分片賦值時,可以使用與原序列不等長的序列將分片替換,也可以在不需要替換任何原有元素的情況下插入新的元素

>>> numbers=[1,5]
>>> numbers
[1, 5]
>>> numbers[1:1]=[2,3,4]
>>> numbers
[1, 2, 3, 4, 5]
>>> numbers[1:4]=[]
>>> numbers
[1, 5]

列表的方法:方法是一個與某些對象緊密聯繫的函數,對象可能是列表,數字,也可能是字符串或者其它類型的對象.
append方法不是簡單返回一個修改過的新列表,而是直接修改原來的列表.

>>> lst=[1,2,3]
>>> lst
[1, 2, 3]
>>> lst.append(4)
>>> lst
[1, 2, 3, 4] 

count方法統計某個元素在列表中出現的次數.

>>> st = ['bo','be','or','not','to','be','to']
>>> st.count('bo')
1
>>> st.count('to')
2

extend方法是在列表末尾一次性追加另一個序列中的多個值.

>>> a = [1,2,4]
>>> b = [4,5,6]
>>> a.extend(b)
>>> a
[1, 2, 4, 4, 5, 6]
看起來有點像連接操作,區別中於,extend方法修改了擴展的序列,而原始連接操作不然,它會返回一個全新的列表

>>> a = [1,2,4]
>>> b = [4,5,6]
>>> a+b
[1, 2, 4, 4, 5, 6]
>>> a
[1, 2, 4]

index方法用於從列表中找出某個值在第一個匹配項的索引位置

>>> knights = ['we','are','the','knights','who','say','ni']
>>> knights.index('who')
4
>>> knights.index('ke')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 'ke' is not in list

insert方法用於將對象插入到列表中

>>> numbers = [1,2,4,5,6,7]
>>> numbers.insert(3,'four')
>>> numbers
[1, 2, 4, 'four', 5, 6, 7]

pop方法會移除列表中一個元素(默認是最後一個),並且返回該元素的值

>>> x = [1,2,3]
>>> x.pop()
3
>>> x
[1, 2]
>>> x.pop(0)
1
>>> x
[2] 

remove方法用於移除列表中某個值的第一個匹配項

>>> x = ['to','be','or','not','to','be']
>>> x
['to', 'be', 'or', 'not', 'to', 'be']
>>> x.remove('be')
>>> x
['to', 'or', 'not', 'to', 'be']
>>> x.remove('bee')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list

erverse方法將列表中的元素反向存放

>>> x = [1,2,3,7,1]
>>> x.reverse()
>>> x
[1, 7, 3, 2, 1]

sort方法用於在原位置對列表進行排序,意味着改變原來的列表,從而讓其中的元素能按一定順序排列,而不是簡單的返回一個已排序的列表副本

>>> x
[1, 7, 3, 2, 1]
>>> x.sort()
>>> x
[1, 1, 2, 3, 7]

如果即要保留原來的列表,又要獲取新的排序後的列表則用sorted

>>> x
[1, 7, 3, 2, 1]
>>> x.sort()
>>> x
[1, 1, 2, 3, 7]

元組  元組與列表一樣,也是一種序列,唯一不同的是元組不能修改,創建元組有逗號,一般需要小括號.

>>> 1,2,3
(1, 2, 3)
>>> (1,2,3)
(1, 2, 3)
>>> ()
()
>>> 2,
(2,)
>>> 3*(40+2)
126
>>> 3*(40+2,)
(42, 42, 42)

tuple函數:以一個列表爲參數,將序列轉換成元組.元組的分片還是元組

>>> tuple([1,2,4,23])
(1, 2, 4, 23)
>>> x = 1,2,3
>>> x[1]
2
>>> x[0:2]
(1, 2)