您好，我是碼農(nóng)飛哥，感謝您閱讀本文，歡迎一鍵三連哦。
本文分十個章節(jié)介紹數(shù)據(jù)類型中的列表（list）和元組（tuple），從使用說到底層實現(xiàn)，包您滿意
干貨滿滿，建議收藏，需要用到時?？纯?。 小伙伴們?nèi)缬袉栴}及需要，歡迎踴躍留言哦~ ~ ~。

一淺: 列表（list）的介紹

列表作為Python序列類型中的一種，其也是用于存儲多個元素的一塊內(nèi)存空間，這些元素按照一定的順序排列。其數(shù)據(jù)結(jié)構(gòu)是：

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

element1~elementn表示列表中的元素，元素的數(shù)據(jù)格式?jīng)]有限制，只要是Python支持的數(shù)據(jù)格式都可以往里面方。同時因為列表支持自動擴容，所以它可變序列，即可以動態(tài)的修改列表，即可以修改，新增，刪除列表元素?？磦€爽圖吧！

在這里插入圖片描述

二淺：列表的操作

首先介紹的是對列表的操作：包括列表的創(chuàng)建，列表的刪除等！其中創(chuàng)建一個列表的方式有兩種：
第一種方式：
通過[]包裹列表中的元素，每個元素之間通過逗號,分割。元素類型不限并且同一列表中的每個元素的類型可以不相同，但是不建議這樣做，因為如果每個元素的數(shù)據(jù)類型都不同的話則非常不方便對列表進(jìn)行遍歷解析。所以建議一個列表只存同一種類型的元素。

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

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

classmates1 = list('碼農(nóng)飛哥')
print(classmates1)

生成的列表是：['碼', '農(nóng)', '飛', '哥']

三淺：向列表中新增元素

向列表中新增元素的方法有四種，分別是：
第一種: 使用+運算符將多個列表連接起來。相當(dāng)于在第一個列表的末尾添加上另一個列表。其語法格式是listname1+listname2

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

輸出結(jié)果是：['碼農(nóng)飛哥', '小偉', '小小偉', 'python', 'java']，可以看出將name_list2中的每個元素都添加到了name_list的末尾。
第二種：使用append()方法添加元素
append()方法用于向列表末尾添加元素，其語法格式是:listname.append(p_object)其中l(wèi)istname表示要添加元素的列表，p_object表示要添加到列表末尾的元素，可以是字符串，數(shù)字，也可以是一個序列。舉個栗子：

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

運行結(jié)果是：

['碼農(nóng)飛哥', '小偉', '小小偉', 'Adam']
['碼農(nóng)飛哥', '小偉', '小小偉', 'Adam', ['test', 'test1']]

可以看出待添加的元素都成功的添加到了原列表的末尾處。并且當(dāng)添加的元素是一個序列時，則會將該序列當(dāng)成一個整體。
第三種：使用extend()方法
extend()方法跟append()方法的用法相同，同樣是向列表末尾添加元素。元素的類型只需要Python支持的數(shù)據(jù)類型即可。不過與append()方法不同的是，當(dāng)添加的元素是序列時，extend()方法不會將列表當(dāng)成一個整體，而是將每個元素添加到列表末尾。還是上面的那個例子：

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

運行結(jié)果是：

['碼農(nóng)飛哥', '小偉', '小小偉', 'A', 'd', 'a', 'm']
['碼農(nóng)飛哥', '小偉', '小小偉', 'A', 'd', 'a', 'm', 'test', 'test1']

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

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

運行結(jié)果是：

['碼農(nóng)飛哥', 'Jack', '小偉', '小小偉']
['碼農(nóng)飛哥', 'Jack', ['test', 'test1'], '小偉', '小小偉']

四淺：修改列表中的元素

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

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

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

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

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

五淺：刪除列表中的元素

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

name_list = ['碼農(nóng)飛哥', '小偉', '小小偉', '超人']
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))

運行結(jié)果是：

原始的name_list=['碼農(nóng)飛哥', '小偉', '小小偉', '超人']
原始的name_list2=['碼農(nóng)飛哥', '小偉', '小小偉', '超人']
使用del刪除元素后name_list=['小小偉', '超人']
使用del刪除元素后name_list2=['小小偉', '超人']
使用del刪除列表后name_list2=['小小偉', '超人']

可以看出用del刪除列表元素時是真實的刪除了內(nèi)存數(shù)據(jù)的，但是用del刪除列表時，則只是刪除了變量，name_list2所指向的內(nèi)存數(shù)據(jù)還是存在的。
第二種：根據(jù)索引值刪除元素的pop()方法
根據(jù)索引值刪除元素的pop()方法的語法結(jié)構(gòu)是：listname.pop(index)，其中，listname表示列表名稱，index表示索引值，如果不寫index參數(shù)，默認(rèn)會刪除列表中最后一個元素，類似于數(shù)據(jù)結(jié)構(gòu)中的出棧操作。舉個例子：

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

運行結(jié)果是：

['碼農(nóng)飛哥', '小偉', '小小偉']
['碼農(nóng)飛哥', '小小偉']

第三種：根據(jù)元素值進(jìn)行刪除的remove()方法
根據(jù)元素值進(jìn)行刪除的remove()方法,其語法結(jié)構(gòu)是:listname.remove(object)，其中l(wèi)istname表示列表的名稱，object表示待刪除的元素名稱。需要注意的是：如果元素在列表中不存在則會報ValueError的錯誤。舉個栗子：

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

運行結(jié)果是：['碼農(nóng)飛哥', '小偉', '超人']。
第四種：刪除列表中的所有元素clear()方法
通過clear()方法可以刪除掉列表中的所有元素，其語法結(jié)構(gòu)是：listname.clear()，其中l(wèi)istname表示列表的名稱。還是舉個栗子吧：

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

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

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

說完了第五淺列表元素的刪除，略感疲憊。接著進(jìn)行第六淺吧！看看列表中元素的查找以及訪問。看完這個之后，列表相關(guān)的內(nèi)容也就告一段落了。

訪問列表中的元素

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

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

運行結(jié)果是：

碼農(nóng)飛哥
['小偉', '小小偉']
['小小偉', 123]

查找某個元素在列表中出現(xiàn)的位置 index()

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

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

運行結(jié)果是：1

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

此處留一個空白，歡迎小伙伴留言告訴我，先看個圖放松下吧?。?/p>

圖片看完之后是不是感覺好多了，那就讓我們接著來學(xué)習(xí)吧。

Python新增元素中各個方法的區(qū)別

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

name_list = ['碼農(nóng)飛哥', '小偉', '小小偉', '超人']
name_list2 = ['牛魔王']
name_list3 = name_list + name_list2
print("原始的name_list的值={0}；內(nèi)存地址={1}".format(name_list, id(name_list)))
print("使用+運算符后name_list3的值={0}；內(nèi)存地址={1}".format(name_list3, id(name_list3)))
print("使用+運算符后name_list的值{0}；內(nèi)存地址={1}".format(name_list, id(name_list)))
name_list4 = name_list.append('牛魔王')
print('使用append方法后name_list4的值={0}；內(nèi)存地址={1}'.format(name_list4, id(name_list4)))
print("使用append方法后name_list的值{0}；內(nèi)存地址={1}".format(name_list, id(name_list)))
name_list5 = name_list.extend('牛魔王')
print('使用extend方法后name_list5的值={0}；內(nèi)存地址={1}'.format(name_list4, id(name_list4)))
print("使用extend方法后name_list的值{0}；內(nèi)存地址={1}".format(name_list, id(name_list)))

運行結(jié)果是：

原始的name_list的值=['碼農(nóng)飛哥', '小偉', '小小偉', '超人']；內(nèi)存地址=2069467533448
使用+運算符后name_list3的值=['碼農(nóng)飛哥', '小偉', '小小偉', '超人', '牛魔王']；內(nèi)存地址=2069467533896
使用+運算符后name_list的值['碼農(nóng)飛哥', '小偉', '小小偉', '超人']；內(nèi)存地址=2069467533448
使用append方法后name_list4的值=None；內(nèi)存地址=2012521616
使用append方法后name_list的值['碼農(nóng)飛哥', '小偉', '小小偉', '超人', '牛魔王']；內(nèi)存地址=2069467533448
使用extend方法后name_list5的值=None；內(nèi)存地址=2012521616
使用extend方法后name_list的值['碼農(nóng)飛哥', '小偉', '小小偉', '超人', '牛魔王', '牛', '魔', '王']；內(nèi)存地址=2069467533448

從運行結(jié)果可以看出如下幾點：

1. 使用+運算符是創(chuàng)建一個新的列表，新列表的地址與原列表的地址不相同，并且原始列表的內(nèi)容不會改變。
2. append方法和extend方法都是修改原始列表的內(nèi)容，并且都沒有返回值，所以兩者都不能使用鏈?zhǔn)奖磉_(dá)式。
3. 當(dāng)待添加的元素是列表時,append方法會將列表當(dāng)成一個整體，而extend不會。

八淺：元組（tuple）的介紹

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

元組的創(chuàng)建方式

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

#創(chuàng)建元組
tuple_name = ('碼農(nóng)飛哥', '小偉', '小小偉', '超人')
print(tuple_name)
#去掉小括號創(chuàng)建元組
tuple2 = '碼農(nóng)飛哥', '小偉', '小小偉', '超人'
print(type(tuple2))

運行結(jié)果是：

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

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

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

運行結(jié)果是：

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

由于元組是不可變序列，所以沒有修改元素相關(guān)的方法，只能對元組中的元素進(jìn)行查看。查看元素的方式也與列表類似，共兩種方式：
第一種：通過索引（index）訪問元組中的元素，其語法結(jié)構(gòu)是tuplename[index]
第二種：通過切片的方式訪問，其語法結(jié)構(gòu)是：tuplename[start:end:step]
相關(guān)參數(shù)的描述在此不再贅述了。依然是舉例說明：

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

運行結(jié)果是：

小偉
('碼農(nóng)飛哥', '小偉')

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

九淺：元組和列表的區(qū)別

說完了前面八淺之后，也有點累了。接著說下元組和列表的區(qū)別吧。為啥Python要另外設(shè)置元組這樣一個數(shù)據(jù)結(jié)構(gòu)呢？元組的功能列表不是都可以滿足么？所以，這一淺主要是介紹元組的優(yōu)點，存在即合理，哈哈哈哈。
區(qū)別：

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

TypeError: 'tuple' object does not support item assignment

2. 存儲同樣數(shù)據(jù)所占空間
   下面展示初始化一個空列表和一個空元組所占的字節(jié)數(shù)

>>> listdemo = []
>>> listdemo.__sizeof__()
40
>>> tupleDemo = ()
>>> tupleDemo.__sizeof__()
24

可以看出元組比列表少占用16個字節(jié)，這是因為列表是動態(tài)的，它需要存儲指針來指向?qū)?yīng)的元素（占用8個字節(jié)），另外，由于列表中的元素可變，所以需要額外存儲已經(jīng)分配的長度大?。ㄕ加?個字節(jié)）。但是對于元組，情況就不同了，元組長度的大小固定，其存儲元素不可變，所以存儲空間也是固定的。總體來說，元組的存儲性能要由于列表，存儲同樣數(shù)據(jù)所占用空間更小。

3. 初始化同樣數(shù)據(jù)所需時間
   大家想一想初始化同樣數(shù)據(jù)的元組和列表，哪個的速度更快呢？是元組還是列表呢？相信大部分人都會選擇元組，那么元組到底快多少呢？下面就用一個例子說明一下：同樣是初始化元素為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 秒，所以，可以得出的結(jié)論是初始化一個相同元素的列表和元組分別所需的時間，元組的初始化速度要比列表快5倍多。

小結(jié)

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

一深：列表和元組的底層實現(xiàn)

九淺已經(jīng)完成了，最后就來一次更深入的交流吧。知其然更要知其所以然。話不多說，下面就直接從源碼層面來看看列表和元組的底層實現(xiàn)。
首先來分析列表（list），它的具體結(jié)構(gòu)如下所示：

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：列表實現(xiàn)的源碼文件是 listobject.h 和 listobject.c。
list 本質(zhì)上是一個長度可變的連續(xù)數(shù)組。其中ob_item是一個指針列表，里面的每個指針都指向列表中的元素，而allocated則用于存儲該列表目前被分配的空間大小。
需要注意的是，allocated和列表的實際空間大小不同，列表實際空間大小是指len(list)返回的結(jié)果，即上面注釋中的ob_size,表示該列表實際存儲了多少個元素，而實際情況是，為了優(yōu)化存儲結(jié)構(gòu)，避免每次增加元素都要重新分配內(nèi)存，列表預(yù)分配的空間allocated往往大于ob_size。他們的關(guān)系是0 <= ob_size <= allocated。
接下來在分析元組，如下所示為Python3.7 tuple元組的具體結(jié)構(gòu):

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）實現(xiàn)的源碼文件是 tupleobject.h 和 tupleobject.c。
tuple和list相似，本質(zhì)也是一個數(shù)組，但是空間大小固定。不同于一般數(shù)組，Python 的 tuple 做了許多優(yōu)化，來提升在程序中的效率。

總結(jié)

本文詳細(xì)介紹了Python內(nèi)置數(shù)據(jù)類型中的列表（list）和元組（tuple）。特別是列表，它的新增元素和刪除元素的方法很多，各種方法之間還有許多不同，需要在使用時特別注意。對于不涉及修改元素操作的場景，優(yōu)先使用元組。因為它的性能更好，所占空間更少。

粉絲專屬福利【關(guān)注碼農(nóng)飛哥】

軟考資料：實用軟考資料

面試題：5G 的Java高頻面試題

學(xué)習(xí)資料：50G的各類學(xué)習(xí)資料

脫單秘籍：回復(fù)【脫單】

并發(fā)編程：回復(fù)【并發(fā)編程】
我是碼農(nóng)飛哥，再次感謝您讀完本文。
全網(wǎng)同名【碼農(nóng)飛哥】。不積跬步，無以至千里，享受分享的快樂
我是碼農(nóng)飛哥，再次感謝您讀完本文。