python課程第二周 內建資料結構——列表和元組

標籤：python list tuple

5種內建資料結構：列表、元組、字典、集合、字串。列表、字典、字串三種被稱為線性結構。

• 針對線性結構的操作有：切片、封包和解包、成員運算子、迭代。

• 針對資料結構的操作有解析式：解析式分為列表解析、產生器解析、集合解析和字典解析。

後面三種是Python3.x特有的。

基本架構如下：

650) this.width=650;" src="http://s2.51cto.com/wyfs02/M00/8B/7C/wKiom1hPZYyjPAdMAABQd-R_pqE050.png" title="clipboard.png" style="float:left;" alt="wKiom1hPZYyjPAdMAABQd-R_pqE050.png" />

一、列表：Python中最具靈活性的有序集合物件類型

列表可包含任何種類的對象：數字、字串、字典、集合甚至其他列表，這個特性稱為異構。還具有可變長度和任意嵌套的特性，屬於可變長度序列。

（1）列表的初始化，有兩種方式，第一種使用list()函數，第二種直接使用空列表賦值：

>>>lst=list()>>>lst=[1,2,3]

（2）列表元素的訪問，主要通過列表的下標和索引。元素的下標從0開始。如果給出的下標超出下標範圍，會給出IndexError錯誤。也支援逆向訪問列表內部元素，下標從-1開始，同時支援序列的分區操作。

>>>lst[0]  訪問第一個元素1>>>lst[-1]        訪問最後一個元素，逆序訪問3>>>lst[2]          訪問最後一個元素3>>>lst[0:] 訪問第一個到最後一個元素[1,2,3]

（3）列表的方法：

增

append(object)    #給列表添加一個對象object，傳回值是None

insert(index,object) #給列表添加一個對象object，但是可以根據index確定插入位置，傳回值None

extend(iterable)#從迭代器中添加元素到列表中

下面是幾個樣本：

lst=[5,2,10]

索引是在清單索引範圍內，正常插入：

>>>lst.insert(0,7)>>>lst[7,5,2,10]

索引超出列表的範圍，在最後插入：

>>>lst.insert(100,13)>>>lst[7,5,2,10,13]

索引使用負值且在正常索引範圍內，從後往前插入：

>>>lst.insert(-1,12)>>>lst[7,5,2,10,12,13]

索引使用負值但是超出索引範圍，從最開始插入：

>>> lst.insert(-100,20)>>> lst[20, 7, 5.2, 10, 12, 13]

從迭代器中添加元素

>>>lst.extend([1,2,3])>>>lst[20, 7, 5.2, 10, 12, 13,1,2,3]

刪

pop(index)  #根據索引index將列表中的某個元素移除並返回這個元素，如果沒有給出index，返回最後一個元素。如果列表為空白或者索引超出範圍，則給出IndexError錯誤。

lst=[5,2,10]>>>lst.pop()10>>lst[5,2]>>>lst.pop(0)5>>>lst[2]>>>lst.pop(-1)2>>>lst[]

remove(value) #根據value值刪除list中的一個元素value，如果value不存在，會提示ValueError，傳回值None

>>>lst=[5,2,10]>>>lst.remove[10]>>>lst[5,2]

clear() #清除list中所有的元素，傳回值None。

>>>lst.clear()>>>lst[]

del L[k]

del L[i:j] 根據索引刪除指定值或者刪除某個範圍內的值

>>> lst=[1,2,3,4,5,6]>>> del lst[2]>>> lst[1, 2, 4, 5, 6]>>> del lst[0:2]>>> lst[4, 5, 6]

改

reverse() #將list中的元素反轉

sort(key=None, reverse=False) #將list中的元素有序排列，reverse為True時，將list逆序排列，key是個函數對象，使用該函數對list進行排序。排序後返回None。

L[k] = n  #根據清單索引來修改對應位置的值

樣本如下：

>>>lst= [5, 2, 10]>>>sort(lst)#排序>>>lst[2,5,10]>>>reverse(lst)   #倒轉>>>lst[10,5,2]>>>lst[0] = 100#索引改值>>>lst[100, 2, 10]

查

index(value,[start,[stop]])  #根據value值，返回start和stop索引範圍內第一次出現value的索引，value不存在時返回ValueError。

>>>lst= [‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]>>>lst.index(‘a‘)0>>>lst.append(‘b‘)>>>lst.index(‘b‘,0,4)1

count(value) #根據value值返回列表中value的個數，傳回值是整數

>>>lst.count(‘b‘)2

len(object,/)  #返回列表中的元素個數

>>>len(lst)6

其他方法

copy()  #返回list的一個副本。

切片操作

基本格式：seq[start:stop:step]，輸出的內容是[start,stop)，step指的是隔幾個數取一個值，看下面樣本。

>>>lst=[1,2,3,4,5,6,7,8]>>>lst[0:8][1,2,3,4,5,6,7,8]>>>lst[0:8:2][1,3,5,7]

因為一般情況下切片操作是從左往右，因此start一定要小於stop，否則只能得到一個空數組。

>>>lst[7:5][]

特殊情況下，例如step<0時，例如：

當start>stop時，step=-1，輸出(stop,start]

>>>lst[5:1:-1][6,5,4,3]

當start或stop超出索引範圍時（step>0），分為4種情況：

1. start超出索引，stop沒有超過索引，同時start的絕對值大於列表長度時，從索引0開始輸出一直到索引stop-1

>>>lst=[1,2,3,4,5,6,7,8]   #列表長度為8>>>lst[-10:5][1,2,3,4,5]

2. start超過索引，stop沒有超過索引，同時start的絕對值小於列表長度時，取值範圍是[len(lst)+start, stop]

>>>lst[-5:5]             #取值範圍是[8-5,5]，即[3,5][4,5]

2. stop超出索引，start沒有超過索引從start開始輸出，直到最後一個元素停止

>>>lst[3,100][4,5,6,7,8]

3. 當start和stop同時超出索引時，start絕對值大於數組長度，輸出seq第一個到最後一個元素。

>>> lst[-100:100][1, 2, 3, 4, 5, 6, 7, 8]

4. 當start和stop同時超出索引時，start絕對值小於數組長度時，取值範圍是[len(lst)+start:]

>>>lst[-5:100][4,5,6,7,8]

切片操作支援省略start或stop：

當start省略時，從索引0開始輸出，到stop-1停止

>>>lst[:5][1,2,3,4]

當stop省略時，從start開始，到最後一個元素停止

>>>lst[3:][4,5,6,7,8]

當start和stop都省略時，輸出seq所有元素。

lst[:][1, 2, 3, 4, 5, 6, 7, 8]

元組（tuple）：不可變的資料結構，位置有序的對象的集合。

通常寫成圓括弧中的一系列項，雖然元組不支援任何方法調用，但具有列表的大多數屬性。

• 通過位移和索引存取

• 屬於不可不序列類型

• 固定長度，不能伸長或縮短，異構，可以包含其他綜合物件，支援嵌套。

• 對象引用的數組，對元組進行索引操作的速度相對較快。

1. 元組的定義

t=()   #空元組t=tuple()  #空元組t=（1，2，3）#3個元素的元組，索引只能用來訪問元素t=（1，） #定義單個元素的元組時，需要在元素後面加個逗號，否則t就是一個數字。

2. 元組的方法

t.count(value)                    #返回元組內某個元素個數t.index(value,[start,[stop]])     #返回元素value第一次出現的索引t[i]、t[i:j]                      #根據索引來訪問元素，根據分區和長度來訪問元素t1+t2、t * 3                      #合并和重複

*元組的不可變性只有一層，即元組的元素是單層或不可變元素時，例如數字、字元，元組元素不可變，但元組的元素是多層可變元素時，該元素自身不能被改變，而元素內部值可變，例如列表，下面請看樣本：

1. 元組元素是數字和字串時

>>>t = ( 1, ‘test‘, 4)>>> t[0] = ‘a‘Traceback (most recent call last):File "<stdin>", line 1, in <module>TypeError: ‘tuple‘ object does not support item assignment    #元素不可變>>> t[1] = ‘TEST‘Traceback (most recent call last):File "<stdin>", line 1, in <module>TypeError: ‘tuple‘ object does not support item assignment   #元素不可變

2. 元組元素是數字、列表時

>>>t = (1, [2, 3], 4)>>> t[1] = [4, 5]Traceback (most recent call last):File "<stdin>", line 1, in <module>TypeError: ‘tuple‘ object does not support item assignment   #元組元素不可變>>> t[1][1] = 5>>> t(1, [2, 5], 4)       #列表仍然可變

元組通常用於處理具有固定關係的情況，在某些要求不可變內容的情形下應用。

本周的主要知識點如下：

1. 列表的初始化、基本的增刪改查方法；

2. 列表的分區處理

3. 元組的初始化和基本方法
   

本文出自 “無飛天下” 部落格，請務必保留此出處http://hf1208.blog.51cto.com/8957433/1882212

python課程第二周 內建資料結構——列表和元組