Skip to main content

Python 基础

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. 注意事项

  1. 可变性
    • 列表可变,适合动态修改场景。
    • 元组不可变,适合固定数据。
  2. 性能
    • 元组内存占用少,访问稍快。
    • 列表操作灵活,但可能耗时。
    • 列表嵌套元素可修改,元组嵌套元素不可改。
  3. 错误处理
    • 越界索引抛出 IndexError
    • 元组修改抛出 TypeError
  4. 单元素元组
    • 必须加逗号,如 (42,)
  5. 空序列
    • 空列表 [],空元组 ()
  6. 切片边界
    • 越界切片返回空序列,不报错。

嵌套

nested_list = [1, [2, 3], 4]
nested_list[1][0] = 20
print(nested_list)      # 输出: [1, [20, 3], 4]

6. 总结

  • 列表:灵活、可变,适合动态操作,方法丰富。
  • 元组:固定、不可变,内存高效,方法较少。
  • 两者支持索引、切片、遍历等操作,选择时根据是否需要修改数据决定。