如果你觉得我的文章写的不错，请关注我哟，请点赞、评论，收藏此文章，谢谢！

本文内容体系结构如下：

Python列表，作为编程中的基础数据结构，扮演着至关重要的角色。它不仅能够存储一系列有序的、可重复的元素，还支持丰富的操作，如访问、修改、添加、删除等。掌握列表的使用，是提升编程效率和代码可读性的关键。在接下来的内容中，我们将深入探索Python列表的各项功能，帮助你更好地理解和运用这一强大的数据结构。

一、什么是列表（List）

列表（List）是Python中的一种数据结构，用于存储一系列有序的、可重复的项目集合。列表中的项目可以是同类型的，也可以是不同类型的数据，比如数字、字符串、甚至是另一个列表（嵌套列表）。列表是可变的序列，这意味着你可以在创建后修改它的内容。

[100,200,300,400] # 存储4个int类型数据的列表
['Hello','Python','Good'] # 存储3个字符串类型数据的列表
['hi',9.9,10,[100, 200]] # 存储4个不同类型数据的列表
[['Hello',100,10], ['Python',200,20,30]] # 嵌套列表

列表看起来有点像其它语言（C语言、Java、JavaScript 等）中的数组，但要注意与数组的不同：

• 数组中的元素数据类型必须一样。
• 需要明确的是，Python 中没有数组。（其第三方库：NumPy中用到一数组的概念，但还是与其它语言中的数组实质上是不同的）
• 在使用列表时，虽然可以将不同类型的数据放入到同一个列表中，但通常情况下不这么做，同一列表中只放入同一类型的数据，这样可以提高程序的可读性。

二、创建列表

要创建一个列表，可以使用方括号 [] 将一系列元素包围起来，元素之间用英文逗号 , 分隔。或者使用list()函数创建列表。

2.1 使用 [] 直接创建列表

使用[ ]创建列表后，一般使用=将它赋值给某个变量。具体格式如下：

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

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

示例代码：

# 使用[]直接创建列表
# 创建1个空列表
list01 = []
print(list01) # []
print(type(list01)) # <class 'list'>

# 创建1个包含1个int类型数据的列表
list02  = [10]
print(list02) # [10]
print(type(list02)) # <class 'list'>

# 创建1个包含2个字符串类型数据的列表
list03  = ["Hello","Python"]
print(list03) # ['Hello', 'Python']
print(type(list03)) # <class 'list'>

# 创建1个包含4个不同类型数据的列表
list04 = [100,"Hi",12.5,True]
print(list04) # [100, 'Hi', 12.5, True]
print(type(list04)) # <class 'list'>

# 创建1个嵌套列表
list05 = [[10,20,30],["abc","qwe"]]
print(list05) # [[10, 20, 30], ['abc', 'qwe']]
print(type(list05)) # <class 'list'>

2.2 使用 list() 函数创建列表

Python 还提供了一个内置的函数 list()，使用它可以将其它数据类型转换为列表类型。例如：

# 使用list()函数创建列表
# 创建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'>

# 将区间转换成列表
range01 = range(1, 6) #  range(1, 6)产生数字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.

代码执行效果如下：

四、访问列表元素

列表是 Python 序列的一种，列表中的每个元素都有一个索引（Index），也可以称之为下标，索引分正向索引和负向索引。正向索引从左往右计数，第一个元素索引为0，第二个元素索引为1,第三个元素索引为2，以此类推。负向索引从右往左计数，第一个元素索引为-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 列表切片

切片是指从列表中提取一部分子列表。切片通过指定起始索引和结束索引来实现，语法为[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表示步长，可以是正数或负数。

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循环遍历、for循环遍历、range()函数索引遍历和enumerate()函数遍历。

5.1 while循环遍历

使用变量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循环遍历

for循环遍历列表，for后面的变量存储列表中的元素值，列表名放到in关键字的后面。

list01 = [10,20,30,40,50,60,70,80,90]

for val in list01:
    print(val,end=" ") 

5.3 range()函数索引遍历

用range()函数进行列表的索引遍历，然后通过索引获取值，可以按照以下三步走：

1. 通过len(listName)获取列表的长度
2. 通过range(len(listName))获取列表的所有索引，从0到len(listName)-1。
3. 通过for循环获取列表中的每个索引对应的元素。

list01 = [10,20,30,40,50,60,70,80,90]

# range()函数获取列表索引范围，index变量存储索引值，list01[index]获取数据
for index in range(len(list01)):
    print(list01[index],end=" ") 

5.4 enumerate()函数遍历

enumerate()函数用于将一个可遍历的数据对象（如字符串、列表、元组等）变为一个索引序列，同时输出索引和元素内容，一般与for循环配合使用。

list01 = [10,20,30,40,50,60,70,80,90]

# index存储元素的索引，value存储索引对应的值
for index,value in enumerate(list01):
    print(f"索引{index}对应的值：{value}")

六、增加列表元素

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

列表是序列的一种，可以使用+对多个列表进行连接，这样就相当于在第一个列表的末尾添加了另一个列表。但是严格意义上来说，+操作并不是真正的为列表增加元素，而是创建了一个包含多个列表中所有元素的新列表。该操作涉及大量元素的复制，因此操作效率低，在涉及大量元素添加时，不建议使用此方式。

list01 = [10,20,30]
list02 = [40,50,60,70,80]
# +操作前列表数据
print(list01)  # [10, 20, 30]
print(list02) # [40, 50, 60, 70, 80]

list03 = list01 + list02
# +操作之后list03列表数据
print(list03) # [10, 20, 30, 40, 50, 60, 70, 80]

# +操作后列表数据，原来列表元素不变
print(list01) # [10, 20, 30]
print(list02) # [40, 50, 60, 70, 80]

代码运行结果如下：

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

append() 方法用于在当前列表尾部追加元素，原地修改列表，是真正意义上的在列表尾部添加元素，速度较快。
所谓“原地”，是指不改变列表在内存中的首地址，可以使用id()函数查看列表的内存地址值。

使用append()方法可以向列表中添加1个元素，也可以添加1个列表、1个元组、1个字典等数据，但是append()方法会将添加进去的列表、元组、字典等当做一个整体添加进列表。

该方法的语法格式如下：

listname.append(obj)

• listname ：表示要添加元素的列表
• obj ：表示到添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等。

list01 = [10,20,30]
# append()操作前列表数据
print(list01)  # [10, 20, 30]
print("列表id：",id(list01)) # 列表id：2104113409472

# 追加1个元素
list01.append(40)
# append()操作后列表数据
print(list01)  # [10, 20, 30, 40]
print("列表id：",id(list01)) # 列表id：2104113409472

# 追加列表，整个列表也被当成一个元素
list01.append([50,60])
# append()操作后列表数据
print(list01)  # [10, 20, 30, 40, [50, 60]]
print("列表id：",id(list01)) # 列表id：2104113409472

# 追加元组，整个元组也被当成一个元素
list01.append((70,80))
# append()操作后列表数据
print(list01)  # [10, 20, 30, 40, [50, 60], (70, 80)]
print("列表id：",id(list01)) # 列表id：2104113409472

# 追加字典，整个字典也被当成一个元素
list01.append({"a":100,"b":200})
# append()操作后列表数据
print(list01)  # [10, 20, 30, 40, [50, 60], (70, 80), {'a': 100, 'b': 200}]
print("列表id：",id(list01)) # 列表id：2104113409472

运行结果如下图所示：

可以发现，列表的内存地址值一直没有变化，说明append()方法追加元素到列表尾部是“原地”操作。

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

extend()方法的功能和 和 append() 方法一样，都是在列表的尾部添加元素，也都是原地操作，不改变列表内存首地址。不同之处在于append() 方法会将添加到列表中的列表、元组、字典等元素当做一个整体添加到列表中，而extend() 不会把列表、元祖或者字典等视为一个整体，而是把它们包含的元素逐个添加到列表中。

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

listname.extend(obj)

• listname：指的是要添加元素的列表；
• obj： 表示到添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等，但不能是单个的数字。

list01 = [10,20,30]
# extend()操作前列表数据
print(list01)  # [10, 20, 30]
print("列表id：",id(list01)) # 列表id： 2902869192128

# 追加1个字符串，将字符串中的字符依次取出来追加在列表尾部
# 注意：添加一个元素时，不能是单个的数字，会报错。如果要添加单个数字，可以将单个数字存入列表或者元组中
list01.extend("abc")
# extend()操作后列表数据
print(list01)  # [10, 20, 30, 'a', 'b', 'c']
print("列表id：",id(list01)) # 列表id： 2902869192128

# 追加1个数字，将1个数字放入列表中
list01.extend([40])
# extend()操作后列表数据
print(list01)  # [10, 20, 30, 'a', 'b', 'c', 40]
print("列表id：",id(list01)) # 列表id： 2902869192128

# 追加列表，将列表中元素依次取出来追加在列表尾部
list01.extend([50,60])
# extend()操作后列表数据
print(list01)  # [10, 20, 30, 'a', 'b', 'c', 40, 50, 60]
print("列表id：",id(list01)) # 列表id： 2902869192128

# 追加元组，将元组中元素依次取出来追加在列表尾部
list01.extend((70,80))
# extend()操作后列表数据
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()操作后列表数据
print(list01)  # [10, 20, 30, 'a', 'b', 'c', 40, 50, 60, 70, 80, 'k1', 'k2']
print("列表id：",id(list01)) # 列表id： 2902869192128

运行结果如下图所示：

可以发现，列表的内存地址值一直没有变化，说明extend()方法追加元素到列表尾部是“原地”操作。

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

append() 和 extend() 方法向列表中增加元素时，都只能在列表末尾添加元素，如果希望在列表中间某个位置增加元素，就可以用 insert() 方法来实现。

需要注意的是，向列表某个位置增加字符串、列表、元组或者字典时，insert()方法 也会将它们视为一个整体，作为一个元素增加到列表中某个位置，这一点和 append() 方法是一样的。

insert() 的语法格式如下：

listname.insert(index , obj)

• index ：表示指定位置的索引值。
• obj：表示添加到列表第index位置的数据，它可以是单个元素，也可以是列表、元组等。

list01 = [10,20,30]
# insert()操作前列表数据
print(list01)  # [10, 20, 30]
print("列表id：",id(list01)) # 列表id： 1515344997824

# 插入1个元素
list01.insert(1,40)
# insert()操作后列表数据
print(list01)  # [10, 40, 20, 30]
print("列表id：",id(list01)) # 列表id： 1515344997824

# 插入列表，整个列表也被当成一个元素
list01.insert(1,[50,60])
# insert()操作后列表数据
print(list01)  # [10, [50, 60], 40, 20, 30]
print("列表id：",id(list01)) # 列表id： 1515344997824

# 插入元组，整个元组也被当成一个元素
list01.insert(1,(70,80))
# insert()操作后列表数据
print(list01)  # [10, (70, 80), [50, 60], 40, 20, 30]
print("列表id：",id(list01)) # 列表id： 1515344997824

# 插入字典，整个字典也被当成一个元素
list01.insert(1,{"a":100,"b":200})
# insert()操作后列表数据
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()操作后列表数据
print(list01)  # [10, 'qwert', {'a': 100, 'b': 200}, (70, 80), [50, 60], 40, 20, 30]
print("列表id：",id(list01)) # 列表id： 1515344997824

运行结果如下图所示：

可以发现，列表的内存地址值一直没有变化，说明insert()方法插入元素到列表指定位置是“原地”操作。

注意：

• 应尽量从列表尾部进行元素的增加与删除操作。
• 列表的insert()可以在列表的任意位置插入元素，但由于列表的自动内存管理功能，insert()方法会引起插入位置之后所有元素的移动，这会影响处理速度。
• 类似的还有后面介绍的remove()方法以及使用pop()函数弹出列表非尾部元素和使用del命令删除列表非尾部元素的情况。

6.5 使用乘法来扩展列表对象

将1个列表与1个整数相乘，生成一个新列表，新列表中的元素是原来列表中所有元素重复整数次后的元素。

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

list02 = 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语句可以删除指定索引的元素，结合切片可以删除多个元素，还可以删除整个列表。注意使用索引时，索引不要超出列表索引范围，否则会发生IndexError错误。

语法格式如下

删除指定索引元素
del listname[index]
结合切片，删除中间一段连续（切片）的元素
del listname[start : end]
结合步长切片，删除中间一段不连续的元素
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()方法根据元素本身的值来进行删除操作。需要注意的是，remove() 方法只会删除第一个和指定值相同的元素，没有返回值。而且必须保证该元素是存在的，否则会引发 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()方法根据列表索引来删除元素，并返回删除的值，如果没有指定索引，则默认删除列表中最后一个元素并将该元素返回。注意使用索引时，索引不要超出列表索引范围，否则会发生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]
# 修改前列表数据
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]

# 修改后列表数据
print(list01)

代码运行结果如下图所示：

8.2 使用切片修改多个元素

8.2.1 切片修改多个元素

Python 支持通过切片语法给一组元素赋值。在进行这种操作时，如果不指定步长（step 参数），Python 就不要求新赋值的元素个数与原来的元素个数相同。这意味，该操作既可以为列表添加元素，也可以为列表删除元素。

下面是新赋值元素与索引表示范围元素个数相同的操作：

list01 = [10,20,30,40,50,60,70,80,90]
# 修改前列表数据
print(list01) # [10, 20, 30, 40, 50, 60, 70, 80, 90]

#修改第 1~4 个元素的值（不包括第4个元素），列表中值的个数和索引范围一致，进行修改操作
list01[1: 4] = [200,300,400]

# 修改后列表数据
print(list01) # [10, 200, 300, 400, 50, 60, 70, 80, 90]

运行结果如下图所示：

下面是新赋值元素与索引表示范围元素个数不同的操作：

如果对空切片（slice）赋值，就相当于插入一组新的元素；如果修改的元素值个数比索引范围多，多的元素会插入到列表中；如果修改的元素值个数比索引范围少 ，少的元素从列表中删除。

list01 = [10,20,30,40,50,60,70,80,90]
# 修改前列表数据
print(list01) # [10, 20, 30, 40, 50, 60, 70, 80, 90]
# 如果对空切片（slice）赋值，就相当于插入一组新的元素：
list01[4: 4] = [200,300,400]
# 修改后列表数据
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]
# 修改前列表数据
print(list02) # [10, 20, 30, 40, 50, 60, 70, 80, 90]
#修改第 1~4 个元素的值（不包括第4个元素），修改的值的个数大于索引范围，索引指示的元素进行修改，多的元素添加进列表
list02[1: 4] = [200,300,400,500,600,700]
# 修改后列表数据
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]
# 修改前列表数据
print(list03) # [10, 20, 30, 40, 50, 60, 70, 80, 90]
#修改第 1~5 个元素的值（不包括第5个元素），修改的值的个数小于索引范围，索引指示的元素进行修改，少的元素从列表中删除
list03[1: 5] = [200,300]
# 修改后列表数据
print(list03) # [10, 200, 300, 60, 70, 80, 90]

运行结果如下图所示：

使用切片语法赋值时，Python 不支持单个值，运行会报错

list01 = [10,20,30,40,50,60,70,80,90]
# 修改前列表数据
print(list01) # [10, 20, 30, 40, 50, 60, 70, 80, 90]
# 使用切片语法赋值时，Python 不支持单个值，例如下面的写法就是错误的：
list01[4:4] = 999 # TypeError: must assign iterable to extended slice
# 修改后列表数据
print(list01)

运行结果如下图所示：

8.2.2 步长切片修改多个元素

使用切片语法时也可以指定步长（step 参数），但这个时候就要求所赋值的新元素的个数与原有元素的个数相同，不能多也不能少，否则就报错。

赋值的新元素与原有元素个数相同

list01 = [10,20,30,40,50,60,70,80,90]
# 修改前列表数据
print(list01) # [10, 20, 30, 40, 50, 60, 70, 80, 90]
# 赋值的新元素与原有元素个数相同
list01[1:6:2 ] = [200,300,400]
# 修改后列表数据
print(list01) # [10, 200, 30, 300, 50, 400, 70, 80, 90]

运行结果如下图所示：

赋值的新元素比原有元素个数多

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

运行结果如下图所示：

赋值的新元素比原有元素个数少

list01 = [10,20,30,40,50,60,70,80,90]
# 修改前列表数据
print(list01) # [10, 20, 30, 40, 50, 60, 70, 80, 90]
# 赋值的新元素比原有元素个数多
list01[1:6:2 ] = [200,300] # ValueError: attempt to assign sequence of size 2 to extended slice of size 3
# 修改后列表数据
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中存在： True

result02 = 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中存在： False

result02 = 100 not in list01
print("元素100不在列表list01中存在：",result02) # 元素100不在列表list01中存在： True

运行结果如下图所示：

9.3 index() 方法

index() 方法用来查找某个元素在列表中出现的位置（也就是索引），如果该元素不存在，则会导致 ValueError 错误，所以在查找之前最好in运算或使用 count() 方法判断一下。

语法格式如下：

listname.index(obj, start, end)

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

start 和 end 参数用来指定检索范围：

• 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在列表中第一次出现的索引：",index01) # 元素20在列表中第一次出现的索引： 1

index02 = list01.index(20,3,6)
print("元素20在列表索引范围[3,6）第一次出现的索引：",index02) # 元素20在列表索引范围[3,6）第一次出现的索引： 4

运行结果如下：

9.4 count()方法

count() 方法用来统计某个元素在列表中出现的次数。

语法格式如下：

result = listname.count(obj)

listname ：代表列表名

obj ：表示要统计的元素。

如果 count() 返回 0，就表示列表中不存在该元素，所以 count() 也可以用来判断列表中的某个元素是否存在。

演示示例如下：

list01 = [10,20,30,40,20,50,60,70,20]
# 查找元素值20在列表中出现的次数
result01 = list01.count(20)
print("元素20在列表中出现的次数：",result01) # 元素20在列表中出现的次数： 3

# 查找元素值100在列表中出现的次数
result02 = list01.count(100)
print("元素100在列表中出现的次数：",result02) # 元素100在列表中出现的次数： 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()函数对列表进行临时排序，也就是不会改变列表元素原来的排序。两个方法都可以多列表元素进行升序或者降序排序。默认都是升序排序，如果要进行降序排序，需要借助参数reverse参数。

列表中还提供了方法对列表元素进行逆序操作。使用reverse()方法可以实现。

10.1 使用 sorted() 函数

该函数会返回升序排序的新列表，同时不影响原本的列表。

语法格式如下：

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

• iterable：表示可迭代对象，在这里就是列表名
• key为可选参数，如果指定了该参数，会使用该参数的方法进行排序
• reverse为可选参数，设置升序还是降序，默认值为False，进行升序排序，设置为True，可以实现降序排序。

演示示例如下：

list01 = [10,90,50,20,60,30,70,30,80,40]
print("排序前list01列表：",list01) # 排序前list01列表： [10, 90, 50, 20, 60, 30, 70, 30, 80, 40]

# sorted()方法是临时排序，默认是升序排序，不影响列表本身排序，产生一个升序排序的新列表
sortedList01 = sorted(list01) # 升序排序操作得到的列表： [10, 20, 30, 30, 40, 50, 60, 70, 80, 90]
print("升序排序操作得到的列表：",sortedList01)
# sorted()方法是临时排序，默认是升序排序，设置参数reverse=True产生一个降序排序的新列表
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为可选参数，如果指定了该参数，会使用该参数的方法进行排序
• reverse为可选参数，表示是否反向排序，默认为False

演示示例如下：

list01 = [10,90,50,20,60,30,70,30,80,40]
print("排序前list01列表：",list01) # 排序前list01列表： [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("排序前list02列表：",list02) # 排序前list02列表： [10, 90, 50, 20, 60, 30, 70, 30, 80, 40]
# sort()方法是永久排序，默认是升序排序，直接在原列表上进行排序操作，设置参数reverse=True产生一个降序排序的列表
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("反转前list01列表：",list01) # 反转前list01列表： [10, 90, 50, 20, 60, 30]
list01.reverse()
print("反转后list01列表：",list01) # 反转后list01列表： [30, 60, 20, 50, 90, 10]

运行结果如下图所示：

十一、列表的复制

列表的复制有两种方式可以实现，一种是使用切片访问列表，创建一个包含整个列表的切片，也就是在切片中同时省略起始索引值和结束索引值（列表名[:]），从而实现列表的复制；另外一种方式是使用列表对象的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）是一种简洁而高效的构建容器（如列表、集合、字典）的方法。它允许你用一行代码来创建容器，并且可以通过循环和条件语句来生成容器中的元素。

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

推导式是Python中非常强大和常用的特性，可以使代码更加简洁和高效。

12.2 列表推导式

列表推导式提供了一种创建列表的简洁方法，通常是操作某个序列的每个元素，并将其结果作为新列表的元素，或者根据判定条件创建子序列。列表推导式一般由表达式及for语句构成，其后还可以有零个到多个for自居或if子句，返回结果是表达式在for语句和if语句的操作下生成的列表。

语法格式：

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

• listname：新生成的列表名字。
• expression：表达式。
• variable：变量名。
• （if condition）：用于从对象中选择符合要求的列表。

演示示例：

# 1：生成[0-10)之间的10个整数，存储在列表中
# 普通方式生成
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]之间所有整数的平方组成的列表
# 普通方式生成
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:取出已有列表中的奇数值生成新列表
# 已有列表
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列表是一种功能强大的数据结构，能够存储任意类型的有序、可重复元素。列表的创建简洁明了，可以使用方括号 [] 或内置的 list() 函数来初始化。列表支持多种访问方式，包括使用索引和切片来获取单个或多个元素，这些操作使得数据访问变得灵活且高效。

在列表的操作上，可以方便地添加、删除和修改元素。无论是追加到列表末尾，还是插入到指定位置，亦或是删除某个特定元素，Python都提供了直观的方法。修改元素时，只需通过索引直接赋值即可。此外，列表还支持遍历操作，可以通过循环和 enumerate() 函数轻松地访问每个元素及其索引。

查找元素时，Python提供了 in 和 not in 运算符来检查元素是否存在，以及 index() 和 count() 方法来获取元素的索引和计数。列表还可以进行排序和反转操作，以满足不同的数据处理需求。

复制列表时，可以使用切片操作或内置的 copy() 方法来创建一个新的列表副本。列表推导式则提供了一种简洁的方式来生成列表，通过一行代码即可实现对数据的处理和转换。

总之，Python列表的灵活性和强大功能使其成为编程中不可或缺的数据结构。通过学习和实践，你将能够熟练运用列表来解决各种问题，提高编程效率和代码可读性。掌握列表的使用，将为你进一步学习Python打下坚实的基础。

博主辛苦写了这么详细的教程，都看到这了，还不关注博主，是不是说不过去呀？？？