列表(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]](子列表元素会被修改,因浅拷贝共享嵌套对象)