【Python】（六）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

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

使用+運算子是創建一個新的串列，新串列的地址與原串列的地址不相同，并且原始串列的內容不會改變，
append方法和extend方法都是修改原始串列的內容，并且都沒有回傳值，所以兩者都不能使用鏈式運算式，
當待添加的元素是串列時,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要另外設定元組這樣一個資料結構呢？元組的功能串列不是都可以滿足么？所以，這一淺主要是介紹元組的優點，存在即合理，哈哈哈哈，
區別：

元素是否可以修改？
串列中的元素可以修改，而元組中的元素不能修改，如果強行修改元組中的元素，你會得到如下錯誤：

TypeError: 'tuple' object does not support item assignment

存盤同樣資料所占空間
下面展示初始化一個空串列和一個空元組所占的位元組數

>>> 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），特別是串列，它的新增元素和洗掉元素的方法很多，各種方法之間還有許多不同，需要在使用時特別注意，對于不涉及修改元素操作的場景，優先使用元組，因為它的性能更好，所占空間更少，

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

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/288612.html

標籤：Python

上一篇：python 字典和串列嵌套用法

下一篇：Django-ORM