列表（List）是 Python 中最常用的序列类型之一，它可以存储多个不同类型的元素，并且支持动态修改。本文将详细讲解列表的基本特性、常用操作、高级技巧及注意事项，帮助你熟练掌握列表的使用。
一、列表的基本特性
1. 列表的类型
列表属于 list 类型，用方括号 [] 表示，元素之间用逗号分隔，支持存储整数、字符串、甚至其他列表等任意数据类型。
# 查看列表类型
a = [1, 2, '3', 4, "python"]
print(type(a)) # <class 'list'>2. 列表的可变性
与字符串的不可变性不同，列表是可变序列，可以直接修改、新增、删除元素，无需创建新对象。
二、列表的基础访问
1. 下标访问
通过下标（索引）获取单个元素，规则与字符串一致：
- 正向索引：从左到右，从
0开始 - 反向索引：从右到左，从
-1开始
a = [1, 2, '3', 4, "python"]
print(a[3]) # 4（正向索引：第4个元素）
print(a[-2]) # 4（反向索引：从右数第2个元素）2. 切片操作
截取列表的一部分，遵循 **“包前不包后”** 原则，支持指定步长。
a = [1, 2, '3', 4, "python"]
print(a[3:]) # [4, 'python']（从下标3到结尾）
print(a[:3]) # [1, 2, '3']（从开头到下标2）
print(a[1:4:2]) # [2, 4]（步长为2，截取下标1、3）3. 迭代遍历
列表是可迭代对象，可通过 for 循环逐个访问元素。
a = [1, 2, '3', 4, "python"]
for i in a:
print(i) # 依次输出：1、2、'3'、4、"python"三、列表的核心操作
1. 新增元素
列表提供多种新增元素的方法，适用于不同场景：
| 方法 | 说明 | 示例 |
|---|---|---|
append(x) |
在列表末尾添加单个元素 | a.append("哈哈") → [1, 2, '3', 4, 'python', '哈哈'] |
extend(iter) |
将可迭代对象（列表、字符串等）的元素逐个添加到末尾 | a.extend("this") → [..., 't', 'h', 'i', 's'] |
insert(index, x) |
在指定下标位置插入元素 | a.insert(1, "is") → [1, 'is', 2, '3', 4, 'python', ...] |
+ 运算符 |
拼接两个列表（生成新列表） | a + ['java', 'web'] → [1, 2, '3', 4, 'python', 'java', 'web'] |
2. 修改元素
通过下标直接赋值修改元素。
a = [1, 2, '3', 4, "python"]
a[2] = "T" # 将下标2的元素改为"T"
print(a) # [1, 2, 'T', 4, 'python']3. 查询元素
判断元素是否存在或获取元素位置：
in/not in：判断元素是否在列表中index(x)：返回第一个匹配元素的下标（元素不存在则报错）count(x)：统计元素出现的次数
a = [1, 2, '3', 4, "python", "python"]
print("3" in a) # True（元素存在）
print("python" not in a) # False（元素存在）
print(a.index("python")) # 4（第一个"python"的下标）
print(a.count("python")) # 2（"python"出现2次）4. 删除元素
根据需求选择删除方式：
| 方法 | 说明 | 示例 |
|---|---|---|
del list[index] |
删除指定下标的元素 | del a[0] → 删除下标 0 的元素 |
pop(index) |
删除指定下标的元素并返回该元素（默认删除最后一个） | a.pop(2) → 删除下标 2 的元素，返回被删值 |
remove(x) |
删除第一个匹配的元素（无返回值） | a.remove("python") → 删除第一个 "python" |
a = [1, 2, '3', 4, "python", "python"]
# del 删除
del a[0]
print(a) # [2, '3', 4, 'python', 'python']
# pop 删除
b = [1, 2, '3', 4, "python"]
b.pop() # 默认删除最后一个元素
print(b) # [1, 2, '3', 4]
# remove 删除
c = [1, 2, '3', 4, "python"]
c.remove("python")
print(c) # [1, 2, '3', 4]5. 排序与反转
sort()：对列表元素排序（默认升序，直接修改原列表）reverse()：反转列表元素的顺序（直接修改原列表）
# 排序
a = [1, 2, 3, 8, -1, 9]
a.sort()
print(a) # [-1, 1, 2, 3, 8, 9]（升序）
# 反转
b = [1, 2, 3, 8, -1, 9]
b.reverse()
print(b) # [9, -1, 8, 3, 2, 1]四、列表的高级特性
1. 列表推导式
一种简洁创建列表的方式，格式为：
- 基础格式：
[表达式 for 变量 in 可迭代对象] - 带条件格式：
[表达式 for 变量 in 可迭代对象 if 条件]
# 示例1：生成元素乘以5的列表
li = [1, 2, 3, 4, 5, 6]
result = [i * 5 for i in li]
print(result) # [5, 10, 15, 20, 25, 30]
# 示例2：筛选1-10中的奇数
odd_list = [i for i in range(1, 11) if i % 2 == 1]
print(odd_list) # [1, 3, 5, 7, 9]
# 示例3：批量添加元素
[li.append(i) for i in range(7, 10)]
print(li) # [1, 2, 3, 4, 5, 6, 7, 8, 9]2. 列表嵌套
列表中的元素可以是另一个列表，形成嵌套结构，可通过多级下标访问。
li = [1, 2, 3, [4, 5, 6]] # 嵌套列表
print(li[3]) # [4, 5, 6]（访问嵌套的子列表）
print(li[3][0]) # 4（访问子列表的第一个元素）
print(li[3][1:]) # [5, 6]（子列表切片）3. 列表比较
需通过 operator 模块的 eq 方法比较两个列表是否完全相等（元素及顺序均相同）。
import operator
a = [1, 2]
b = [2, 3]
c = [2, 3]
print(operator.eq(a, b)) # False（a与b不相等）
print(operator.eq(c, b)) # True（c与b完全相等）五、列表的复制：赋值、浅拷贝与深拷贝
在处理列表时，复制操作的行为差异可能导致意外结果，需明确三者的区别：
1. 直接赋值（完全共享资源）
将一个列表赋值给另一个变量时，两者指向同一个内存地址，修改其中一个会影响另一个。
li = [1, 2, 3, 4]
li2 = li # 直接赋值，共享内存地址
li.append(5) # 修改原列表
print(f'li: {li}, id(li): {id(li)}') # li: [1, 2, 3, 4, 5], id(li): 1721799677504
print(f'li2: {li2}, id(li2): {id(li2)}') # li2: [1, 2, 3, 4, 5], id(li2): 1721799677504
# 两者id相同，修改同步生效2. 浅拷贝（数据半共享）
通过 copy.copy() 实现，创建新列表对象，但嵌套的子列表仍共享原内存地址：
- 外层元素修改互不影响
- 嵌套层元素修改会同步影响
import copy
li = [1, 2, 3, [4, 5, 6]] # 含嵌套列表
li2 = copy.copy(li) # 浅拷贝
# 修改外层元素（互不影响）
li.append(7)
print(f'li: {li}, id(li): {id(li)}') # li: [1, 2, 3, [4, 5, 6], 7], id(li): 1721799810944
print(f'li2: {li2}, id(li2): {id(li2)}') # li2: [1, 2, 3, [4, 5, 6]], id(li2): 1721799806272
# 修改嵌套层元素（同步影响）
li[3].append(7) # 操作嵌套子列表
print(f'li[3]: {li[3]}, id(li[3]): {id(li[3])}') # li[3]: [4, 5, 6, 7], id(li[3]): 1721799685760
print(f'li2[3]: {li2[3]}, id(li2[3]): {id(li2[3])}') # li2[3]: [4, 5, 6, 7], id(li2[3]): 1721799685760
# 嵌套子列表id相同，修改同步生效3. 深拷贝（数据完全不共享）
通过 copy.deepcopy() 实现，完全复制所有元素（包括嵌套层），创建独立的内存空间，修改互不影响。
import copy
li = [1, 2, 3, [4, 5, 6]]
li2 = copy.deepcopy(li) # 深拷贝
# 修改外层元素（互不影响）
li.append(7)
print(f'li: {li}, id(li): {id(li)}') # li: [1, 2, 3, [4, 5, 6], 7], id(li): 1721799813440
print(f'li2: {li2}, id(li2): {id(li2)}') # li2: [1, 2, 3, [4, 5, 6]], id(li2): 1721799685888
# 修改嵌套层元素（互不影响）
li[3].append(7)
print(f'li[3]: {li[3]}, id(li[3]): {id(li[3])}') # li[3]: [4, 5, 6, 7], id(li[3]): 1721799817152
print(f'li2[3]: {li2[3]}, id(li2[3]): {id(li2[3])}') # li2[3]: [4, 5, 6], id(li2[3]): 1721799810944
# 嵌套子列表id不同，修改互不影响六、补充实用方法
1. 列表拼接与重复
+：拼接两个列表（生成新列表）*：重复列表元素指定次数（生成新列表）
a = [1, 2]
b = [3, 4]
print(a + b) # [1, 2, 3, 4]（拼接）
print(a * 3) # [1, 2, 1, 2, 1, 2]（重复3次）2. 清空列表
clear() 方法用于清空列表中的所有元素。
a = [1, 2, 3]
a.clear()
print(a) # []3. 复制列表
copy() 方法用于创建列表的浅拷贝（仅复制表层元素）。
a = [1, 2, [3, 4]]
b = a.copy()
b[0] = 100
b[2][0] = 300
print(a) # [1, 2, [300, 4]]（子列表元素会被修改，因浅拷贝共享嵌套对象）