Python 使用 List 和 Tuple
本章节介绍 Python 中 list(列表)和 tuple(元组)的基本使用,包括创建、增删改查、切片操作及注意事项。
1. 基本概念
1.1 什么是 List 和 Tuple?
- List(列表):可变的有序序列,使用方括号
[]
定义,可存储任意类型元素。 - Tuple(元组):不可变的有序序列,使用圆括号
()
定义,内容定义后不可修改。
1.2 创建 List 和 Tuple
# 创建列表
my_list = [1, 2, "hello", 3.14]
empty_list = []
# 创建元组
my_tuple = (1, 2, "world", 3.14)
empty_tuple = ()
single_tuple = (42,) # 单元素元组需加逗号
注意:
- 列表和元组可包含任意类型元素。
- 单元素元组必须加逗号,否则 Python 视为普通值。
2. 基本操作
2.1 访问元素(查)
列表和元组通过索引访问元素,索引从 0
开始,负索引从末尾开始。
my_list = [10, 20, 30, 40]
my_tuple = (1, 2, 3, 4)
print(my_list[0]) # 输出: 10
print(my_tuple[-1]) # 访问最后一个元素,输出: 4
遍历 List 和 Tuple
- for 循环:逐个访问元素。
- while 循环:通过索引遍历。
- 列表推导式(仅限列表):快速处理元素。
my_list = [10, 20, 30, 40]
my_tuple = (1, 2, 3, 4)
# for 循环遍历
for item in my_list:
print(item, end=" ") # 输出: 10 20 30 40
# while 循环遍历
i = 0
while i < len(my_tuple):
print(my_tuple[i], end=" ") # 输出: 1 2 3 4
i += 1
# 列表推导式(仅列表)
squared = [x**2 for x in my_list]
print(squared) # 输出: [100, 400, 900, 1600]
2.2 修改元素(改)
- 列表:支持直接修改。
- 元组:不可修改,尝试修改会抛出
TypeError
。
my_list = [10, 20, 30, 40]
my_tuple = (1, 2, 3, 4)
my_list[1] = 50 # 修改列表元素
print(my_list) # 输出: [10, 50, 30, 40]
my_tuple[1] = 5 # 错误!元组不可修改
2.3 添加元素(增)
- 列表:支持多种添加方法。
- 元组:不可直接添加,可通过拼接创建新元组。
my_list = [10, 20, 30, 40]
my_tuple = (1, 2, 3, 4)
# 列表添加
my_list.append(60) # 末尾添加
my_list.insert(1, 15) # 在索引1插入
my_list.extend([70, 80]) # 批量添加
print(my_list) # 输出: [10, 15, 50, 30, 40, 60, 70, 80]
# 元组拼接
my_tuple = my_tuple + (5, 6)
print(my_tuple) # 输出: (1, 2, 3, 4, 5, 6)
2.4 删除元素(删)
- 列表:支持多种删除方式。
- 元组:不可直接删除,可通过切片创建新元组。
my_list = [10, 15, 20, 30, 40, 60, 70, 80]
my_tuple = (1, 2, 3, 4, 5, 6)
# 列表删除
my_list.pop() # 删除最后一个
my_list.pop(1) # 删除索引1
my_list.remove(50) # 删除值为50
del my_list[0] # 删除索引0
print(my_list) # 输出: [30, 40, 60, 70]
# 元组切片
my_tuple = my_tuple[:2] + my_tuple[3:]
print(my_tuple) # 输出: (1, 2, 4, 5, 6)
3. 切片操作
切片用于获取子序列,格式为 [start:end:step]
:
start
:起始索引(包含,默认 0)。end
:结束索引(不包含,默认到末尾)。step
:步长(默认 1,负数表示逆序)。
my_list = [0, 1, 2, 3, 4, 5]
my_tuple = (0, 1, 2, 3, 4, 5)
# 基本切片
print(my_list[1:4]) # 输出: [1, 2, 3]
print(my_tuple[:3]) # 输出: (0, 1, 2)
print(my_list[2:]) # 输出: [2, 3, 4, 5]
# 带步长
print(my_list[::2]) # 输出: [0, 2, 4]
print(my_tuple[1:5:2]) # 输出: (1, 3)
# 逆序
print(my_list[::-1]) # 输出: [5, 4, 3, 2, 1, 0]
print(my_tuple[4:1:-1]) # 输出: (4, 3, 2)
# 切片赋值(仅列表)
my_list[1:3] = [10, 20]
print(my_list) # 输出: [0, 10, 20, 3, 4, 5]
注意:
- 切片返回新序列,不修改原序列。
- 越界索引返回空序列,不报错。
- 列表支持切片赋值,元组不支持。
4. 常用方法和操作
4.1 列表常用方法
my_list = [3, 1, 4, 1, 5]
my_list.append(6) # 末尾添加
my_list.insert(0, 0) # 指定位置插入
my_list.extend([7, 8]) # 批量添加
my_list.remove(1) # 删除第一个匹配值
my_list.pop() # 删除并返回末尾元素
my_list.sort() # 排序
my_list.reverse() # 反转
my_list.clear() # 清空列表
print(my_list) # 输出: []
print(my_list.count(1)) # 统计元素出现次数
print(len(my_list)) # 获取长度
print(max([1, 2, 3])) # 最大值
print(min([1, 2, 3])) # 最小值
4.2 元组常用操作
元组方法较少,主要支持以下操作:
my_tuple = (1, 2, 2, 3)
print(my_tuple.count(2)) # 输出: 2
print(my_tuple.index(2)) # 输出: 1
print(len(my_tuple)) # 输出: 4
print(max(my_tuple)) # 输出: 3
print(min(my_tuple)) # 输出: 1
4.3 其他操作
- 连接:
+
合并序列。 - 重复:
*
重复序列。 - 成员测试:
in
检查元素存在。
my_list = [3, 1, 4, 1, 5]
print([1, 2] + [3, 4]) # 输出: [1, 2, 3, 4]
print((1, 2) * 2) # 输出: (1, 2, 1, 2)
print(2 in my_list) # 输出: False
5. 注意事项
- 可变性:
- 列表可变,适合动态修改场景。
- 元组不可变,适合固定数据。
- 性能:
- 元组内存占用少,访问稍快。
- 列表操作灵活,但可能耗时。
- 列表嵌套元素可修改,元组嵌套元素不可改。
- 错误处理:
- 越界索引抛出
IndexError
。 - 元组修改抛出
TypeError
。
- 越界索引抛出
- 单元素元组:
- 必须加逗号,如
(42,)
。
- 必须加逗号,如
- 空序列:
- 空列表
[]
,空元组()
。
- 空列表
- 切片边界:
- 越界切片返回空序列,不报错。
嵌套:
nested_list = [1, [2, 3], 4]
nested_list[1][0] = 20
print(nested_list) # 输出: [1, [20, 3], 4]
6. 总结
- 列表:灵活、可变,适合动态操作,方法丰富。
- 元组:固定、不可变,内存高效,方法较少。
- 两者支持索引、切片、遍历等操作,选择时根据是否需要修改数据决定。