如果你覺得我的文章寫的不錯，請關注我喲，請點贊、評論，收藏此文章，謝謝！

本文內容體系結構如下：

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

一、什么是列表（List）

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

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

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

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

二、創(chuàng)建列表

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

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

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

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

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

示例代碼：

# 使用[]直接創(chuàng)建列表
# 創(chuàng)建1個空列表
list01 = []
print(list01) # []
print(type(list01)) # <class 'list'># 創(chuàng)建1個包含1個int類型數(shù)據(jù)的列表
list02  = [10]
print(list02) # [10]
print(type(list02)) # <class 'list'># 創(chuàng)建1個包含2個字符串類型數(shù)據(jù)的列表
list03  = ["Hello","Python"]
print(list03) # ['Hello', 'Python']
print(type(list03)) # <class 'list'># 創(chuàng)建1個包含4個不同類型數(shù)據(jù)的列表
list04 = [100,"Hi",12.5,True]
print(list04) # [100, 'Hi', 12.5, True]
print(type(list04)) # <class 'list'># 創(chuàng)建1個嵌套列表
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 還提供了一個內置的函數(shù) list()，使用它可以將其它數(shù)據(jù)類型轉換為列表類型。例如：

# 使用list()函數(shù)創(chuàng)建列表
# 創(chuàng)建1個空列表
list01 = list()
print(list01) # []
print(type(list01)) # <class 'list'># 將字符串轉換成列表
list02 = list("hello")
print(list02) # ['h', 'e', 'l', 'l', 'o']
print(type(list02)) # <class 'list'># 將元組轉換成列表
tuple01 = ('Python', 'Java', 'C++', 'JavaScript')
list03 = list(tuple01)
print(list03) # ['Python', 'Java', 'C++', 'JavaScript']
print(type(list03)) # <class 'list'># 將字典轉換成列表
dict01 = {'a':100, 'b':42, 'c':9}
list04 = list(dict01)
print(list04) # ['a', 'b', 'c']
print(type(list04)) # <class 'list'># 將區(qū)間轉換成列表
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'>

三、刪除列表

當列表不再使用時，使用del命令刪除整個列表。刪除列表后，再次使用列表會報NameError錯誤。

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

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

四、訪問列表元素

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

4.1 使用索引訪問單個元素

我們可以直接通過元素索引訪問列表中的某個元素，但是注意，索引不要超過列表索引范圍，否則會報錯。

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

4.2 使用切片訪問多個元素

4.2.1 列表切片

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

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]
# 切片操作不會改變列表本身內容
print(list01) # [10, 20, 30, 40, 50, 60, 70, 80, 90]# 省略起始索引
slice_list02 = list01[:5]
print(slice_list02) # [10, 20, 30, 40, 50]
# 切片操作不會改變列表本身內容
print(list01) # [10, 20, 30, 40, 50, 60, 70, 80, 90]# 省略結束索引
slice_list03 = list01[7:]
print(slice_list03) # [80, 90]
# 切片操作不會改變列表本身內容
print(list01) # [10, 20, 30, 40, 50, 60, 70, 80, 90]# 使用負索引
slice_list04 = list01[-6:-1]
print(slice_list04) # [40, 50, 60, 70, 80]
# 切片操作不會改變列表本身內容
print(list01) # [10, 20, 30, 40, 50, 60, 70, 80, 90]# 獲取整個列表（相當于復制）
slice_list05 = list01[:]
print(slice_list05) # [10, 20, 30, 40, 50, 60, 70, 80, 90]

代碼運行結果如下圖所示：

4.2.2 列表的步長切片

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

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

代碼運行結果如下圖所示：

五、遍歷列表元素

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

5.1 while循環(huán)遍歷

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

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

5.2 for循環(huán)遍歷

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

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

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

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

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

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

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

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

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

六、增加列表元素

6.1 使用“+”運算符將元素添加到列表中

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

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]

代碼運行結果如下：

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

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

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

該方法的語法格式如下：

listname.append(obj)

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

list01 = [10,20,30]
# append()操作前列表數(shù)據(jù)
print(list01)  # [10, 20, 30]
print("列表id：",id(list01)) # 列表id：2104113409472# 追加1個元素
list01.append(40)
# append()操作后列表數(shù)據(jù)
print(list01)  # [10, 20, 30, 40]
print("列表id：",id(list01)) # 列表id：2104113409472# 追加列表，整個列表也被當成一個元素
list01.append([50,60])
# append()操作后列表數(shù)據(jù)
print(list01)  # [10, 20, 30, 40, [50, 60]]
print("列表id：",id(list01)) # 列表id：2104113409472# 追加元組，整個元組也被當成一個元素
list01.append((70,80))
# append()操作后列表數(shù)據(jù)
print(list01)  # [10, 20, 30, 40, [50, 60], (70, 80)]
print("列表id：",id(list01)) # 列表id：2104113409472# 追加字典，整個字典也被當成一個元素
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

運行結果如下圖所示：

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

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

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

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

listname.extend(obj)

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

list01 = [10,20,30]
# extend()操作前列表數(shù)據(jù)
print(list01)  # [10, 20, 30]
print("列表id：",id(list01)) # 列表id： 2902869192128# 追加1個字符串，將字符串中的字符依次取出來追加在列表尾部
# 注意：添加一個元素時，不能是單個的數(shù)字，會報錯。如果要添加單個數(shù)字，可以將單個數(shù)字存入列表或者元組中
list01.extend("abc")
# extend()操作后列表數(shù)據(jù)
print(list01)  # [10, 20, 30, 'a', 'b', 'c']
print("列表id：",id(list01)) # 列表id： 2902869192128# 追加1個數(shù)字，將1個數(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

運行結果如下圖所示：

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

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

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

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

insert() 的語法格式如下：

listname.insert(index , obj)

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

list01 = [10,20,30]
# insert()操作前列表數(shù)據(jù)
print(list01)  # [10, 20, 30]
print("列表id：",id(list01)) # 列表id： 1515344997824# 插入1個元素
list01.insert(1,40)
# insert()操作后列表數(shù)據(jù)
print(list01)  # [10, 40, 20, 30]
print("列表id：",id(list01)) # 列表id： 1515344997824# 插入列表，整個列表也被當成一個元素
list01.insert(1,[50,60])
# insert()操作后列表數(shù)據(jù)
print(list01)  # [10, [50, 60], 40, 20, 30]
print("列表id：",id(list01)) # 列表id： 1515344997824# 插入元組，整個元組也被當成一個元素
list01.insert(1,(70,80))
# insert()操作后列表數(shù)據(jù)
print(list01)  # [10, (70, 80), [50, 60], 40, 20, 30]
print("列表id：",id(list01)) # 列表id： 1515344997824# 插入字典，整個字典也被當成一個元素
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# 插入字符串，整個字符串也被當成一個元素
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

運行結果如下圖所示：

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

注意：

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

6.5 使用乘法來擴展列表對象

將1個列表與1個整數(shù)相乘，生成一個新列表，新列表中的元素是原來列表中所有元素重復整數(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

運行結果如下圖所示：

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

七、刪除列表元素

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

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

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

語法格式如下

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

演示代碼如下：

list01 = [10,20,30,40,50,60]
# 刪除前列表元素
print(list01) # [10, 20, 30, 40, 50, 60]# 刪除列表中第二個元素
del list01[1]
# 刪除列表中最后一個元素
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之間,步長為2（隔一個刪除一個）的元素，包括索引為1的元素，不包括索引為8的元素
del list03[1:8:2]
# 刪除后列表元素
print(list03) # [10, 30, 50, 70, 90]

運行結果如下圖所示：

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

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

語法格式如下：

列表名.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]

運行結果如下圖所示：

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

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

語法格式如下：

# 未指定索引，默認刪除列表最后一個元素
變量 = 列表名.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# 默認刪除列表中最后一個元素
result02 = list01.pop()
print("刪除的最后1個元素值為：",result02) # 刪除的最后一個元素值為： 70# 刪除后列表元素
print(list01) # [10, 30, 40, 50, 60]

運行結果如下圖所示：

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

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

語法格式如下：

列表名.clear()

演示代碼如下：

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

運行結果如下圖所示：

八、修改列表元素

8.1 使用索引修改單個元素

直接使用索引號修改指定位置上的元素，注意，索引號不要超出范圍，不然會報錯。

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)

代碼運行結果如下圖所示：

8.2 使用切片修改多個元素

8.2.1 切片修改多個元素

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

下面是新賦值元素與索引表示范圍元素個數(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 個元素的值（不包括第4個元素），列表中值的個數(shù)和索引范圍一致，進行修改操作
list01[1: 4] = [200,300,400]# 修改后列表數(shù)據(jù)
print(list01) # [10, 200, 300, 400, 50, 60, 70, 80, 90]

運行結果如下圖所示：

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

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

list01 = [10,20,30,40,50,60,70,80,90]
# 修改前列表數(shù)據(jù)
print(list01) # [10, 20, 30, 40, 50, 60, 70, 80, 90]
# 如果對空切片（slice）賦值，就相當于插入一組新的元素：
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 個元素的值（不包括第4個元素），修改的值的個數(shù)大于索引范圍，索引指示的元素進行修改，多的元素添加進列表
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 個元素的值（不包括第5個元素），修改的值的個數(shù)小于索引范圍，索引指示的元素進行修改，少的元素從列表中刪除
list03[1: 5] = [200,300]
# 修改后列表數(shù)據(jù)
print(list03) # [10, 200, 300, 60, 70, 80, 90]

運行結果如下圖所示：

使用切片語法賦值時，Python 不支持單個值，運行會報錯

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

運行結果如下圖所示：

8.2.2 步長切片修改多個元素

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

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

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

運行結果如下圖所示：

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

list01 = [10,20,30,40,50,60,70,80,90]
# 修改前列表數(shù)據(jù)
print(list01) # [10, 20, 30, 40, 50, 60, 70, 80, 90]
# 賦值的新元素比原有元素個數(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)

運行結果如下圖所示：

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

list01 = [10,20,30,40,50,60,70,80,90]
# 修改前列表數(shù)據(jù)
print(list01) # [10, 20, 30, 40, 50, 60, 70, 80, 90]
# 賦值的新元素比原有元素個數(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)

運行結果如下圖所示：

九、查找列表元素

9.1 in運算符查詢元素在列表中是否存在

使用in運算符查詢某個元素在列表中是否存在，如果存在返回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

運行結果如下圖所示：

9.2 not in運算符查詢元素在列表中是否不存在

使用not in運算符查詢某個元素在列表中是否不存在，如果不存在返回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

運行結果如下圖所示：

9.3 index() 方法

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

語法格式如下：

listname.index(obj, start, end)

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

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

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

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

演示代碼如下：

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

運行結果如下：

9.4 count()方法

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

語法格式如下：

result = listname.count(obj)

listname ：代表列表名

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

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

演示示例如下：

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在列表中不存在")

運行結果如下圖所示：

十、排序列表元素

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

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

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

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

語法格式如下：

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

• iterable：表示可迭代對象，在這里就是列表名
• key為可選參數(shù)，如果指定了該參數(shù)，會使用該參數(shù)的方法進行排序
• reverse為可選參數(shù)，設置升序還是降序，默認值為False，進行升序排序，設置為True，可以實現(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()方法是臨時排序，默認是升序排序，不影響列表本身排序，產(chǎn)生一個升序排序的新列表
sortedList01 = sorted(list01) # 升序排序操作得到的列表： [10, 20, 30, 30, 40, 50, 60, 70, 80, 90]
print("升序排序操作得到的列表：",sortedList01)
# sorted()方法是臨時排序，默認是升序排序，設置參數(shù)reverse=True產(chǎn)生一個降序排序的新列表
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]

運行結果如下：

10.2 使用sort()方法

用于對原列表進行排序（默認為升序排序），排序后的新列表會覆蓋原列表。

語法格式如下：

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

• list表示列表
• key為可選參數(shù)，如果指定了該參數(shù)，會使用該參數(shù)的方法進行排序
• reverse為可選參數(shù)，表示是否反向排序，默認為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()方法是永久排序，默認是升序排序，直接在原列表上進行排序操作
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()方法是永久排序，默認是升序排序，直接在原列表上進行排序操作，設置參數(shù)reverse=True產(chǎn)生一個降序排序的列表
list02.sort(reverse=True)
print("降序排序操作得到的列表：",list02) # 降序排序操作得到的列表： [90, 80, 70, 60, 50, 40, 30, 30, 20, 10]

運行結果如下圖所示：

10.3 reverse()方法反轉列表

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

語法格式如下：

list.reverse()

• list表示列表

演示示例如下：

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

運行結果如下圖所示：

十一、列表的復制

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

11.1 使用切片操作復制列表

語法格式如下：

列表變量 = 列表名[:]

演示代碼如下：

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

運行結果如下圖所示：

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

語法格式如下：

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

演示代碼如下：

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

運行結果如下圖所示：

十二、列表推導式

12.1 什么是推導式

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

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

推導式是Python中非常強大和常用的特性，可以使代碼更加簡潔和高效。

12.2 列表推導式

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

語法格式：

listname = [expression for variable in 對象（if condition）]

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

演示示例：

# 1：生成[0-10)之間的10個整數(shù)，存儲在列表中
# 普通方式生成
list01 = []
for i in range(10):list01.append(i)
print("普通方式生成的列表：",list01) # 普通方式生成的列表： [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]# 列表推導式生成
list02 = [i for i in range(10)]
print("列表推導式生成的列表：",list02) # 列表推導式生成的列表： [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]# 2：生成一個[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]# 列表推導式生成
list04 = [i**2 for i in range(1,11)]
print("列表推導式生成的列表：",list04) # 列表推導式生成的列表： [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]# 列表推導式生成
list07 = [i for i in list05 if i%2!=0]
print("列表推導式生成的列表：",list07)

運行結果如下圖所示：

十三、總結

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

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

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

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

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

博主辛苦寫了這么詳細的教程，都看到這了，還不關注博主，是不是說不過去呀？？？