【Python】（六）Python資料型別-列表和元組,九淺一深，用得到

碼農飛哥發表於2021-06-28
Python資料型別

您好，我是碼農飛哥，感謝您閱讀本文，歡迎一鍵三連哦。
本文分十個章節介紹資料型別中的列表（list）和元組（tuple），從使用說到底層實現，包您滿意
乾貨滿滿，建議收藏，需要用到時常看看。 小夥伴們如有問題及需要，歡迎踴躍留言哦~ ~ ~。

一淺: 列表（list）的介紹

列表作為Python序列型別中的一種，其也是用於儲存多個元素的一塊記憶體空間，這些元素按照一定的順序排列。其資料結構是：

[element1, element2, element3, ..., elementn]

element1~elementn表示列表中的元素，元素的資料格式沒有限制，只要是Python支援的資料格式都可以往裡面方。同時因為列表支援自動擴容，所以它可變序列，即可以動態的修改列表，即可以修改，新增，刪除列表元素。看個爽圖吧！
在這裡插入圖片描述

二淺：列表的操作

首先介紹的是對列表的操作：包括列表的建立，列表的刪除等！其中建立一個列表的方式有兩種：
第一種方式：
通過[]包裹列表中的元素，每個元素之間通過逗號,分割。元素型別不限並且同一列表中的每個元素的型別可以不相同，但是不建議這樣做，因為如果每個元素的資料型別都不同的話則非常不方便對列表進行遍歷解析。所以建議一個列表只存同一種型別的元素。

   list=[element1, element2, element3, ..., elementn]

例如：test_list = ['測試', 2, ['碼農飛哥', '小偉'], (12, 23)]
PS: 空列表的定義是list=[]
第二種方式：
通過list(iterable)函式來建立列表，list函式是Python內建的函式。該函式傳入的引數必須是可迭代的序列，比如字串，列表，元組等等，如果iterable傳入為空，則會建立一個空的列表。iterable不能只傳一個數字。

classmates1 = list('碼農飛哥')
print(classmates1)

生成的列表是：['碼', '農', '飛', '哥']

三淺：向列表中新增元素

向列表中新增元素的方法有四種，分別是：
第一種: 使用+運算子將多個列表連線起來。相當於在第一個列表的末尾新增上另一個列表。其語法格式是listname1+listname2

name_list = ['碼農飛哥', '小偉', '小小偉']
name_list2 = ['python', 'java']
print(name_list + name_list2)

輸出結果是：['碼農飛哥', '小偉', '小小偉', 'python', 'java']，可以看出將name_list2中的每個元素都新增到了name_list的末尾。
第二種：使用append()方法新增元素
append()方法用於向列表末尾新增元素，其語法格式是:listname.append(p_object)其中listname表示要新增元素的列表，p_object表示要新增到列表末尾的元素，可以是字串，數字，也可以是一個序列。舉個例子：

name_list.append('Adam')
print(name_list)
name_list.append(['test', 'test1'])
print(name_list)

執行結果是：

['碼農飛哥', '小偉', '小小偉', 'Adam']
['碼農飛哥', '小偉', '小小偉', 'Adam', ['test', 'test1']]

可以看出待新增的元素都成功的新增到了原列表的末尾處。並且當新增的元素是一個序列時，則會將該序列當成一個整體。
第三種：使用extend()方法
extend()方法跟append()方法的用法相同，同樣是向列表末尾新增元素。元素的型別只需要Python支援的資料型別即可。不過與append()方法不同的是，當新增的元素是序列時，extend()方法不會將列表當成一個整體，而是將每個元素新增到列表末尾。還是上面的那個例子：

name_list = ['碼農飛哥', '小偉', '小小偉']
name_list.extend('Adam')
print(name_list)
name_list.extend(['test', 'test1'])
print(name_list)

執行結果是：

['碼農飛哥', '小偉', '小小偉', 'A', 'd', 'a', 'm']
['碼農飛哥', '小偉', '小小偉', 'A', 'd', 'a', 'm', 'test', 'test1']

從結果看出，當新增字串時會將字串中的每個字元作為一個元素新增到列表的末尾處，當新增的列表時會將列表中的每個元素新增到末尾處。
第四種：使用insert()方法
前面介紹的幾種插入方法，都只能向列表的末尾處插入元素，如果想在列表指定位置插入元素則無能為力。insert()方法正式用於處理這種問題而來的。其語法結構是listname.insert(index, p_object) 其中index表示指定位置的索引值，insert()會將p_object插入到listname列表第index個元素的位置。與append()方法相同的是，如果待新增的元素的是序列，則insert()會將該序列當成一個整體插入到列表的指定位置處。舉個例子：

name_list = ['碼農飛哥', '小偉', '小小偉']
name_list.insert(1, 'Jack')
print(name_list)
name_list.insert(2, ['test', 'test1'])
print(name_list)

執行結果是：

['碼農飛哥', 'Jack', '小偉', '小小偉']
['碼農飛哥', 'Jack', ['test', 'test1'], '小偉', '小小偉']

四淺：修改列表中的元素

說完了列表中元素新增的方法，接著讓我們來看看修改列表中的元素相關的方法。修改列表元素的方法有兩種：
第一種：修改單個元素：
修改單個元素的方法就是對某個索引上的元素進行重新賦值。其語法結構是：listname[index]=newValue，就是將列表listname中索引值為index位置上的元素替換成newValue。
舉個例子：

name_list = ['碼農飛哥', '小偉', '小小偉']
name_list[1] = 'Sarah'
print(name_list)

執行結果：['碼農飛哥', 'Sarah', '小小偉'] 從結果可以看出索引為1處的元素值被成功修改成了Sarch。
第二種：通過切片語法修改一組元素
通過切片語法可以修改一組元素，其語法結構是:listname[start:end:step]，其中，listname表示列表名稱，start表示起始位置，end表示結束位置（不包括），step表示步長，如果不指定步長，Python就不要求新賦值的元素個數與原來的元素個數相同，這意味著，該操作可以為列表新增元素，也可以為列表刪除元素。舉個例子：

name_list = ['碼農飛哥', '小偉', '小小偉']
name_list[0:1] = ['飛哥', '牛逼']
print(name_list)

執行結果是：['飛哥', '牛逼', '小偉', '小小偉'] ，從結果可以看出將原列表中索引為0處的元素值已經被替換為飛哥,並且插入了牛逼 這個元素。

五淺：刪除列表中的元素

刪除列表中元素的方法共有四種。
第一種：根據索引值刪除元素的del關鍵字
根據索引值刪除元素的del關鍵字有兩種形式，一種是刪除單個元素，del listname[index]，一種是根據切片刪除多個元素del listname[start : end]，其中，listname表示列表名稱，start表示起始索引，end表示結束索引，del會刪除從索引start到end之間的元素，但是不包括end位置的元素。還是舉個例子：

name_list = ['碼農飛哥', '小偉', '小小偉', '超人']
name_list2 = name_list
print('原始的name_list={0}'.format(name_list))
print('原始的name_list2={0}'.format(name_list2))
# 刪除索引0到2之間的元素，即刪除索引0和索引1兩個位置的元素
del name_list[0:2]
print('使用del刪除元素後name_list={0}'.format(name_list))
print('使用del刪除元素後name_list2={0}'.format(name_list2))
del name_list
print('使用del刪除列表後name_list2={0}'.format(name_list2))

執行結果是：

原始的name_list=['碼農飛哥', '小偉', '小小偉', '超人']
原始的name_list2=['碼農飛哥', '小偉', '小小偉', '超人']
使用del刪除元素後name_list=['小小偉', '超人']
使用del刪除元素後name_list2=['小小偉', '超人']
使用del刪除列表後name_list2=['小小偉', '超人']

可以看出用del刪除列表元素時是真實的刪除了記憶體資料的，但是用del刪除列表時，則只是刪除了變數，name_list2所指向的記憶體資料還是存在的。
第二種：根據索引值刪除元素的pop()方法
根據索引值刪除元素的pop()方法的語法結構是：listname.pop(index)，其中，listname表示列表名稱，index表示索引值，如果不寫index引數，預設會刪除列表中最後一個元素，類似於資料結構中的出棧操作。舉個例子：

name_list = ['碼農飛哥', '小偉', '小小偉', '超人']
# 刪除list末尾的元素
name_list.pop()
print(name_list)
# 刪除指定位置的元素，用pop(i)方法，其中i是索引位置
name_list.pop(1)
print(name_list)

執行結果是：

['碼農飛哥', '小偉', '小小偉']
['碼農飛哥', '小小偉']

第三種：根據元素值進行刪除的remove()方法
根據元素值進行刪除的remove()方法,其語法結構是:listname.remove(object)，其中listname表示列表的名稱，object表示待刪除的元素名稱。需要注意的是：如果元素在列表中不存在則會報ValueError的錯誤。舉個例子：

name_list = ['碼農飛哥', '小偉', '小小偉', '超人']
name_list.remove('小小偉')
print(name_list)

執行結果是：['碼農飛哥', '小偉', '超人']。
第四種：刪除列表中的所有元素clear()方法
通過clear()方法可以刪除掉列表中的所有元素，其語法結構是：listname.clear()，其中listname表示列表的名稱。還是舉個例子吧：

name_list = ['碼農飛哥', '小偉', '小小偉', '超人']
name_list.clear()
print(name_list)

執行結果是：[]，可以看出列表中元素被全部清空了。

六淺：列表中元素的查詢以及訪問

說完了第五淺列表元素的刪除，略感疲憊。接著進行第六淺吧！看看列表中元素的查詢以及訪問。看完這個之後，列表相關的內容也就告一段落了。

訪問列表中的元素

訪問列表中的元素有兩種方式，分別是通過索引定位訪問單個元素，通過切片訪問多個元素。
第一種：通過索引定位訪問單個元素，其語法結構是：listname[index] ,其中listname表示列表的名字，index表示要查詢元素的索引值。
第二種：通過切片的方式訪問多個元素，其語法結構是：listname[start:end:step]。其中，listname表示列表的名字，start表示開始索引，end表示結束索引（不包括end位置），step表示步長。同樣是舉個例子：

list = ['碼農飛哥', '小偉', '小小偉',123]
print(list[0])  # 輸出列表的第一個元素
print(list[1:3])  # 輸出第二個至第三個元素
print(list[2:])  # 輸出從第三個開始至列表末尾的所有元素

執行結果是：

碼農飛哥
['小偉', '小小偉']
['小小偉', 123]

查詢某個元素在列表中出現的位置 index()

indext()方法用來查詢某個元素在列表中出現的位置（也就是索引），如果該元素在列表中不存在，則會報ValueError錯誤。其語法結構是：listname.index(object, start, end) 其中listname表示列表的名字，object表示要查詢的元素，start表示起始索引，end表示結束索引（不包括）。

name_list = ['碼農飛哥', '小偉', '小小偉', '超人']
print(name_list.index('小偉', 0, 2))

執行結果是：1

七淺：列表使用技巧及注意事項

此處留一個空白，歡迎小夥伴留言告訴我，先看個圖放鬆下吧！！
在這裡插入圖片描述
圖片看完之後是不是感覺好多了，那就讓我們接著來學習吧。

Python新增元素中各個方法的區別

前面介紹了使用+運算子，使用append方法，使用extend方法都可以新增元素，那麼他們到底有啥區別呢？還是舉例說明吧;

name_list = ['碼農飛哥', '小偉', '小小偉', '超人']
name_list2 = ['牛魔王']
name_list3 = name_list + name_list2
print("原始的name_list的值={0}；記憶體地址={1}".format(name_list, id(name_list)))
print("使用+運算子後name_list3的值={0}；記憶體地址={1}".format(name_list3, id(name_list3)))
print("使用+運算子後name_list的值{0}；記憶體地址={1}".format(name_list, id(name_list)))
name_list4 = name_list.append('牛魔王')
print('使用append方法後name_list4的值={0}；記憶體地址={1}'.format(name_list4, id(name_list4)))
print("使用append方法後name_list的值{0}；記憶體地址={1}".format(name_list, id(name_list)))
name_list5 = name_list.extend('牛魔王')
print('使用extend方法後name_list5的值={0}；記憶體地址={1}'.format(name_list4, id(name_list4)))
print("使用extend方法後name_list的值{0}；記憶體地址={1}".format(name_list, id(name_list)))

執行結果是：

原始的name_list的值=['碼農飛哥', '小偉', '小小偉', '超人']；記憶體地址=2069467533448
使用+運算子後name_list3的值=['碼農飛哥', '小偉', '小小偉', '超人', '牛魔王']；記憶體地址=2069467533896
使用+運算子後name_list的值['碼農飛哥', '小偉', '小小偉', '超人']；記憶體地址=2069467533448
使用append方法後name_list4的值=None；記憶體地址=2012521616
使用append方法後name_list的值['碼農飛哥', '小偉', '小小偉', '超人', '牛魔王']；記憶體地址=2069467533448
使用extend方法後name_list5的值=None；記憶體地址=2012521616
使用extend方法後name_list的值['碼農飛哥', '小偉', '小小偉', '超人', '牛魔王', '牛', '魔', '王']；記憶體地址=2069467533448

從執行結果可以看出如下幾點：

  1. 使用+運算子是建立一個新的列表，新列表的地址與原列表的地址不相同，並且原始列表的內容不會改變。
  2. append方法和extend方法都是修改原始列表的內容，並且都沒有返回值，所以兩者都不能使用鏈式表示式。
  3. 當待新增的元素是列表時,append方法會將列表當成一個整體，而extend不會。

八淺：元組（tuple）的介紹

說完了列表，接著讓我們來看看另外一個重要的序列--元組（tuple），和列表類似，元組也是由一系列按特定書序排序的元素組成，與列表最重要的區別是，元組屬於不可變序列，即元組一旦被建立，它的元素就不可更改了。

元組的建立方式

第一種：使用()直接建立
使用()建立元組的語法結構是tuplename=(element1,element2,....,elementn),其中tuplename表示元組的變數名，element1~elementn表示元組中的元素。小括號不是必須的，只要將元素用逗號分隔，Python就會將其視為元組。還是舉個例子：

#建立元組
tuple_name = ('碼農飛哥', '小偉', '小小偉', '超人')
print(tuple_name)
#去掉小括號建立元組
tuple2 = '碼農飛哥', '小偉', '小小偉', '超人'
print(type(tuple2))

執行結果是：

('碼農飛哥', '小偉', '小小偉', '超人')
<class 'tuple'>

第二種：使用tuple()函式建立
與列表類似的，我們可以通過tuple(iterable)函式來建立元組，如果iterable傳入為空，則建立一個空的元組，iterable 引數必須是可迭代的序列，比如字串，列表，元組等。同樣的iterable不能傳入一個數字。舉個例子：

name_list = ['碼農飛哥', '小偉', '小小偉', '超人']
print(tuple(name_list))
print(tuple('碼農飛哥'))

執行結果是：

('碼農飛哥', '小偉', '小小偉', '超人')
('碼', '農', '飛', '哥')

由於元組是不可變序列，所以沒有修改元素相關的方法，只能對元組中的元素進行檢視。檢視元素的方式也與列表類似，共兩種方式：
第一種：通過索引（index）訪問元組中的元素，其語法結構是tuplename[index]
第二種：通過切片的方式訪問，其語法結構是：tuplename[start:end:step]
相關引數的描述在此不再贅述了。依然是舉例說明：

tuple_name = ('碼農飛哥', '小偉', '小小偉', '超人')
# 獲取索引為1的元素值
print(tuple_name[1])
#獲取索引為1到索引為2之間的元素值，不包括索引2本身
print(tuple_name[0:2])

執行結果是：

小偉
('碼農飛哥', '小偉')

元組中的元素不能修改，不過可以通過 + 來生成一個新的元組。

九淺：元組和列表的區別

說完了前面八淺之後，也有點累了。接著說下元組和列表的區別吧。為啥Python要另外設定元組這樣一個資料結構呢？元組的功能列表不是都可以滿足麼？所以，這一淺主要是介紹元組的優點，存在即合理，哈哈哈哈。
區別：

  1. 元素是否可以修改？
    列表中的元素可以修改，而元組中的元素不能修改。如果強行修改元組中的元素，你會得到如下錯誤：
TypeError: 'tuple' object does not support item assignment
  1. 儲存同樣資料所佔空間
    下面展示初始化一個空列表和一個空元組所佔的位元組數
>>> listdemo = []
>>> listdemo.__sizeof__()
40
>>> tupleDemo = ()
>>> tupleDemo.__sizeof__()
24

可以看出元組比列表少佔用16個位元組，這是因為列表是動態的，它需要儲存指標來指向對應的元素（佔用8個位元組），另外，由於列表中的元素可變，所以需要額外儲存已經分配的長度大小（佔用8個位元組）。但是對於元組，情況就不同了，元組長度的大小固定，其儲存元素不可變，所以儲存空間也是固定的。總體來說，元組的儲存效能要由於列表，儲存同樣資料所佔用空間更小。
3. 初始化同樣資料所需時間
大家想一想初始化同樣資料的元組和列表，哪個的速度更快呢？是元組還是列表呢？相信大部分人都會選擇元組，那麼元組到底快多少呢？下面就用一個例子說明一下：同樣是初始化元素為1,2,3,4兩個序列。

(python-demo)  root$ python3 -m timeit 'x=(1,2,3,4)'
10000000 loops, best of 3: 0.029 usec per loop
(python-demo)  root$ python3 -m timeit 'x=[1,2,3,4]'
10000000 loops, best of 3: 0.165 usec per loop

初始化元組花了0.029秒，初始化話列表花了0.165 秒，所以，可以得出的結論是初始化一個相同元素的列表和元組分別所需的時間，元組的初始化速度要比列表快5倍多。

小結

元組有如下優點：元組比列表的訪問和處理速度更快，儲存相同內容所需空間更小。

一深：列表和元組的底層實現

九淺已經完成了，最後就來一次更深入的交流吧。知其然更要知其所以然。話不多說，下面就直接從原始碼層面來看看列表和元組的底層實現。
首先來分析列表（list），它的具體結構如下所示：

typedef struct {
    PyObject_VAR_HEAD
    /* Vector of pointers to list elements.  list[0] is ob_item[0], etc. */
    PyObject **ob_item;

    /* ob_item contains space for 'allocated' elements.  The number
     * currently in use is ob_size.
     * Invariants:
     *     0 <= ob_size <= allocated
     *     len(list) == ob_size
     *     ob_item == NULL implies ob_size == allocated == 0
     * list.sort() temporarily sets allocated to -1 to detect mutations.
     *
     * Items must normally not be NULL, except during construction when
     * the list is not yet visible outside the function that builds it.
     */
    Py_ssize_t allocated;
} PyListObject;

PS：列表實現的原始碼檔案是 listobject.h 和 listobject.c。
list 本質上是一個長度可變的連續陣列。其中ob_item是一個指標列表，裡面的每個指標都指向列表中的元素，而allocated則用於儲存該列表目前被分配的空間大小。
需要注意的是，allocated和列表的實際空間大小不同，列表實際空間大小是指len(list)返回的結果，即上面註釋中的ob_size,表示該列表實際儲存了多少個元素，而實際情況是，為了優化儲存結構，避免每次增加元素都要重新分配記憶體，列表預分配的空間allocated往往大於ob_size。他們的關係是0 <= ob_size <= allocated。
接下來在分析元組，如下所示為Python3.7 tuple元組的具體結構:

typedef struct {
    PyObject_VAR_HEAD
    PyObject *ob_item[1];

    /* ob_item contains space for 'ob_size' elements.
     * Items must normally not be NULL, except during construction when
     * the tuple is not yet visible outside the function that builds it.
     */
} PyTupleObject;

PS: 元組（tuple）實現的原始碼檔案是 tupleobject.h 和 tupleobject.c。
tuple和list相似，本質也是一個陣列，但是空間大小固定。不同於一般陣列，Python 的 tuple 做了許多優化，來提升在程式中的效率。
在這裡插入圖片描述

總結

本文詳細介紹了Python內建資料型別中的列表（list）和元組（tuple）。特別是列表，它的新增元素和刪除元素的方法很多，各種方法之間還有許多不同，需要在使用時特別注意。對於不涉及修改元素操作的場景，優先使用元組。因為它的效能更好，所佔空間更少。

全網同名【碼農飛哥】。不積跬步，無以至千里，享受分享的快樂
我是碼農飛哥，再次感謝您讀完本文。

相關文章