Python列表与元组：有序序列的完整指南

Python列表与元组：有序序列的完整指南

列表和元组是Python中最常用的有序序列类型，本篇将系统讲解它们的用法、区别及实战场景。

一、列表（List）

列表是Python中最常用的数据结构，可以存储任意类型的元素，且支持增删改查。

1. 创建列表

# 空列表
empty_list = []
empty_list2 = list()

# 有元素的列表
numbers = [1, 2, 3, 4, 5]
mixed = [1, "hello", 3.14, True]  # 可以混合不同类型
nested = [[1, 2], [3, 4]]         # 嵌套列表

2. 访问元素（索引与切片）

fruits = ["苹果", "香蕉", "橙子", "葡萄", "西瓜"]

# 索引（从0开始）
print(fruits[0])    # 苹果
print(fruits[-1])   # 西瓜（负索引从末尾开始）

# 切片 [起始:结束:步长]
print(fruits[1:3])    # ['香蕉', '橙子']（不包含结束索引）
print(fruits[:3])     # ['苹果', '香蕉', '橙子']（省略起始默认0）
print(fruits[2:])     # ['橙子', '葡萄', '西瓜']（省略结束到末尾）
print(fruits[::2])    # ['苹果', '橙子', '西瓜']（步长2）
print(fruits[::-1])   # ['西瓜', '葡萄', '橙子', '香蕉', '苹果']（反转）

3. 修改元素

fruits = ["苹果", "香蕉", "橙子"]
fruits[0] = "草莓"
print(fruits)  # ['草莓', '香蕉', '橙子']

4. 添加元素

fruits = ["苹果", "香蕉"]

# append：末尾添加单个元素
fruits.append("橙子")
print(fruits)  # ['苹果', '香蕉', '橙子']

# insert：指定位置插入
fruits.insert(1, "草莓")
print(fruits)  # ['苹果', '草莓', '香蕉', '橙子']

# extend：批量添加（拼接另一个列表）
fruits.extend(["葡萄", "西瓜"])
print(fruits)  # ['苹果', '草莓', '香蕉', '橙子', '葡萄', '西瓜']

5. 删除元素

fruits = ["苹果", "香蕉", "橙子", "香蕉"]

# remove：删除第一个匹配的元素
fruits.remove("香蕉")
print(fruits)  # ['苹果', '橙子', '香蕉']

# pop：删除指定索引的元素（默认最后一个），并返回该元素
removed = fruits.pop()
print(removed)  # 香蕉
print(fruits)   # ['苹果', '橙子']

# del：按索引删除
del fruits[0]
print(fruits)  # ['橙子']

# clear：清空列表
fruits.clear()
print(fruits)  # []

6. 常用方法

numbers = [3, 1, 4, 1, 5, 9, 2, 6]

# 统计元素出现次数
print(numbers.count(1))  # 2

# 查找元素索引（不存在会报错）
print(numbers.index(5))  # 4

# 排序（原地修改）
numbers.sort()
print(numbers)  # [1, 1, 2, 3, 4, 5, 6, 9]

# 降序排序
numbers.sort(reverse=True)
print(numbers)  # [9, 6, 5, 4, 3, 2, 1, 1]

# 反转
numbers.reverse()

# 复制
new_list = numbers.copy()

7. 列表推导式（重点）

列表推导式是Python的特色语法，简洁高效地创建列表。

# 基础形式：[表达式 for 变量 in 可迭代对象]
squares = [x ** 2 for x in range(1, 6)]
print(squares)  # [1, 4, 9, 16, 25]

# 带条件筛选
evens = [x for x in range(1, 11) if x % 2 == 0]
print(evens)  # [2, 4, 6, 8, 10]

# 带if-else
result = ["偶数" if x % 2 == 0 else "奇数" for x in range(1, 6)]
print(result)  # ['奇数', '偶数', '奇数', '偶数', '奇数']

# 嵌套推导式（展平二维列表）
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat = [num for row in matrix for num in row]
print(flat)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

二、元组（Tuple）

元组和列表类似，但不可修改（immutable）。

1. 创建元组

# 空元组
empty_tuple = ()

# 有元素的元组
point = (3, 4)
colors = ("红", "绿", "蓝")

# 单元素元组需要逗号（重要！）
single = (1,)   # 这是元组
not_tuple = (1) # 这是整数

# 可以省略括号
data = 1, 2, 3
print(type(data))  # <class 'tuple'>

2. 元组的操作

point = (3, 4)

# 访问（和列表一样）
print(point[0])  # 3

# 切片
print(point[:1])  # (3,)

# 拼接
new_tuple = point + (5, 6)
print(new_tuple)  # (3, 4, 5, 6)

# 重复
print(point * 2)  # (3, 4, 3, 4)

# 长度
print(len(point))  # 2

⚠️ 元组不能修改元素，不能添加、删除，否则会报错 TypeError: 'tuple' object does not support item assignment

3. 元组解包

# 基本解包
x, y = (3, 4)
print(x, y)  # 3 4

# 交换变量（本质是元组解包）
a, b = 1, 2
a, b = b, a

# 带*的解包
first, *rest = [1, 2, 3, 4, 5]
print(first)  # 1
print(rest)   # [2, 3, 4, 5]

*head, last = [1, 2, 3, 4, 5]
print(head)  # [1, 2, 3, 4]
print(last)  # 5

三、列表 vs 元组：如何选择？

选择建议：

• 数据需要变化 → 用列表
• 数据固定不变 → 用元组（如坐标、配置项）
• 函数返回多个值 → 用元组

四、实战：学生成绩统计

# 学生成绩管理
scores = [
    ("张三", 85),
    ("李四", 92),
    ("王五", 78),
    ("赵六", 95),
    ("钱七", 88)
]

# 计算平均分
total = sum(score for _, score in scores)
average = total / len(scores)
print(f"平均分: {average:.1f}")

# 找出最高分和最低分
highest = max(scores, key=lambda x: x[1])
lowest = min(scores, key=lambda x: x[1])
print(f"最高分: {highest[0]}({highest[1]}分)")
print(f"最低分: {lowest[0]}({lowest[1]}分)")

# 成绩排序（降序）
ranked = sorted(scores, key=lambda x: x[1], reverse=True)
print("\n成绩排名:")
for i, (name, score) in enumerate(ranked, 1):
    print(f"第{i}名: {name} - {score}分")

# 筛选优秀学生（90分以上）
excellent = [name for name, score in scores if score >= 90]
print(f"\n优秀学生: {excellent}")

运行结果：

平均分: 87.6
最高分: 赵六(95分)
最低分: 王五(78分)

成绩排名:
第1名: 赵六 - 95分
第2名: 李四 - 92分
第3名: 钱七 - 88分
第4名: 张三 - 85分
第5名: 王五 - 78分

优秀学生: ['李四', '赵六']

五、常见坑点

1. 单元素元组忘记逗号：(1) 是整数，(1,) 才是元组
2. 列表作为默认参数：函数默认参数用列表会导致共享，应用None
3. 遍历列表时删除元素：会导致索引错乱，应遍历副本或倒序删除
4. 浅拷贝问题：new = old 是引用，修改一个另一个也变，应用 .copy() 或 old[:]

# 错误示范：浅拷贝
a = [1, 2, [3, 4]]
b = a.copy()
b[2][0] = 99
print(a)  # [1, 2, [99, 4]] 嵌套元素还是共享的

# 深拷贝
import copy
c = copy.deepcopy(a)

六、课后练习

1. 编写程序，输入一组数字，输出其中的最大值、最小值和平均值
2. 编写程序，将列表 [1, 2, 3, 4, 5] 中的每个元素平方，生成新列表
3. 编写程序，去除列表中的重复元素（至少用两种方法）

七、小结

本篇详细讲解了列表和元组的用法，包括增删改查、切片、推导式、元组解包等核心操作。列表适用于可变数据，元组适用于固定数据，合理选择能让代码更高效安全。

📌 下一篇预告：《Python字典与集合：键值对与去重的艺术》

本专栏持续更新中，欢迎点赞、收藏、关注三连支持！🐍