如果你覺得我的文章寫的不錯(cuò)，請(qǐng)關(guān)注我喲，請(qǐng)點(diǎn)贊、評(píng)論，收藏此文章，謝謝！

本文內(nèi)容體系結(jié)構(gòu)如下：

Python列表，作為編程中的基礎(chǔ)數(shù)據(jù)結(jié)構(gòu)，扮演著至關(guān)重要的角色。它不僅能夠存儲(chǔ)一系列有序的、可重復(fù)的元素，還支持豐富的操作，如訪問、修改、添加、刪除等。掌握列表的使用，是提升編程效率和代碼可讀性的關(guān)鍵。在接下來的內(nèi)容中，我們將深入探索Python列表的各項(xiàng)功能，幫助你更好地理解和運(yùn)用這一強(qiáng)大的數(shù)據(jù)結(jié)構(gòu)。

一、什么是列表（List）

列表（List）是Python中的一種數(shù)據(jù)結(jié)構(gòu)，用于存儲(chǔ)一系列有序的、可重復(fù)的項(xiàng)目集合。列表中的項(xiàng)目可以是同類型的，也可以是不同類型的數(shù)據(jù)，比如數(shù)字、字符串、甚至是另一個(gè)列表（嵌套列表）。列表是可變的序列，這意味著你可以在創(chuàng)建后修改它的內(nèi)容。

[100,200,300,400] # 存儲(chǔ)4個(gè)int類型數(shù)據(jù)的列表
['Hello','Python','Good'] # 存儲(chǔ)3個(gè)字符串類型數(shù)據(jù)的列表
['hi',9.9,10,[100, 200]] # 存儲(chǔ)4個(gè)不同類型數(shù)據(jù)的列表
[['Hello',100,10], ['Python',200,20,30]] # 嵌套列表

列表看起來有點(diǎn)像其它語言（C語言、Java、JavaScript 等）中的數(shù)組，但要注意與數(shù)組的不同：

• 數(shù)組中的元素?cái)?shù)據(jù)類型必須一樣。
• 需要明確的是，Python 中沒有數(shù)組。（其第三方庫(kù)：NumPy中用到一數(shù)組的概念，但還是與其它語言中的數(shù)組實(shí)質(zhì)上是不同的）
• 在使用列表時(shí)，雖然可以將不同類型的數(shù)據(jù)放入到同一個(gè)列表中，但通常情況下不這么做，同一列表中只放入同一類型的數(shù)據(jù)，這樣可以提高程序的可讀性。

二、創(chuàng)建列表

要?jiǎng)?chuàng)建一個(gè)列表，可以使用方括號(hào) [] 將一系列元素包圍起來，元素之間用英文逗號(hào) , 分隔?；蛘呤褂胠ist()函數(shù)創(chuàng)建列表。

2.1 使用 [] 直接創(chuàng)建列表

使用[ ]創(chuàng)建列表后，一般使用=將它賦值給某個(gè)變量。具體格式如下：

listname = [valu1 , value2 , ... , valuen]

其中，listname 表示列表變量名，value1~ valuen 表示列表元素。

示例代碼：

# 使用[]直接創(chuàng)建列表
# 創(chuàng)建1個(gè)空列表
list01 = []
print(list01) # []
print(type(list01)) # <class 'list'># 創(chuàng)建1個(gè)包含1個(gè)int類型數(shù)據(jù)的列表
list02  = [10]
print(list02) # [10]
print(type(list02)) # <class 'list'># 創(chuàng)建1個(gè)包含2個(gè)字符串類型數(shù)據(jù)的列表
list03  = ["Hello","Python"]
print(list03) # ['Hello', 'Python']
print(type(list03)) # <class 'list'># 創(chuàng)建1個(gè)包含4個(gè)不同類型數(shù)據(jù)的列表
list04 = [100,"Hi",12.5,True]
print(list04) # [100, 'Hi', 12.5, True]
print(type(list04)) # <class 'list'># 創(chuàng)建1個(gè)嵌套列表
list05 = [[10,20,30],["abc","qwe"]]
print(list05) # [[10, 20, 30], ['abc', 'qwe']]
print(type(list05)) # <class 'list'>

2.2 使用 list() 函數(shù)創(chuàng)建列表

Python 還提供了一個(gè)內(nèi)置的函數(shù) list()，使用它可以將其它數(shù)據(jù)類型轉(zhuǎn)換為列表類型。例如：

# 使用list()函數(shù)創(chuàng)建列表
# 創(chuàng)建1個(gè)空列表
list01 = list()
print(list01) # []
print(type(list01)) # <class 'list'># 將字符串轉(zhuǎn)換成列表
list02 = list("hello")
print(list02) # ['h', 'e', 'l', 'l', 'o']
print(type(list02)) # <class 'list'># 將元組轉(zhuǎn)換成列表
tuple01 = ('Python', 'Java', 'C++', 'JavaScript')
list03 = list(tuple01)
print(list03) # ['Python', 'Java', 'C++', 'JavaScript']
print(type(list03)) # <class 'list'># 將字典轉(zhuǎn)換成列表
dict01 = {'a':100, 'b':42, 'c':9}
list04 = list(dict01)
print(list04) # ['a', 'b', 'c']
print(type(list04)) # <class 'list'># 將區(qū)間轉(zhuǎn)換成列表
range01 = range(1, 6) #  range(1, 6)產(chǎn)生數(shù)字1,2,3,4,5
list05 = list(range01)
print(list05) # [1, 2, 3, 4, 5]
print(type(list05)) # <class 'list'>

三、刪除列表

當(dāng)列表不再使用時(shí)，使用del命令刪除整個(gè)列表。刪除列表后，再次使用列表會(huì)報(bào)NameError錯(cuò)誤。

list01 = [10,20]
print(list01) # [10, 20]
# 刪除列表
del list01
print(list01) # NameError: name 'list01' is not defined.

代碼執(zhí)行效果如下：

四、訪問列表元素

列表是 Python 序列的一種，列表中的每個(gè)元素都有一個(gè)索引（Index），也可以稱之為下標(biāo)，索引分正向索引和負(fù)向索引。正向索引從左往右計(jì)數(shù)，第一個(gè)元素索引為0，第二個(gè)元素索引為1,第三個(gè)元素索引為2，以此類推。負(fù)向索引從右往左計(jì)數(shù)，第一個(gè)元素索引為-1，第二個(gè)元素索引為-2，第三個(gè)元素索引為-3，以此類推。你可以使用索引來訪問列表中的特定元素。

4.1 使用索引訪問單個(gè)元素

我們可以直接通過元素索引訪問列表中的某個(gè)元素，但是注意，索引不要超過列表索引范圍，否則會(huì)報(bào)錯(cuò)。

list01 = ["Hello","Python","Good!","Hi","World"]# 訪問第1個(gè)元素
result1 = list01[0]
print(result1) # Hello# 訪問第2個(gè)元素
result2 = list01[1]
print(result2) # Python# 訪問最后一個(gè)元素
result3 = list01[len(list01)-1]
print(result3) # World
result4 = list01[-1]
print(result4) # World

4.2 使用切片訪問多個(gè)元素

4.2.1 列表切片

切片是指從列表中提取一部分子列表。切片通過指定起始索引和結(jié)束索引來實(shí)現(xiàn)，語法為[start:end]，其中start是起始索引（包含），end是結(jié)束索引（不包含）。如果省略start，則表示從列表開頭開始；如果省略end，則表示到列表結(jié)尾為止。

list01 = [10,20,30,40,50,60,70,80,90]
print(list01) # [10, 20, 30, 40, 50, 60, 70, 80, 90]slice_list01 = list01[0:5]
print(slice_list01) # [10, 20, 30, 40, 50]
# 切片操作不會(huì)改變列表本身內(nèi)容
print(list01) # [10, 20, 30, 40, 50, 60, 70, 80, 90]# 省略起始索引
slice_list02 = list01[:5]
print(slice_list02) # [10, 20, 30, 40, 50]
# 切片操作不會(huì)改變列表本身內(nèi)容
print(list01) # [10, 20, 30, 40, 50, 60, 70, 80, 90]# 省略結(jié)束索引
slice_list03 = list01[7:]
print(slice_list03) # [80, 90]
# 切片操作不會(huì)改變列表本身內(nèi)容
print(list01) # [10, 20, 30, 40, 50, 60, 70, 80, 90]# 使用負(fù)索引
slice_list04 = list01[-6:-1]
print(slice_list04) # [40, 50, 60, 70, 80]
# 切片操作不會(huì)改變列表本身內(nèi)容
print(list01) # [10, 20, 30, 40, 50, 60, 70, 80, 90]# 獲取整個(gè)列表（相當(dāng)于復(fù)制）
slice_list05 = list01[:]
print(slice_list05) # [10, 20, 30, 40, 50, 60, 70, 80, 90]

代碼運(yùn)行結(jié)果如下圖所示：

4.2.2 列表的步長(zhǎng)切片

除了基本的切片操作，Python還支持帶步長(zhǎng)的切片，語法為[start:end:step]，其中step表示步長(zhǎng)，可以是正數(shù)或負(fù)數(shù)。

list01 = [10,20,30,40,50,60,70,80,90]
print(list01) # [10, 20, 30, 40, 50, 60, 70, 80, 90]# 正向步長(zhǎng)
slice_list01 = list01[::2]
print(slice_list01) # [10, 30, 50, 70, 90]
# 切片操作不會(huì)改變列表本身內(nèi)容
print(list01) # [10, 20, 30, 40, 50, 60, 70, 80, 90]# 反向步長(zhǎng)
slice_list02 = list01[::-1]  # 反轉(zhuǎn)列表
print(slice_list02) # [90, 80, 70, 60, 50, 40, 30, 20, 10]
# 切片操作不會(huì)改變列表本身內(nèi)容
print(list01) # [10, 20, 30, 40, 50, 60, 70, 80, 90]

代碼運(yùn)行結(jié)果如下圖所示：

五、遍歷列表元素

按照列表元素的索引依次獲取列表中所有的元素，稱之為列表的遍歷。常用的遍歷方式有四種：while循環(huán)遍歷、for循環(huán)遍歷、range()函數(shù)索引遍歷和enumerate()函數(shù)遍歷。

5.1 while循環(huán)遍歷

使用變量index存儲(chǔ)列表索引，使用列表名[索引]輸出元素。索引取值范圍0-len(列表名)，包含索引0，不包含索引len(列表名)

list01 = [10,20,30,40,50,60,70,80,90]# 定義變量存儲(chǔ)列表索引值
index = 0
while index < len(list01):print(list01[index],end=" ") index+=1

5.2 for循環(huán)遍歷

for循環(huán)遍歷列表，for后面的變量存儲(chǔ)列表中的元素值，列表名放到in關(guān)鍵字的后面。

list01 = [10,20,30,40,50,60,70,80,90]for val in list01:print(val,end=" ") 

5.3 range()函數(shù)索引遍歷

用range()函數(shù)進(jìn)行列表的索引遍歷，然后通過索引獲取值，可以按照以下三步走：

1. 通過len(listName)獲取列表的長(zhǎng)度
2. 通過range(len(listName))獲取列表的所有索引，從0到len(listName)-1。
3. 通過for循環(huán)獲取列表中的每個(gè)索引對(duì)應(yīng)的元素。

list01 = [10,20,30,40,50,60,70,80,90]# range()函數(shù)獲取列表索引范圍，index變量存儲(chǔ)索引值，list01[index]獲取數(shù)據(jù)
for index in range(len(list01)):print(list01[index],end=" ") 

5.4 enumerate()函數(shù)遍歷

enumerate()函數(shù)用于將一個(gè)可遍歷的數(shù)據(jù)對(duì)象（如字符串、列表、元組等）變?yōu)橐粋€(gè)索引序列，同時(shí)輸出索引和元素內(nèi)容，一般與for循環(huán)配合使用。

list01 = [10,20,30,40,50,60,70,80,90]# index存儲(chǔ)元素的索引，value存儲(chǔ)索引對(duì)應(yīng)的值
for index,value in enumerate(list01):print(f"索引{index}對(duì)應(yīng)的值：{value}")

六、增加列表元素

6.1 使用“+”運(yùn)算符將元素添加到列表中

列表是序列的一種，可以使用+對(duì)多個(gè)列表進(jìn)行連接，這樣就相當(dāng)于在第一個(gè)列表的末尾添加了另一個(gè)列表。但是嚴(yán)格意義上來說，+操作并不是真正的為列表增加元素，而是創(chuàng)建了一個(gè)包含多個(gè)列表中所有元素的新列表。該操作涉及大量元素的復(fù)制，因此操作效率低，在涉及大量元素添加時(shí)，不建議使用此方式。

list01 = [10,20,30]
list02 = [40,50,60,70,80]
# +操作前列表數(shù)據(jù)
print(list01)  # [10, 20, 30]
print(list02) # [40, 50, 60, 70, 80]list03 = list01 + list02
# +操作之后list03列表數(shù)據(jù)
print(list03) # [10, 20, 30, 40, 50, 60, 70, 80]# +操作后列表數(shù)據(jù)，原來列表元素不變
print(list01) # [10, 20, 30]
print(list02) # [40, 50, 60, 70, 80]

代碼運(yùn)行結(jié)果如下：

6.2 使用列表對(duì)象的append()方法

append() 方法用于在當(dāng)前列表尾部追加元素，原地修改列表，是真正意義上的在列表尾部添加元素，速度較快。
所謂“原地”，是指不改變列表在內(nèi)存中的首地址，可以使用id()函數(shù)查看列表的內(nèi)存地址值。

使用append()方法可以向列表中添加1個(gè)元素，也可以添加1個(gè)列表、1個(gè)元組、1個(gè)字典等數(shù)據(jù)，但是append()方法會(huì)將添加進(jìn)去的列表、元組、字典等當(dāng)做一個(gè)整體添加進(jìn)列表。

該方法的語法格式如下：

listname.append(obj)

• listname ：表示要添加元素的列表
• obj ：表示到添加到列表末尾的數(shù)據(jù)，它可以是單個(gè)元素，也可以是列表、元組等。

list01 = [10,20,30]
# append()操作前列表數(shù)據(jù)
print(list01)  # [10, 20, 30]
print("列表id：",id(list01)) # 列表id：2104113409472# 追加1個(gè)元素
list01.append(40)
# append()操作后列表數(shù)據(jù)
print(list01)  # [10, 20, 30, 40]
print("列表id：",id(list01)) # 列表id：2104113409472# 追加列表，整個(gè)列表也被當(dāng)成一個(gè)元素
list01.append([50,60])
# append()操作后列表數(shù)據(jù)
print(list01)  # [10, 20, 30, 40, [50, 60]]
print("列表id：",id(list01)) # 列表id：2104113409472# 追加元組，整個(gè)元組也被當(dāng)成一個(gè)元素
list01.append((70,80))
# append()操作后列表數(shù)據(jù)
print(list01)  # [10, 20, 30, 40, [50, 60], (70, 80)]
print("列表id：",id(list01)) # 列表id：2104113409472# 追加字典，整個(gè)字典也被當(dāng)成一個(gè)元素
list01.append({"a":100,"b":200})
# append()操作后列表數(shù)據(jù)
print(list01)  # [10, 20, 30, 40, [50, 60], (70, 80), {'a': 100, 'b': 200}]
print("列表id：",id(list01)) # 列表id：2104113409472

運(yùn)行結(jié)果如下圖所示：

可以發(fā)現(xiàn)，列表的內(nèi)存地址值一直沒有變化，說明append()方法追加元素到列表尾部是“原地”操作。

6.3 使用列表對(duì)象的extend()方法

extend()方法的功能和 和 append() 方法一樣，都是在列表的尾部添加元素，也都是原地操作，不改變列表內(nèi)存首地址。不同之處在于append() 方法會(huì)將添加到列表中的列表、元組、字典等元素當(dāng)做一個(gè)整體添加到列表中，而extend() 不會(huì)把列表、元祖或者字典等視為一個(gè)整體，而是把它們包含的元素逐個(gè)添加到列表中。

extend() 方法的語法格式如下：

listname.extend(obj)

• listname：指的是要添加元素的列表；
• obj： 表示到添加到列表末尾的數(shù)據(jù)，它可以是單個(gè)元素，也可以是列表、元組等，但不能是單個(gè)的數(shù)字。

list01 = [10,20,30]
# extend()操作前列表數(shù)據(jù)
print(list01)  # [10, 20, 30]
print("列表id：",id(list01)) # 列表id： 2902869192128# 追加1個(gè)字符串，將字符串中的字符依次取出來追加在列表尾部
# 注意：添加一個(gè)元素時(shí)，不能是單個(gè)的數(shù)字，會(huì)報(bào)錯(cuò)。如果要添加單個(gè)數(shù)字，可以將單個(gè)數(shù)字存入列表或者元組中
list01.extend("abc")
# extend()操作后列表數(shù)據(jù)
print(list01)  # [10, 20, 30, 'a', 'b', 'c']
print("列表id：",id(list01)) # 列表id： 2902869192128# 追加1個(gè)數(shù)字，將1個(gè)數(shù)字放入列表中
list01.extend([40])
# extend()操作后列表數(shù)據(jù)
print(list01)  # [10, 20, 30, 'a', 'b', 'c', 40]
print("列表id：",id(list01)) # 列表id： 2902869192128# 追加列表，將列表中元素依次取出來追加在列表尾部
list01.extend([50,60])
# extend()操作后列表數(shù)據(jù)
print(list01)  # [10, 20, 30, 'a', 'b', 'c', 40, 50, 60]
print("列表id：",id(list01)) # 列表id： 2902869192128# 追加元組，將元組中元素依次取出來追加在列表尾部
list01.extend((70,80))
# extend()操作后列表數(shù)據(jù)
print(list01)  # [10, 20, 30, 'a', 'b', 'c', 40, 50, 60, 70, 80]
print("列表id：",id(list01)) # 列表id： 2902869192128# 追加字典，將字典中的所有鍵依次取出來追加在列表尾部
list01.extend({"k1":100,"k2":200})
# extend()操作后列表數(shù)據(jù)
print(list01)  # [10, 20, 30, 'a', 'b', 'c', 40, 50, 60, 70, 80, 'k1', 'k2']
print("列表id：",id(list01)) # 列表id： 2902869192128

運(yùn)行結(jié)果如下圖所示：

可以發(fā)現(xiàn)，列表的內(nèi)存地址值一直沒有變化，說明extend()方法追加元素到列表尾部是“原地”操作。

6.4 使用列表對(duì)象的insert()方法

append() 和 extend() 方法向列表中增加元素時(shí)，都只能在列表末尾添加元素，如果希望在列表中間某個(gè)位置增加元素，就可以用 insert() 方法來實(shí)現(xiàn)。

需要注意的是，向列表某個(gè)位置增加字符串、列表、元組或者字典時(shí)，insert()方法 也會(huì)將它們視為一個(gè)整體，作為一個(gè)元素增加到列表中某個(gè)位置，這一點(diǎn)和 append() 方法是一樣的。

insert() 的語法格式如下：

listname.insert(index , obj)

• index ：表示指定位置的索引值。
• obj：表示添加到列表第index位置的數(shù)據(jù)，它可以是單個(gè)元素，也可以是列表、元組等。

list01 = [10,20,30]
# insert()操作前列表數(shù)據(jù)
print(list01)  # [10, 20, 30]
print("列表id：",id(list01)) # 列表id： 1515344997824# 插入1個(gè)元素
list01.insert(1,40)
# insert()操作后列表數(shù)據(jù)
print(list01)  # [10, 40, 20, 30]
print("列表id：",id(list01)) # 列表id： 1515344997824# 插入列表，整個(gè)列表也被當(dāng)成一個(gè)元素
list01.insert(1,[50,60])
# insert()操作后列表數(shù)據(jù)
print(list01)  # [10, [50, 60], 40, 20, 30]
print("列表id：",id(list01)) # 列表id： 1515344997824# 插入元組，整個(gè)元組也被當(dāng)成一個(gè)元素
list01.insert(1,(70,80))
# insert()操作后列表數(shù)據(jù)
print(list01)  # [10, (70, 80), [50, 60], 40, 20, 30]
print("列表id：",id(list01)) # 列表id： 1515344997824# 插入字典，整個(gè)字典也被當(dāng)成一個(gè)元素
list01.insert(1,{"a":100,"b":200})
# insert()操作后列表數(shù)據(jù)
print(list01)  # [10, {'a': 100, 'b': 200}, (70, 80), [50, 60], 40, 20, 30]
print("列表id：",id(list01)) # 列表id： 1515344997824# 插入字符串，整個(gè)字符串也被當(dāng)成一個(gè)元素
list01.insert(1,"qwert")
# insert()操作后列表數(shù)據(jù)
print(list01)  # [10, 'qwert', {'a': 100, 'b': 200}, (70, 80), [50, 60], 40, 20, 30]
print("列表id：",id(list01)) # 列表id： 1515344997824

運(yùn)行結(jié)果如下圖所示：

可以發(fā)現(xiàn)，列表的內(nèi)存地址值一直沒有變化，說明insert()方法插入元素到列表指定位置是“原地”操作。

注意：

• 應(yīng)盡量從列表尾部進(jìn)行元素的增加與刪除操作。
• 列表的insert()可以在列表的任意位置插入元素，但由于列表的自動(dòng)內(nèi)存管理功能，insert()方法會(huì)引起插入位置之后所有元素的移動(dòng)，這會(huì)影響處理速度。
• 類似的還有后面介紹的remove()方法以及使用pop()函數(shù)彈出列表非尾部元素和使用del命令刪除列表非尾部元素的情況。

6.5 使用乘法來擴(kuò)展列表對(duì)象

將1個(gè)列表與1個(gè)整數(shù)相乘，生成一個(gè)新列表，新列表中的元素是原來列表中所有元素重復(fù)整數(shù)次后的元素。

list01 = [100, 200, 300]
# 乘法操作前列表元素
print(list01) # [100, 200, 300]
print(id(list01)) # 1932249378240list02 = list01 * 3
print(list02) # [100, 200, 300, 100, 200, 300, 100, 200, 300]
print(id(list02)) # 1932250313856# 乘法操作后列表元素
print(list01) # [100, 200, 300]
print(id(list01)) # 1932249378240

運(yùn)行結(jié)果如下圖所示：

可以看出，原列表的地址值沒有變化，里邊的元素也沒有變化，生成了一個(gè)新列表，說明列表的乘法操作不是原地操作。

七、刪除列表元素

刪除列表元素有三種方式，分別是使用del語句刪除、remove()方法和pop()方法。

7.1 使用del語句刪除指定索引元素

del語句可以刪除指定索引的元素，結(jié)合切片可以刪除多個(gè)元素，還可以刪除整個(gè)列表。注意使用索引時(shí)，索引不要超出列表索引范圍，否則會(huì)發(fā)生IndexError錯(cuò)誤。

語法格式如下

刪除指定索引元素
del listname[index]
結(jié)合切片，刪除中間一段連續(xù)（切片）的元素
del listname[start : end]
結(jié)合步長(zhǎng)切片，刪除中間一段不連續(xù)的元素
del listname[start : end ：step]

演示代碼如下：

list01 = [10,20,30,40,50,60]
# 刪除前列表元素
print(list01) # [10, 20, 30, 40, 50, 60]# 刪除列表中第二個(gè)元素
del list01[1]
# 刪除列表中最后一個(gè)元素
del list01[-1]# 刪除后列表元素
print(list01) # [10, 30, 40, 50]print("----------------------------------------")list02 = [10,20,30,40,50,60,70,80,90]
# 刪除前列表元素
print(list02) # [10, 20, 30, 40, 50, 60, 70, 80, 90]
# 刪除索引2-6之間的元素，包括索引為2的元素，不包括索引為6的元素
del list02[2:6]
# 刪除后列表元素
print(list02) # [10, 20, 30, 40, 50, 60, 70, 80, 90]print("----------------------------------------")list03 = [10,20,30,40,50,60,70,80,90]
# 刪除前列表元素
print(list03) # [10, 20, 30, 40, 50, 60, 70, 80, 90]
# 刪除索引1-8之間,步長(zhǎng)為2（隔一個(gè)刪除一個(gè)）的元素，包括索引為1的元素，不包括索引為8的元素
del list03[1:8:2]
# 刪除后列表元素
print(list03) # [10, 30, 50, 70, 90]

運(yùn)行結(jié)果如下圖所示：

7.2 使用列表對(duì)象的remove()方法

remove()方法根據(jù)元素本身的值來進(jìn)行刪除操作。需要注意的是，remove() 方法只會(huì)刪除第一個(gè)和指定值相同的元素，沒有返回值。而且必須保證該元素是存在的，否則會(huì)引發(fā) ValueError 錯(cuò)誤。

語法格式如下：

列表名.remove(元素值)

演示代碼如下：

list01 = [10,20,30,40,20,50,60,20]
# 刪除前列表元素
print(list01) # [10, 20, 30, 40, 20, 50, 60, 20]
# 刪除值20
list01.remove(20)
print(list01) # [10, 30, 40, 20, 50, 60, 20]
# 再刪除值20
list01.remove(20)
print(list01)  # [10, 30, 40, 50, 60, 20]

運(yùn)行結(jié)果如下圖所示：

7.3 使用列表對(duì)象的pop()方法

pop()方法根據(jù)列表索引來刪除元素，并返回刪除的值，如果沒有指定索引，則默認(rèn)刪除列表中最后一個(gè)元素并將該元素返回。注意使用索引時(shí)，索引不要超出列表索引范圍，否則會(huì)發(fā)生IndexError錯(cuò)誤。

語法格式如下：

# 未指定索引，默認(rèn)刪除列表最后一個(gè)元素
變量 = 列表名.pop()
變量 =  列表名.pop(索引)

演示代碼如下：

list01 = [10,20,30,40,50,60,70]
# 刪除前列表元素
print(list01) # [10, 20, 30, 40, 50, 60, 70]# 刪除索引為1的元素
result01 =list01.pop(1)
print("刪除索引為1的元素值為：",result01) # 刪除的元素值為： 20# 默認(rèn)刪除列表中最后一個(gè)元素
result02 = list01.pop()
print("刪除的最后1個(gè)元素值為：",result02) # 刪除的最后一個(gè)元素值為： 70# 刪除后列表元素
print(list01) # [10, 30, 40, 50, 60]

運(yùn)行結(jié)果如下圖所示：

7.4 使用列表對(duì)象的clear()方法清空列表

列表中的clear()方法用來刪除列表的所有元素，也即清空列表。

語法格式如下：

列表名.clear()

演示代碼如下：

list01 = [10,20,30,40,50,60,70]
# 刪除前列表元素
print(list01) # [10, 20, 30, 40, 50, 60, 70]# 清空列表
list01.clear()# 清空后列表元素
print(list01) # []

運(yùn)行結(jié)果如下圖所示：

八、修改列表元素

8.1 使用索引修改單個(gè)元素

直接使用索引號(hào)修改指定位置上的元素，注意，索引號(hào)不要超出范圍，不然會(huì)報(bào)錯(cuò)。

list01 = [10,20,30,40,50,60,70,80,90]
# 修改前列表數(shù)據(jù)
print(list01) # [10, 20, 30, 40, 50, 60, 70, 80, 90]# 修改索引為2的元素值為300
list01[2] = 300 # [10, 20, 300, 40, 50, 60, 70, 80, 90]# 修改后列表數(shù)據(jù)
print(list01)

代碼運(yùn)行結(jié)果如下圖所示：

8.2 使用切片修改多個(gè)元素

8.2.1 切片修改多個(gè)元素

Python 支持通過切片語法給一組元素賦值。在進(jìn)行這種操作時(shí)，如果不指定步長(zhǎng)（step 參數(shù)），Python 就不要求新賦值的元素個(gè)數(shù)與原來的元素個(gè)數(shù)相同。這意味，該操作既可以為列表添加元素，也可以為列表刪除元素。

下面是新賦值元素與索引表示范圍元素個(gè)數(shù)相同的操作：

list01 = [10,20,30,40,50,60,70,80,90]
# 修改前列表數(shù)據(jù)
print(list01) # [10, 20, 30, 40, 50, 60, 70, 80, 90]#修改第 1~4 個(gè)元素的值（不包括第4個(gè)元素），列表中值的個(gè)數(shù)和索引范圍一致，進(jìn)行修改操作
list01[1: 4] = [200,300,400]# 修改后列表數(shù)據(jù)
print(list01) # [10, 200, 300, 400, 50, 60, 70, 80, 90]

運(yùn)行結(jié)果如下圖所示：

下面是新賦值元素與索引表示范圍元素個(gè)數(shù)不同的操作：

如果對(duì)空切片（slice）賦值，就相當(dāng)于插入一組新的元素；如果修改的元素值個(gè)數(shù)比索引范圍多，多的元素會(huì)插入到列表中；如果修改的元素值個(gè)數(shù)比索引范圍少 ，少的元素從列表中刪除。

list01 = [10,20,30,40,50,60,70,80,90]
# 修改前列表數(shù)據(jù)
print(list01) # [10, 20, 30, 40, 50, 60, 70, 80, 90]
# 如果對(duì)空切片（slice）賦值，就相當(dāng)于插入一組新的元素：
list01[4: 4] = [200,300,400]
# 修改后列表數(shù)據(jù)
print(list01) # [10, 20, 30, 40, 200, 300, 400, 50, 60, 70, 80, 90]print("--------------------------------------------------------")list02 = [10,20,30,40,50,60,70,80,90]
# 修改前列表數(shù)據(jù)
print(list02) # [10, 20, 30, 40, 50, 60, 70, 80, 90]
#修改第 1~4 個(gè)元素的值（不包括第4個(gè)元素），修改的值的個(gè)數(shù)大于索引范圍，索引指示的元素進(jìn)行修改，多的元素添加進(jìn)列表
list02[1: 4] = [200,300,400,500,600,700]
# 修改后列表數(shù)據(jù)
print(list02) # [10, 200, 300, 400, 500, 600, 700, 50, 60, 70, 80, 90]print("--------------------------------------------------------")list03 = [10,20,30,40,50,60,70,80,90]
# 修改前列表數(shù)據(jù)
print(list03) # [10, 20, 30, 40, 50, 60, 70, 80, 90]
#修改第 1~5 個(gè)元素的值（不包括第5個(gè)元素），修改的值的個(gè)數(shù)小于索引范圍，索引指示的元素進(jìn)行修改，少的元素從列表中刪除
list03[1: 5] = [200,300]
# 修改后列表數(shù)據(jù)
print(list03) # [10, 200, 300, 60, 70, 80, 90]

運(yùn)行結(jié)果如下圖所示：

使用切片語法賦值時(shí)，Python 不支持單個(gè)值，運(yùn)行會(huì)報(bào)錯(cuò)

list01 = [10,20,30,40,50,60,70,80,90]
# 修改前列表數(shù)據(jù)
print(list01) # [10, 20, 30, 40, 50, 60, 70, 80, 90]
# 使用切片語法賦值時(shí)，Python 不支持單個(gè)值，例如下面的寫法就是錯(cuò)誤的：
list01[4:4] = 999 # TypeError: must assign iterable to extended slice
# 修改后列表數(shù)據(jù)
print(list01)

運(yùn)行結(jié)果如下圖所示：

8.2.2 步長(zhǎng)切片修改多個(gè)元素

使用切片語法時(shí)也可以指定步長(zhǎng)（step 參數(shù)），但這個(gè)時(shí)候就要求所賦值的新元素的個(gè)數(shù)與原有元素的個(gè)數(shù)相同，不能多也不能少，否則就報(bào)錯(cuò)。

賦值的新元素與原有元素個(gè)數(shù)相同

list01 = [10,20,30,40,50,60,70,80,90]
# 修改前列表數(shù)據(jù)
print(list01) # [10, 20, 30, 40, 50, 60, 70, 80, 90]
# 賦值的新元素與原有元素個(gè)數(shù)相同
list01[1:6:2 ] = [200,300,400]
# 修改后列表數(shù)據(jù)
print(list01) # [10, 200, 30, 300, 50, 400, 70, 80, 90]

運(yùn)行結(jié)果如下圖所示：

賦值的新元素比原有元素個(gè)數(shù)多

list01 = [10,20,30,40,50,60,70,80,90]
# 修改前列表數(shù)據(jù)
print(list01) # [10, 20, 30, 40, 50, 60, 70, 80, 90]
# 賦值的新元素比原有元素個(gè)數(shù)多
list01[1:6:2 ] = [200,300,400,500] # ValueError: attempt to assign sequence of size 4 to extended slice of size 3
# 修改后列表數(shù)據(jù)
print(list01)

運(yùn)行結(jié)果如下圖所示：

賦值的新元素比原有元素個(gè)數(shù)少

list01 = [10,20,30,40,50,60,70,80,90]
# 修改前列表數(shù)據(jù)
print(list01) # [10, 20, 30, 40, 50, 60, 70, 80, 90]
# 賦值的新元素比原有元素個(gè)數(shù)多
list01[1:6:2 ] = [200,300] # ValueError: attempt to assign sequence of size 2 to extended slice of size 3
# 修改后列表數(shù)據(jù)
print(list01)

運(yùn)行結(jié)果如下圖所示：

九、查找列表元素

9.1 in運(yùn)算符查詢?cè)卦诹斜碇惺欠翊嬖?/h4>

使用in運(yùn)算符查詢某個(gè)元素在列表中是否存在，如果存在返回True，如果不在返回False。

語法格式如下：

result = 元素值 in 列表名

演示代碼如下：

list01 = [10,20,30,40,50,60,70]result01 = 10 in list01
print("元素10在列表list01中存在：",result01) # 元素10在列表list01中存在： Trueresult02 = 100 in list01
print("元素100在列表list01中存在：",result02) # 元素100在列表list01中存在： False

運(yùn)行結(jié)果如下圖所示：

9.2 not in運(yùn)算符查詢?cè)卦诹斜碇惺欠癫淮嬖?/h4>

使用not in運(yùn)算符查詢某個(gè)元素在列表中是否不存在，如果不存在返回True，如果存在返回False。

語法格式如下：

result = 元素值 not in 列表名

演示代碼如下：

list01 = [10,20,30,40,50,60,70]result01 = 10 not in list01
print("元素10不在列表list01中存在：",result01) # 元素10不在列表list01中存在： Falseresult02 = 100 not in list01
print("元素100不在列表list01中存在：",result02) # 元素100不在列表list01中存在： True

運(yùn)行結(jié)果如下圖所示：

9.3 index() 方法

index() 方法用來查找某個(gè)元素在列表中出現(xiàn)的位置（也就是索引），如果該元素不存在，則會(huì)導(dǎo)致 ValueError 錯(cuò)誤，所以在查找之前最好in運(yùn)算或使用 count() 方法判斷一下。

語法格式如下：

listname.index(obj, start, end)

其中，listname 表示列表名稱，obj 表示要查找的元素，start 表示起始位置，end 表示結(jié)束位置。

start 和 end 參數(shù)用來指定檢索范圍：

• start 和 end 可以都不寫，此時(shí)會(huì)檢索整個(gè)列表；
• 如果只寫 start 不寫 end，那么表示檢索從 start 到末尾的元素；
• 如果 start 和 end 都寫，那么表示檢索 start 和 end 之間的元素。

index() 方法會(huì)返回元素所在列表中的索引值。

演示代碼如下：

list01 = [10,20,30,40,20,50,60,70]
# 查找元素值20在列表中的索引
index01 = list01.index(20)
print("元素20在列表中第一次出現(xiàn)的索引：",index01) # 元素20在列表中第一次出現(xiàn)的索引： 1index02 = list01.index(20,3,6)
print("元素20在列表索引范圍[3,6）第一次出現(xiàn)的索引：",index02) # 元素20在列表索引范圍[3,6）第一次出現(xiàn)的索引： 4

運(yùn)行結(jié)果如下：

9.4 count()方法

count() 方法用來統(tǒng)計(jì)某個(gè)元素在列表中出現(xiàn)的次數(shù)。

語法格式如下：

result = listname.count(obj)

listname ：代表列表名

obj ：表示要統(tǒng)計(jì)的元素。

如果 count() 返回 0，就表示列表中不存在該元素，所以 count() 也可以用來判斷列表中的某個(gè)元素是否存在。

演示示例如下：

list01 = [10,20,30,40,20,50,60,70,20]
# 查找元素值20在列表中出現(xiàn)的次數(shù)
result01 = list01.count(20)
print("元素20在列表中出現(xiàn)的次數(shù)：",result01) # 元素20在列表中出現(xiàn)的次數(shù)： 3# 查找元素值100在列表中出現(xiàn)的次數(shù)
result02 = list01.count(100)
print("元素100在列表中出現(xiàn)的次數(shù)：",result02) # 元素100在列表中出現(xiàn)的次數(shù)： 0# 使用count()方法判斷元素20在列表中是否存在
if list01.count(20):print("元素20在列表中存在")
else:print("元素20在列表中不存在")# 使用count()方法判斷元素100在列表中是否存在
if list01.count(100):print("元素100在列表中存在")
else:print("元素100在列表中不存在")

運(yùn)行結(jié)果如下圖所示：

十、排序列表元素

列表中提供了方法對(duì)列表元素進(jìn)行排序操作。使用sort()方法可以對(duì)列表進(jìn)行永久排序，也就是改變列表元素原來的排序，或者使用sorted()函數(shù)對(duì)列表進(jìn)行臨時(shí)排序，也就是不會(huì)改變列表元素原來的排序。兩個(gè)方法都可以多列表元素進(jìn)行升序或者降序排序。默認(rèn)都是升序排序，如果要進(jìn)行降序排序，需要借助參數(shù)reverse參數(shù)。

列表中還提供了方法對(duì)列表元素進(jìn)行逆序操作。使用reverse()方法可以實(shí)現(xiàn)。

10.1 使用 sorted() 函數(shù)

該函數(shù)會(huì)返回升序排序的新列表，同時(shí)不影響原本的列表。

語法格式如下：

sorted(iterable[,key=None][,reverse=False])

• iterable：表示可迭代對(duì)象，在這里就是列表名
• key為可選參數(shù)，如果指定了該參數(shù)，會(huì)使用該參數(shù)的方法進(jìn)行排序
• reverse為可選參數(shù)，設(shè)置升序還是降序，默認(rèn)值為False，進(jìn)行升序排序，設(shè)置為True，可以實(shí)現(xiàn)降序排序。

演示示例如下：

list01 = [10,90,50,20,60,30,70,30,80,40]
print("排序前l(fā)ist01列表：",list01) # 排序前l(fā)ist01列表： [10, 90, 50, 20, 60, 30, 70, 30, 80, 40]# sorted()方法是臨時(shí)排序，默認(rèn)是升序排序，不影響列表本身排序，產(chǎn)生一個(gè)升序排序的新列表
sortedList01 = sorted(list01) # 升序排序操作得到的列表： [10, 20, 30, 30, 40, 50, 60, 70, 80, 90]
print("升序排序操作得到的列表：",sortedList01)
# sorted()方法是臨時(shí)排序，默認(rèn)是升序排序，設(shè)置參數(shù)reverse=True產(chǎn)生一個(gè)降序排序的新列表
sortedList02 = sorted(list01,reverse=True)
print("降序排序操作得到的列表：",sortedList02) # 降序排序操作得到的列表： [90, 80, 70, 60, 50, 40, 30, 30, 20, 10]print("排序后list01列表：",list01) # 排序后list01列表： [10, 90, 50, 20, 60, 30, 70, 30, 80, 40]

運(yùn)行結(jié)果如下：

10.2 使用sort()方法

用于對(duì)原列表進(jìn)行排序（默認(rèn)為升序排序），排序后的新列表會(huì)覆蓋原列表。

語法格式如下：

list.sort([key=None][,reverse=False])

• list表示列表
• key為可選參數(shù)，如果指定了該參數(shù)，會(huì)使用該參數(shù)的方法進(jìn)行排序
• reverse為可選參數(shù)，表示是否反向排序，默認(rèn)為False

演示示例如下：

list01 = [10,90,50,20,60,30,70,30,80,40]
print("排序前l(fā)ist01列表：",list01) # 排序前l(fā)ist01列表： [10, 90, 50, 20, 60, 30, 70, 30, 80, 40]
# sort()方法是永久排序，默認(rèn)是升序排序，直接在原列表上進(jìn)行排序操作
list01.sort() #
print("升序排序操作得到的列表：",list01) # 升序排序操作得到的列表： [10, 20, 30, 30, 40, 50, 60, 70, 80, 90]list02 = [10,90,50,20,60,30,70,30,80,40]
print("排序前l(fā)ist02列表：",list02) # 排序前l(fā)ist02列表： [10, 90, 50, 20, 60, 30, 70, 30, 80, 40]
# sort()方法是永久排序，默認(rèn)是升序排序，直接在原列表上進(jìn)行排序操作，設(shè)置參數(shù)reverse=True產(chǎn)生一個(gè)降序排序的列表
list02.sort(reverse=True)
print("降序排序操作得到的列表：",list02) # 降序排序操作得到的列表： [90, 80, 70, 60, 50, 40, 30, 30, 20, 10]

運(yùn)行結(jié)果如下圖所示：

10.3 reverse()方法反轉(zhuǎn)列表

reverse()方法用于將列表中的元素反向存放（原列表改變）。

語法格式如下：

list.reverse()

• list表示列表

演示示例如下：

list01 = [10,90,50,20,60,30]
print("反轉(zhuǎn)前l(fā)ist01列表：",list01) # 反轉(zhuǎn)前l(fā)ist01列表： [10, 90, 50, 20, 60, 30]
list01.reverse()
print("反轉(zhuǎn)后list01列表：",list01) # 反轉(zhuǎn)后list01列表： [30, 60, 20, 50, 90, 10]

運(yùn)行結(jié)果如下圖所示：

十一、列表的復(fù)制

列表的復(fù)制有兩種方式可以實(shí)現(xiàn)，一種是使用切片訪問列表，創(chuàng)建一個(gè)包含整個(gè)列表的切片，也就是在切片中同時(shí)省略起始索引值和結(jié)束索引值（列表名[:]），從而實(shí)現(xiàn)列表的復(fù)制；另外一種方式是使用列表對(duì)象的copy()方法。

11.1 使用切片操作復(fù)制列表

語法格式如下：

列表變量 = 列表名[:]

演示代碼如下：

list01 = [10,20,30,40,50]
print("列表list01：",list01)# 對(duì)列表list0進(jìn)行切片操作，省略起始索引和結(jié)束索引，獲得一個(gè)包含list01列表所有元素的新列表
list02 = list01[:]
print("列表list02：",list02)

運(yùn)行結(jié)果如下圖所示：

11.2 使用copy()方法復(fù)制列表

語法格式如下：

列表變量 = 列表名.copy()

演示代碼如下：

list01 = [10,20,30,40,50]
print("列表list01：",list01)# 使用列表對(duì)象中的copy()方法復(fù)制列表
list02 = list01.copy()
print("列表list02：",list02)

運(yùn)行結(jié)果如下圖所示：

十二、列表推導(dǎo)式

12.1 什么是推導(dǎo)式

Python推導(dǎo)式（comprehension）是一種簡(jiǎn)潔而高效的構(gòu)建容器（如列表、集合、字典）的方法。它允許你用一行代碼來創(chuàng)建容器，并且可以通過循環(huán)和條件語句來生成容器中的元素。

推導(dǎo)式分為列表推導(dǎo)式（list comprehension）、集合推導(dǎo)式（set comprehension）、字典推導(dǎo)式（dictionary comprehension）以及生成器表達(dá)式（generator expression）。

推導(dǎo)式是Python中非常強(qiáng)大和常用的特性，可以使代碼更加簡(jiǎn)潔和高效。

12.2 列表推導(dǎo)式

列表推導(dǎo)式提供了一種創(chuàng)建列表的簡(jiǎn)潔方法，通常是操作某個(gè)序列的每個(gè)元素，并將其結(jié)果作為新列表的元素，或者根據(jù)判定條件創(chuàng)建子序列。列表推導(dǎo)式一般由表達(dá)式及for語句構(gòu)成，其后還可以有零個(gè)到多個(gè)for自居或if子句，返回結(jié)果是表達(dá)式在for語句和if語句的操作下生成的列表。

語法格式：

listname = [expression for variable in 對(duì)象（if condition）]

• listname：新生成的列表名字。
• expression：表達(dá)式。
• variable：變量名。
• （if condition）：用于從對(duì)象中選擇符合要求的列表。

演示示例：

# 1：生成[0-10)之間的10個(gè)整數(shù)，存儲(chǔ)在列表中
# 普通方式生成
list01 = []
for i in range(10):list01.append(i)
print("普通方式生成的列表：",list01) # 普通方式生成的列表： [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]# 列表推導(dǎo)式生成
list02 = [i for i in range(10)]
print("列表推導(dǎo)式生成的列表：",list02) # 列表推導(dǎo)式生成的列表： [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]# 2：生成一個(gè)[1-10]之間所有整數(shù)的平方組成的列表
# 普通方式生成
list03 = []
for i in range(1,11):list03.append(i ** 2)
print("普通方式生成的列表：",list03) # 普通方式生成的列表： [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]# 列表推導(dǎo)式生成
list04 = [i**2 for i in range(1,11)]
print("列表推導(dǎo)式生成的列表：",list04) # 列表推導(dǎo)式生成的列表： [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]# 3:取出已有列表中的奇數(shù)值生成新列表
# 已有列表
list05 = [1,2,3,4,5,6,7,8,9,10]
# 普通方式生成
list06 = []
for i in list05:if i%2!=0:list06.append(i)
print("普通方式生成的列表：",list06) # 普通方式生成的列表： [1, 3, 5, 7, 9]# 列表推導(dǎo)式生成
list07 = [i for i in list05 if i%2!=0]
print("列表推導(dǎo)式生成的列表：",list07)

運(yùn)行結(jié)果如下圖所示：

十三、總結(jié)

Python列表是一種功能強(qiáng)大的數(shù)據(jù)結(jié)構(gòu)，能夠存儲(chǔ)任意類型的有序、可重復(fù)元素。列表的創(chuàng)建簡(jiǎn)潔明了，可以使用方括號(hào) [] 或內(nèi)置的 list() 函數(shù)來初始化。列表支持多種訪問方式，包括使用索引和切片來獲取單個(gè)或多個(gè)元素，這些操作使得數(shù)據(jù)訪問變得靈活且高效。

在列表的操作上，可以方便地添加、刪除和修改元素。無論是追加到列表末尾，還是插入到指定位置，亦或是刪除某個(gè)特定元素，Python都提供了直觀的方法。修改元素時(shí)，只需通過索引直接賦值即可。此外，列表還支持遍歷操作，可以通過循環(huán)和 enumerate() 函數(shù)輕松地訪問每個(gè)元素及其索引。

查找元素時(shí)，Python提供了 in 和 not in 運(yùn)算符來檢查元素是否存在，以及 index() 和 count() 方法來獲取元素的索引和計(jì)數(shù)。列表還可以進(jìn)行排序和反轉(zhuǎn)操作，以滿足不同的數(shù)據(jù)處理需求。

復(fù)制列表時(shí)，可以使用切片操作或內(nèi)置的 copy() 方法來創(chuàng)建一個(gè)新的列表副本。列表推導(dǎo)式則提供了一種簡(jiǎn)潔的方式來生成列表，通過一行代碼即可實(shí)現(xiàn)對(duì)數(shù)據(jù)的處理和轉(zhuǎn)換。

總之，Python列表的靈活性和強(qiáng)大功能使其成為編程中不可或缺的數(shù)據(jù)結(jié)構(gòu)。通過學(xué)習(xí)和實(shí)踐，你將能夠熟練運(yùn)用列表來解決各種問題，提高編程效率和代碼可讀性。掌握列表的使用，將為你進(jìn)一步學(xué)習(xí)Python打下堅(jiān)實(shí)的基礎(chǔ)。

博主辛苦寫了這么詳細(xì)的教程，都看到這了，還不關(guān)注博主，是不是說不過去呀？？？