之前,我們已經探討過字串的相關操作了(Python–字串)。列表和字串相同,他也是一種序列,所謂序列,就是按照一定順序儲存物件的容器,容器中的每個序列都被預設存在一個下標(索引)與之對應。從這個角度講,列表當然和字串在序列的性質方面是有相同之處的。不過他們的不同之處更多,比如在儲存的方式上,儲存物件的類型上等等。 列表也是一種序列
我們發現,列表在建立和訪問上,滿足和字串類似的性質。 1. 列表的建立
和建立字串一樣,分為兩種:直接賦值以及通過 list() 函數
alist = [1, 2, "we", [12.5, "how"]] # >>> 由四個元素構成的列表alist = [] # >>> 空列表alist = list("123") # >>> ["1", "2", "3"]
列表由中括弧 “[ ]” 裡面寫入對象的形式表示,不同的對象之間由 “,” 隔開,當然,如果中括弧內什麼都沒有,就表示建立了一個空列表。我們可以發現,Python中列表的一個顯著特徵是它裡面可以儲存任何類型的對象(整型,浮點型,字串,甚至是列表自己等等),而不像字串,只能儲存字元。
另外,需要注意的是,使用 list() 函數時,傳入的參數一定得是可迭代的,比如傳入整數,浮點數,就一定會報錯。 2. 列表的訪問
兩種方法:通過下標;通過切片
alist = [1, 2, 3, 4, 5]alist[-1] # >>> 5alist[0:2] # >>> [1, 2]alist[0::2] # >>> [1, 3, 5]alist[::-1] # >>> [5, 4, 3, 2, 1]
和字串一樣,索引的設定也是從0開始的,而且同樣存在正索引和負索引。切片也一樣是由三個3個參數構成[begin : end : step],具體的設定和字串中是一模一樣的,在此不贅述(參見:Python–字串) 相關操作
我們已經知道字串是不可變的,也就是說,我們所做的關於對字串的更新操作,其實都是通過建立一個新的字串對象實現的。但是列表則方便的多,他是可變的,你可以隨時添加、刪除、修改列表中的元素。再加上我們上面談到的列表可以儲存任意類型的對象,那麼,其實可以想象,列表為我們提供的這種非常便捷的資料存放區結構,一定會大大簡化程式的編寫。 1. 添加
append() 函數可以實現直接向列表的末尾添加元素,而且文法非常簡單。
alist = []alist.append(1) # >>> alist = [1]alist.append("we") # >>> alist = [1, "we"]
注意,此時就是列表alist本身改變了,而不是建立了另一個列表,這一點和字串有著本質區別。 2. 插入
append() 函數只能在列表的末尾添加元素,而有時,我們需要在一些特定的位置插入元素,這就需要用到 insert() 函數。
alist = ["I", "Python"]alist.insert(1, "wrote") # 在位置1處插入字串對象 "wrote"print(alist) # >>> ["I", "wrote", "Python"]
insert() 函數的結構時這樣的:insert(index, obj). 第一個參數表示要插入的位置,第二個參數表示要插入的元素 3. 刪除
兩種刪除方法:remove(obj) 和 pop(index)
從兩個函數的參數就可以看出使用情境的不同。如果我們已知要刪除對象本身的值,則使用 remove(obj) 直接刪除,而如果知道要刪除對象的位置,則使用 pop(index) 根據索引刪除元素,如果沒有給出要刪除的索引,則預設索引為-1,也就是刪除列表的最後一個元素。
我們具體來看看怎麼用
alist = [1, 2, 1, 3, 4, 5, 6]alist.remove(1) # >>> 刪除第一個為1的元素print(alist) # >>> [2, 1, 3, 4, 5, 6]alist.pop(0) # >>> 刪除index = 0的元素,也就是現在alist裡面的2print(alist) # >>> [1, 3, 4, 5, 6]
需要注意的是,remove(obj) 函數是沒有傳回值的(或者說他的傳回值是 None),比如:
alist = [1, 2, 1, 3, 4, 5, 6]print(alist.remove(1)) # >>> None # >>> 因為只是刪除了alist中第一個值為1的元素,但是函數本身並沒有傳回值
而 pop(index) 函數會返回被刪除的那個值:
alist = [1, 2, 1, 3, 4, 5, 6]print(alist.pop()) # >>> 6 # >>> 返回被刪除的那個元素
4. 修改
通過下標,可以修改列表相應的元素
alist = [1, 2, 3, 4]alist[1] = 3 # >>> [1, 3, 3, 4]alist[-1] = 3 # >>> [1, 3, 3, 9]
當然,也可以通過切片實施批量修改,但是,這種方式要盡量避免使用。
alist = [1, 2, 3, 4]alist[0:2] = [3, 4]print(alist) # >>> [3, 4, 3, 4]
因為稍不注意,就會出錯,比如還是剛才的例子:
alist = [1, 2, 3, 4]b = alist[0:2] # >>> b = [1, 2]; 相當於把alist的一部分複製了,然後用b引用b[1] = 3print(b) # >>> [1, 3]print(alist) # >>> [1, 2, 3, 4] alist並未改變
所以應盡量避免這種批量修改。 5. 拓展
我們也可以將一個列表與另一個列表(也可以是別的序列)合并,合并方式有兩種:
(1) extend() 函數
alist = [1, 2, 3, 4]alist.extend([5, 6, 7, 8])print(alist) # >>> [1, 2, 3, 4, 5, 6, 7, 8]alist.extend("we")print(alist) # >>> [1, 2, 3, 4, 5, 6, 7, 8, "w", "e"]
extend() 函數實際上是給原列表添加了內容,而並沒有建立新的列表。
(2) + 操作符
+ 操作符在列表中的作用和字串中一樣,表示串連。且只能在相同類型的對象間操作,列表的 + 就只能加列表
alist = [1, 2, 3, 4]alist += [5, 6, 7, 8]print(alist) # >>> [1, 2, 3, 4, 5, 6, 7, 8]
需要注意的是,對一個列表使用 + 操作符必須要對這個加之後的結果(實際上是一個新對象)賦值。這一點和整數,浮點數的加法以及字串的連結是一樣的。比如,像下面的操作就是非法的:
alist = [1, 2, 3]alist + [4, 5] # >>> invalid!
6. 操作符
上面的拓展當中,已經介紹了 + 操作符,和字串的設定一樣,列表還有重複操作符 * 和成員操作符 in, not in,使用方式也和字串中一樣,這裡,只是給出例子
alist = [1, 2]alist *= 3print(alist) # >>> [1, 2, 1, 2, 1, 2]print(1 in alist) # >>> Trueprint(2 not in alist) # >>> True
常用函數
上面已經介紹了一些列表的相關內建函數:append(), remove(), pop(), extend(), insert(),下面,我再介紹一些別的。 1. 長度和大小值
alist = [3, 1, 2, 9, 8]# len()函數求取列表長度print(len(alist)) # >>> 5# max(), min()求取列表最大最小值print(max(alist)) # >>> 9print(min(alist)) # >>> 1
求大小值的時候,需要列表所儲存的元素是同一種類型,或者是可比較大小的不同類型(比如整型和浮點)。 2. 翻轉和排序
字串是不可變類型,所以,對字串的翻轉其實是建立了一個對象,而列表可變,所以,我們可以實現對列表本身的翻轉和排序。
(1) 翻轉
alist = [1, 2, 3, 4, 5]alist.reverse() # 翻轉列表,但是這個函數本身沒有傳回值,只是翻轉了列表print(alist) # >>> [5, 4, 3, 2, 1]
當然,我們還可以通過函數 reversed() 產生一個新的經過翻轉的列表,而不改變原列表。
alist = [1, 2, 3, 4, 5]temp = reversed(alist) # >>> 新產生了一個對象,而且這個對象不是list型的,但是可以通過for逐一查看for i in temp: print(i) # >>> 依次輸出: 5, 4, 3, 2, 1print(alist) # >>> [1, 2, 3, 4, 5], 原列表不變
用切片的方式,也能實現列表的翻轉
alist = [1, 2, 3, 4, 5]temp = alist[::-1] # temp是一個新產生的列表print(temp) # >>> [5, 4, 3, 2, 1]print(alist) # >>> [1, 2, 3, 4, 5], 原列表不變
(2) 排序
和求取列表的最大最小值類似,對列表排序時,也得要求列所儲存的元素是同一類型或者可比較的不同類型。
兩個函數可實現排序:sort(), sorted()
alist = [3, 1, 2, 9, 8]alist.sort() # >>> 對alist原地排序(按升序),但是函數本身沒有輸出,只是完成了一個功能,跟reverse()類似print(alist) # >>> [1, 2, 3, 8, 9]
alist = [3, 1, 2, 9, 8]b = sorted(alist) # >>> 建立了一個列表b,b是alist排好序的樣子print(b) # >>> [1, 2, 3, 8, 9]print(alist) # >>> [3, 1, 2, 9, 8] 原列表alist未變
注意:sorted() 函數跟之前的 reversed() 函數不同,sorted() 就是直接產生了一個新的list,不用通過for迴圈,也能直接列印出來。
當然,sort() 函數雖是預設升序排列,但我們也能通過更改相應的參數實現降序排列。
alist = [3, 1, 2, 9, 8]alist.sort(reversed=True) # >>> 設定參數reversed=True實現降序排列print(alist) # >>> [9, 8, 3, 2, 1]
其實,sort() 函數的使用通過設定參數還有很多變型,這個等我們以後講到具體問題時再說吧。 3. 求和和統計
(1) 列表通過 sum() 函數完成求和,當然,要滿足列表所儲存的元素都是整型或浮點
alist = [1, 45, 56, 2.33]print(sum(alist)) # >>> 104.33
(2) 列表通過 count() 函數完成對列表中元素的統計
alist = [1, 2, 1, [1, 2], [1, 2]]print(alist.count(1)) # >>> 2print(alist.count([1, 2])) # >>> 2print(alist.count([2, 1])) # >>> 0
4. 清空和複製
(1) 清空
直接賦值一個空列表是可以的,但是這樣做的原理相當於是讓變數名去引用了一個新的空的列表,並不是真正意義上的清空
alist= [1, 2, 3]alist = [] # >>> 引用了一個新的空的列表print(alist) # >>> []
真正意義上清空列表可以使用 clear() 函數
alist= [1, 2, 3]print(id(alist)) # >>> 4328406280alist.clear()print(alist) # >>> []print(id(alist)) # >>> 4328406280,同一個位置,說明是原地清空
(2) 複製
兩種方法可以實現:切片及 copy() 函數
切片 [:]
alist= [1, 2, 3]b = alist[:]b[0] = 8print(b) # >>> [8, 2, 3]print(alist) # >>> [1, 2, 3] 修改b,alist不受影響
函數 copy()
alist= [1, 2, 3]b = alist.copy()print(id(alist)) # >>> 4362226952print(id(b)) # >>> 4362264520<
和切片的方法一樣,在另一個位置複製了列表 5. enumerate() 和 zip()
關於這兩個函數的使用和字串一樣,具體參見之前的博文吧(Python–字串),這裡,只是給出例子:
a = ["I", "he", "she"]b = ["my", "his", "her"]for i, j in enumerate(a): print(i, j) # >>> 依次輸出 0 "I", 1 "he", 2 "she"for i, j in zip(a, b): print(i, j) # >>> 依次輸出 "I" "my", "he", "his", "she", "her"
需要注意的一點是,如果想把多個多個元素通過一個序列的方式傳遞給 zip() 函數,是需要在這個序列名前面加 * 的,否則不會出現我們想要的結果:
a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]for i in zip(*a): print(i) # >>> 依次輸出 (1, 4, 7), (2, 5, 8), (3, 6, 9)
而如果不加 *,函數會認為只有一個輸入
a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]for i in zip(a): print(i) # >>> 依次輸出 ([1, 2, 3],), ([4, 5, 6],), ([7, 8, 9],)