Python 零基础入门系列（五）：列表与元组——序列操作全解析
·
🐍 Python 零基础入门系列（五）：列表与元组——序列操作全解析
📢 系列说明：
欢迎来到《Python 零基础入门系列》第五篇！前四篇我们掌握了基础语法、运算符、流程控制和字符串操作。📅 更新时间：2026 年 3 月（基于 Python 3.14 最新版本）
🎯 本篇你将学到：列表和元组的创建与访问、50+ 常用方法、列表推导式、两者特点与区别，以及 3 个实用数据管理项目。
⏱️ 预计阅读时间：50-60 分钟 | 💻 实践时间：40-50 分钟
📌 前置知识：已完成前四篇（基础语法、运算符、流程控制、字符串）
📋 完整目录
┌─────────────────────────────────────────────────────────────┐
│ 本篇博客内容导航 │
├─────────────────────────────────────────────────────────────┤
│ 第一部分：列表基础 │
│ ├── 1. 什么是列表？ │
│ ├── 2. 列表的创建方式 │
│ └── 3. 列表的索引与切片 │
├─────────────────────────────────────────────────────────────┤
│ 第二部分：列表常用方法 │
│ ├── 4. 添加元素（append/insert/extend） │
│ ├── 5. 删除元素（remove/pop/clear/del） │
│ ├── 6. 查找元素（index/count/in） │
│ ├── 7. 排序与反转（sort/sorted/reverse） │
│ └── 8. 复制列表（copy/切片） │
├─────────────────────────────────────────────────────────────┤
│ 第三部分：列表推导式 │
│ ├── 9. 基础语法 │
│ ├── 10. 条件过滤 │
│ └── 11. 嵌套推导式 │
├─────────────────────────────────────────────────────────────┤
│ 第四部分：元组详解 │
│ ├── 12. 元组的创建 │
│ ├── 13. 元组的索引与切片 │
│ ├── 14. 元组的常用方法 │
│ └── 15. 元组解包 │
├─────────────────────────────────────────────────────────────┤
│ 第五部分：列表 vs 元组 │
│ ├── 16. 可变性对比 │
│ ├── 17. 性能对比 │
│ ├── 18. 使用场景对比 │
│ └── 19. 何时用列表，何时用元组 │
├─────────────────────────────────────────────────────────────┤
│ 第六部分：综合实战 │
│ ├── 20. 实战一：学生成绩管理系统 │
│ ├── 21. 实战二：购物车系统 │
│ └── 22. 实战三：待办事项列表 │
└─────────────────────────────────────────────────────────────┘
第一部分：列表基础
1. 什么是列表？
📖 定义
列表（List） 是 Python 中最常用的有序、可变序列类型，可以存储任意类型的元素，是动态数组的实现。
┌─────────────────────────────────────────────────────────────┐
│ 列表的本质 │
├─────────────────────────────────────────────────────────────┤
│ │
│ [10, 20, 30, 40, 50] │
│ │ │ │ │ │ │
│ 0 1 2 3 4 ← 正向索引 │
│ -5 -4 -3 -2 -1 ← 负向索引 │
│ │
│ 核心特性： │
│ ✅ 有序（Ordered）- 元素有固定顺序 │
│ ✅ 可变（Mutable）- 可以修改、添加、删除元素 │
│ ✅ 可重复（Allow Duplicates）- 允许相同元素 │
│ ✅ 异构（Heterogeneous）- 可存储不同类型 │
│ │
└─────────────────────────────────────────────────────────────┘
2. 列表的创建方式
📝 多种创建方法
# 1. 方括号创建（最常用）
list1 = [1, 2, 3, 4, 5]
list2 = ["苹果", "香蕉", "橙子"]
# 2. 空列表
list3 = []
list4 = list()
# 3. list() 转换
list5 = list("Python") # ['P', 'y', 't', 'h', 'o', 'n']
list6 = list(range(5)) # [0, 1, 2, 3, 4]
list7 = list((1, 2, 3)) # 从元组转换 [1, 2, 3]
# 4. 混合类型
list8 = [1, "hello", 3.14, True, [1, 2]]
# 5. 列表推导式创建
list9 = [x for x in range(10)]
print(f"list1: {list1}")
print(f"list3: {list3}")
print(f"list5: {list5}")
print(f"list8: {list8}")
💡 创建技巧
# 技巧 1：重复元素
zeros = [0] * 5 # [0, 0, 0, 0, 0]
pairs = [1, 2] * 3 # [1, 2, 1, 2, 1, 2]
# 技巧 2：快速生成数字列表
numbers = list(range(1, 11)) # [1, 2, 3, ..., 10]
# 技巧 3：拆分字符串
chars = list("Hello") # ['H', 'e', 'l', 'l', 'o']
# ⚠️ 陷阱：列表乘法创建二维列表
# ❌ 错误方式
matrix_wrong = [[0] * 3] * 3
matrix_wrong[0][0] = 1
print(matrix_wrong) # [[1, 0, 0], [1, 0, 0], [1, 0, 0]] 所有行都被修改！
# ✅ 正确方式
matrix_right = [[0] * 3 for _ in range(3)]
matrix_right[0][0] = 1
print(matrix_right) # [[1, 0, 0], [0, 0, 0], [0, 0, 0]]
3. 列表的索引与切片
列表支持与字符串相同的索引和切片操作。
🔍 索引访问
fruits = ["苹果", "香蕉", "橙子", "葡萄", "西瓜"]
# 正向索引
print(fruits[0]) # 苹果
print(fruits[2]) # 橙子
print(fruits[4]) # 西瓜
# 负向索引
print(fruits[-1]) # 西瓜（最后一个）
print(fruits[-2]) # 葡萄（倒数第二个）
print(fruits[-5]) # 苹果（倒数第五个，即第一个）
# 修改元素
fruits[1] = "芒果"
print(fruits) # ['苹果', '芒果', '橙子', '葡萄', '西瓜']
# ⚠️ 索引越界
# print(fruits[10]) # IndexError!
🔍 切片操作
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 基础切片
print(numbers[2:5]) # [2, 3, 4]
print(numbers[:5]) # [0, 1, 2, 3, 4]
print(numbers[5:]) # [5, 6, 7, 8, 9]
print(numbers[:]) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]（复制）
# 步长切片
print(numbers[::2]) # [0, 2, 4, 6, 8]
print(numbers[1::2]) # [1, 3, 5, 7, 9]
print(numbers[::-1]) # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]（反转）
# 切片修改
numbers[2:5] = [20, 30, 40]
print(numbers) # [0, 1, 20, 30, 40, 5, 6, 7, 8, 9]
# 切片删除
numbers[5:8] = []
print(numbers) # [0, 1, 20, 30, 40, 8, 9]
第二部分：列表常用方法
4. 添加元素
| 方法 | 说明 | 示例 | 结果 |
|---|---|---|---|
append() |
末尾添加单个元素 | lst.append(5) |
[1,2,3,5] |
insert() |
指定位置插入 | lst.insert(1, 5) |
[1,5,2,3] |
extend() |
末尾添加多个元素 | lst.extend([4,5]) |
[1,2,3,4,5] |
🔍 示例
fruits = ["苹果", "香蕉"]
# append - 添加单个元素
fruits.append("橙子")
print(fruits) # ['苹果', '香蕉', '橙子']
# insert - 指定位置插入
fruits.insert(1, "葡萄")
print(fruits) # ['苹果', '葡萄', '香蕉', '橙子']
# extend - 添加多个元素
fruits.extend(["西瓜", "芒果"])
print(fruits) # ['苹果', '葡萄', '香蕉', '橙子', '西瓜', '芒果']
# += 也可以实现 extend
fruits += ["草莓", "蓝莓"]
print(fruits) # ['苹果', '葡萄', '香蕉', '橙子', '西瓜', '芒果', '草莓', '蓝莓']
# ⚠️ append vs extend
list1 = [1, 2, 3]
list1.append([4, 5])
print(list1) # [1, 2, 3, [4, 5]]（嵌套列表）
list2 = [1, 2, 3]
list2.extend([4, 5])
print(list2) # [1, 2, 3, 4, 5]（扁平列表）
5. 删除元素
| 方法 | 说明 | 示例 | 返回值 |
|---|---|---|---|
remove() |
删除第一个匹配值 | lst.remove(3) |
None |
pop() |
删除并返回指定位置元素 | lst.pop() |
元素值 |
clear() |
清空列表 | lst.clear() |
None |
del |
删除语句（可删切片） | del lst[0] |
None |
🔍 示例
fruits = ["苹果", "香蕉", "橙子", "香蕉", "葡萄"]
# remove - 删除第一个匹配值
fruits.remove("香蕉")
print(fruits) # ['苹果', '橙子', '香蕉', '葡萄']
# pop - 删除并返回
last = fruits.pop() # 删除最后一个
print(f"删除了：{last}, 剩余：{fruits}")
second = fruits.pop(1) # 删除索引 1
print(f"删除了：{second}, 剩余：{fruits}")
# clear - 清空
fruits.clear()
print(f"清空后：{fruits}") # []
# del - 删除语句
numbers = [1, 2, 3, 4, 5]
del numbers[0]
print(numbers) # [2, 3, 4, 5]
del numbers[1:3]
print(numbers) # [2, 5]
# 删除整个列表
del numbers
# print(numbers) # NameError!
6. 查找元素
| 方法 | 说明 | 示例 | 结果 |
|---|---|---|---|
index() |
查找元素索引 | lst.index(3) |
2 |
count() |
统计出现次数 | lst.count(3) |
1 |
in |
判断是否存在 | 3 in lst |
True |
🔍 示例
numbers = [1, 2, 3, 2, 4, 2, 5]
# index - 查找索引
print(numbers.index(3)) # 2
print(numbers.index(2)) # 1（第一个 2）
# print(numbers.index(10)) # ValueError!
# 带范围查找
print(numbers.index(2, 2)) # 3（从索引 2 开始找）
print(numbers.index(2, 4, 7)) # 5（在索引 4-7 之间找）
# count - 统计次数
print(numbers.count(2)) # 3
print(numbers.count(10)) # 0
# in - 判断存在
print(3 in numbers) # True
print(10 in numbers) # False
print(10 not in numbers) # True
# 实用：安全查找
def safe_index(lst, value, default=-1):
try:
return lst.index(value)
except ValueError:
return default
print(safe_index(numbers, 10)) # -1
7. 排序与反转
| 方法/函数 | 说明 | 是否修改原列表 |
|---|---|---|
sort() |
列表排序（方法） | ✅ 是 |
sorted() |
列表排序（函数） | ❌ 否 |
reverse() |
列表反转（方法） | ✅ 是 |
[::-1] |
切片反转 | ❌ 否 |
🔍 示例
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
# sort - 原地排序
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]
# 自定义排序（按绝对值）
nums = [-3, 1, -2, 4, -1]
nums.sort(key=abs)
print(nums) # [1, -1, -2, -3, 4]
# sorted - 返回新列表
numbers = [3, 1, 4, 1, 5]
sorted_nums = sorted(numbers)
print(f"原列表：{numbers}") # [3, 1, 4, 1, 5]
print(f"新列表：{sorted_nums}") # [1, 1, 3, 4, 5]
# reverse - 原地反转
numbers.reverse()
print(numbers) # [5, 1, 4, 1, 3]
# 切片反转 - 返回新列表
numbers = [1, 2, 3, 4, 5]
reversed_nums = numbers[::-1]
print(f"原列表：{numbers}") # [1, 2, 3, 4, 5]
print(f"新列表：{reversed_nums}") # [5, 4, 3, 2, 1]
# 字符串列表排序
words = ["python", "Java", "C++", "JavaScript"]
words.sort() # 按 ASCII 排序（大写在前）
print(words) # ['C++', 'Java', 'JavaScript', 'python']
words.sort(key=str.lower) # 不区分大小写
print(words) # ['C++', 'Java', 'JavaScript', 'python']
8. 复制列表
⚠️ 重要：浅拷贝 vs 深拷贝
# ❌ 错误：直接赋值（引用相同）
list1 = [1, 2, 3]
list2 = list1
list2.append(4)
print(list1) # [1, 2, 3, 4] 原列表也被修改！
print(list2) # [1, 2, 3, 4]
print(id(list1) == id(list2)) # True
# ✅ 方法 1：切片复制（浅拷贝）
list1 = [1, 2, 3]
list2 = list1[:]
list2.append(4)
print(list1) # [1, 2, 3]
print(list2) # [1, 2, 3, 4]
# ✅ 方法 2：copy() 方法（浅拷贝）
list1 = [1, 2, 3]
list2 = list1.copy()
list2.append(4)
print(list1) # [1, 2, 3]
print(list2) # [1, 2, 3, 4]
# ✅ 方法 3：list() 构造函数（浅拷贝）
list1 = [1, 2, 3]
list2 = list(list1)
list2.append(4)
print(list1) # [1, 2, 3]
print(list2) # [1, 2, 3, 4]
# ⚠️ 浅拷贝的陷阱（嵌套列表）
import copy
list1 = [1, 2, [3, 4]]
list2 = list1.copy() # 浅拷贝
list2[2].append(5)
print(list1) # [1, 2, [3, 4, 5]] 嵌套列表被修改！
print(list2) # [1, 2, [3, 4, 5]]
# ✅ 深拷贝（完全独立）
list1 = [1, 2, [3, 4]]
list2 = copy.deepcopy(list1)
list2[2].append(5)
print(list1) # [1, 2, [3, 4]]
print(list2) # [1, 2, [3, 4, 5]]
📊 复制方法对比
| 方法 | 类型 | 嵌套列表 | 推荐场景 |
|---|---|---|---|
= |
引用 | ❌ 共享 | 不需要复制时 |
[:] |
浅拷贝 | ❌ 共享 | 简单列表 |
.copy() |
浅拷贝 | ❌ 共享 | 简单列表（推荐） |
list() |
浅拷贝 | ❌ 共享 | 从其他序列转换 |
copy.deepcopy() |
深拷贝 | ✅ 独立 | 嵌套列表 |
第三部分：列表推导式
9. 基础语法
列表推导式是创建列表的简洁方式，比 for 循环更高效。
📝 语法格式
[表达式 for 变量 in 序列]
等价于：
result = []
for 变量 in 序列:
result.append(表达式)
🔍 示例
# 传统方式
squares = []
for i in range(10):
squares.append(i ** 2)
print(squares) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
# 列表推导式
squares = [i ** 2 for i in range(10)]
print(squares) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
# 更多示例
# 1. 提取字符串长度
words = ["python", "java", "c++", "javascript"]
lengths = [len(word) for word in words]
print(lengths) # [6, 4, 3, 10]
# 2. 转大写
upper_words = [word.upper() for word in words]
print(upper_words) # ['PYTHON', 'JAVA', 'C++', 'JAVASCRIPT']
# 3. 数字转换
numbers = ["1", "2", "3", "4"]
ints = [int(n) for n in numbers]
print(ints) # [1, 2, 3, 4]
# 4. 生成坐标对
coords =
print(coords) #
10. 条件过滤
📝 语法格式
[表达式 for 变量 in 序列 if 条件]
🔍 示例
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 筛选偶数
evens = [n for n in numbers if n % 2 == 0]
print(evens) # [2, 4, 6, 8, 10]
# 筛选大于 5 的数
greater_than_5 = [n for n in numbers if n > 5]
print(greater_than_5) # [6, 7, 8, 9, 10]
# 多个条件
result = [n for n in numbers if n % 2 == 0 if n > 5]
print(result) # [6, 8, 10]
# if-else 表达式
labels = ["偶数" if n % 2 == 0 else "奇数" for n in numbers]
print(labels) # ['奇数', '偶数', '奇数', '偶数', ...]
# 实用：过滤空字符串
texts = ["hello", "", "world", "", "python"]
non_empty = [t for t in texts if t]
print(non_empty) # ['hello', 'world', 'python']
# 实用：提取数字
mixed = ["a", "1", "b", "2", "c", "3"]
digits = [int(x) for x in mixed if x.isdigit()]
print(digits) # [1, 2, 3]
11. 嵌套推导式
🔍 示例
# 二维列表展平
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [num for row in matrix for num in row]
print(flattened) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 等价的传统写法
flattened = []
for row in matrix:
for num in row:
flattened.append(num)
# 生成乘法表
multiplication = [[i * j for j in range(1, 10)] for i in range(1, 10)]
print(multiplication[0]) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(multiplication[8]) # [9, 18, 27, 36, 45, 54, 63, 72, 81]
# 矩阵转置
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
transposed = [[row[i] for row in matrix] for i in range(3)]
print(transposed) # [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
# 过滤嵌套列表
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
evens = [[num for num in row if num % 2 == 0] for row in matrix]
print(evens) # [[2], [4, 6], [8]]
💡 建议：嵌套推导式不要超过 2 层，否则可读性会下降。
第四部分：元组详解
12. 元组的创建
📖 定义
元组（Tuple） 是 Python 中的有序、不可变序列类型，一旦创建就不能修改。
📝 创建方式
# 1. 圆括号创建
tuple1 = (1, 2, 3, 4, 5)
tuple2 = ("苹果", "香蕉", "橙子")
# 2. 空元组
tuple3 = ()
tuple4 = tuple()
# 3. tuple() 转换
tuple5 = tuple("Python") # ('P', 'y', 't', 'h', 'o', 'n')
tuple6 = tuple([1, 2, 3]) # (1, 2, 3)
tuple7 = tuple(range(5)) # (0, 1, 2, 3, 4)
# 4. 单元素元组（注意逗号！）
single1 = (5,) # ✅ 正确
single2 = (5) # ❌ 这是整数 5，不是元组！
single3 = 5, # ✅ 也可以，逗号是关键
print(f"single1: {single1}, 类型：{type(single1)}")
print(f"single2: {single2}, 类型：{type(single2)}")
print(f"single3: {single3}, 类型：{type(single3)}")
# 5. 省略括号（元组打包）
tuple8 = 1, 2, 3
print(tuple8) # (1, 2, 3)
13. 元组的索引与切片
元组支持与列表相同的索引和切片操作。
🔍 示例
colors = ("红", "绿", "蓝", "黄", "紫")
# 索引访问
print(colors[0]) # 红
print(colors[-1]) # 紫
print(colors[2]) # 蓝
# 切片
print(colors[1:4]) # ('绿', '蓝', '黄')
print(colors[::-1]) # ('紫', '黄', '蓝', '绿', '红')
# ⚠️ 元组不可修改
# colors[0] = "橙" # TypeError!
# colors.append("白") # TypeError!
# ✅ 但可以通过重新赋值"修改"
colors = colors + ("白",)
print(colors) # ('红', '绿', '蓝', '黄', '紫', '白')
14. 元组的常用方法
元组方法比列表少，因为不可变。
| 方法 | 说明 | 示例 | 结果 |
|---|---|---|---|
count() |
统计出现次数 | t.count(1) |
2 |
index() |
查找元素索引 | t.index(2) |
1 |
🔍 示例
numbers = (1, 2, 3, 2, 4, 2, 5)
# count
print(numbers.count(2)) # 3
# index
print(numbers.index(3)) # 2
# print(numbers.index(10)) # ValueError!
# len
print(len(numbers)) # 7
# in
print(3 in numbers) # True
print(10 in numbers) # False
# 其他操作（与列表相同）
print(len(numbers)) # 7
print(min(numbers)) # 1
print(max(numbers)) # 5
print(sum(numbers)) # 19
print(numbers + (6, 7)) # (1, 2, 3, 2, 4, 2, 5, 6, 7)
print(numbers * 2) # (1, 2, 3, 2, 4, 2, 5, 1, 2, 3, 2, 4, 2, 5)
15. 元组解包
元组解包是 Python 的优雅特性，用于快速赋值。
🔍 基础解包
# 基本解包
point = (10, 20)
x, y = point
print(f"x={x}, y={y}") # x=10, y=20
# 多变量赋值
a, b, c = 1, 2, 3
print(a, b, c) # 1 2 3
# 交换变量（Python 特色）
a, b = 1, 2
a, b = b, a
print(a, b) # 2 1
# 函数返回多值
def get_info():
return "小明", 18, "北京"
name, age, city = get_info()
print(f"{name}, {age}岁，{city}") # 小明，18 岁，北京
🔍 扩展解包（Python 3）
# * 解包剩余元素
numbers = (1, 2, 3, 4, 5)
first, *middle, last = numbers
print(f"first={first}, middle={middle}, last={last}")
# first=1, middle=[2, 3, 4], last=5
# 只取前几个
first, second, *rest = numbers
print(f"first={first}, second={second}, rest={rest}")
# first=1, second=2, rest=[3, 4, 5]
# 只取后几个
*beginning, second_last, last = numbers
print(f"beginning={beginning}, second_last={second_last}, last={last}")
# beginning=[1, 2, 3], second_last=4, last=5
# 嵌套解包
nested = (1, (2, 3), 4)
a, (b, c), d = nested
print(a, b, c, d) # 1 2 3 4
💡 实用场景
# 场景 1：遍历字典
person = {"name": "小明", "age": 18, "city": "北京"}
for key, value in person.items():
print(f"{key}: {value}")
# 场景 2：enumerate 获取索引和值
fruits = ["苹果", "香蕉", "橙子"]
for index, fruit in enumerate(fruits):
print(f"{index}: {fruit}")
# 场景 3：zip 并行遍历
names = ["小明", "小红", "小刚"]
scores = [90, 85, 88]
for name, score in zip(names, scores):
print(f"{name}: {score}分")
第五部分：列表 vs 元组
16. 可变性对比
┌─────────────────────────────────────────────────────────────┐
│ 可变性对比 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 列表（List） │
│ ═══════ │
│ ✅ 可变（Mutable） │
│ • 可以添加元素（append/extend/insert） │
│ • 可以删除元素（remove/pop/del） │
│ • 可以修改元素（lst[0] = new_value） │
│ • 可以排序（sort/reverse） │
│ │
│ ───────────────────────────────────────────────────────── │
│ │
│ 元组（Tuple） │
│ ═══════ │
│ ❌ 不可变（Immutable） │
│ • 不能添加元素 │
│ • 不能删除元素 │
│ • 不能修改元素 │
│ • 不能排序 │
│ • 但可以通过重新赋值"替换"整个元组 │
│ │
└─────────────────────────────────────────────────────────────┘
🔍 代码对比
# 列表 - 可变
list1 = [1, 2, 3]
list1[0] = 100 # ✅ 可以修改
list1.append(4) # ✅ 可以添加
list1.remove(2) # ✅ 可以删除
print(list1) # [100, 3, 4]
# 元组 - 不可变
tuple1 = (1, 2, 3)
# tuple1[0] = 100 # ❌ TypeError!
# tuple1.append(4) # ❌ AttributeError!
# tuple1.remove(2) # ❌ AttributeError!
tuple1 = (100, 2, 3) # ✅ 重新赋值（创建新元组）
print(tuple1) # (100, 2, 3)
17. 性能对比
📊 性能测试
import timeit
# 创建性能
list_time = timeit.timeit('[1, 2, 3, 4, 5]', number=1000000)
tuple_time = timeit.timeit('(1, 2, 3, 4, 5)', number=1000000)
print(f"列表创建时间：{list_time:.4f}秒")
print(f"元组创建时间：{tuple_time:.4f}秒")
print(f"元组快约：{list_time/tuple_time:.2f}倍")
# 内存占用
import sys
list1 = [1, 2, 3, 4, 5]
tuple1 = (1, 2, 3, 4, 5)
print(f"列表内存：{sys.getsizeof(list1)}字节")
print(f"元组内存：{sys.getsizeof(tuple1)}字节")
print(f"元组节省：{(sys.getsizeof(list1)-sys.getsizeof(tuple1))/sys.getsizeof(list1)*100:.1f}%")
📋 性能对比总结
| 特性 | 列表 | 元组 | 优势方 |
|---|---|---|---|
| 创建速度 | 较慢 | 较快 | 元组 |
| 访问速度 | 快 | 更快 | 元组 |
| 内存占用 | 较大 | 较小 | 元组 |
| 修改灵活性 | 高 | 无 | 列表 |
18. 使用场景对比
┌─────────────────────────────────────────────────────────────┐
│ 使用场景对比 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 📌 使用列表的场景 │
│ ══════════════ │
│ • 需要动态添加/删除元素 │
│ • 需要修改元素内容 │
│ • 需要排序或反转 │
│ • 存储同类数据的集合 │
│ • 作为栈或队列使用 │
│ │
│ ───────────────────────────────────────────────────────── │
│ │
│ 📌 使用元组的场景 │
│ ══════════════ │
│ • 数据不应该被修改（如配置常量） │
│ • 作为字典的键（列表不能做键） │
│ • 函数返回多个值 │
│ • 存储异构数据（如数据库记录） │
│ • 需要保证数据安全性 │
│ • 性能敏感的场景 │
│ │
└─────────────────────────────────────────────────────────────┘
19. 何时用列表，何时用元组
📋 决策指南
# ✅ 用列表
# 场景 1：待办事项（需要增删）
todos = ["学习 Python", "写博客", "锻炼身体"]
todos.append("看电影")
todos.remove("写博客")
# 场景 2：收集数据
scores = []
for i in range(5):
scores.append(int(input(f"输入第{i+1}个分数：")))
# 场景 3：需要排序
numbers = [5, 2, 8, 1, 9]
numbers.sort()
# ✅ 用元组
# 场景 1：配置常量（不应修改）
RGB_RED = (255, 0, 0)
RGB_GREEN = (0, 255, 0)
RGB_BLUE = (0, 0, 255)
# 场景 2：数据库记录
user_record = ("小明", 18, "北京", "student@example.com")
# 场景 3：字典的键
locations = {
(39.9, 116.4): "北京",
(31.2, 121.5): "上海",
(23.1, 113.3): "广州"
}
# 场景 4：函数返回多值
def get_user_info():
return "小明", 18, "北京"
name, age, city = get_user_info()
💡 博主建议
┌─────────────────────────────────────────────────────────────┐
│ 专家建议 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 1️⃣ 默认使用列表 │
│ 除非有明确理由使用元组，否则优先用列表 │
│ │
│ 2️⃣ 保护数据用元组 │
│ 如果数据不应该被修改，用元组表达意图 │
│ │
│ 3️⃣ 字典键必须用元组 │
│ 列表不能作为字典的键（不可哈希） │
│ │
│ 4️⃣ 函数返回多值用元组 │
│ 这是 Python 的约定俗成 │
│ │
│ 5️⃣ 性能敏感用元组 │
│ 元组创建和访问略快，内存占用更小 │
│ │
└─────────────────────────────────────────────────────────────┘
第六部分：综合实战
20. 实战一：学生成绩管理系统
📋 项目需求
- 添加学生信息（姓名、成绩）
- 查询学生成绩
- 修改学生成绩
- 删除学生信息
- 统计平均分、最高分、最低分
- 成绩排序
💻 完整代码
由于代码内容过多,导致博客篇幅过长,所以之后实战答案将单独出一篇博客,大家可以先自行练习,之后再核对答案
21. 实战二：购物车系统
📋 项目需求
- 添加商品到购物车
- 移除商品
- 修改商品数量
- 计算总价
- 清空购物车
- 显示购物车内容
💻 完整代码
由于代码内容过多,导致博客篇幅过长,所以之后实战答案将单独出一篇博客,大家可以先自行练习,之后再核对答案
22. 实战三：待办事项列表
📋 项目需求
- 添加待办事项
- 标记完成
- 删除事项
- 显示所有/已完成/未完成
- 统计进度
💻 完整代码
由于代码内容过多,导致博客篇幅过长,所以之后实战答案将单独出一篇博客,大家可以先自行练习,之后再核对答案
📝 总结与下一篇预告
本篇核心知识点回顾
┌─────────────────────────────────────────────────────────────┐
│ 知识点思维导图 │
├─────────────────────────────────────────────────────────────┤
│ │
│ Python 列表与元组 │
│ │ │
│ ├── 列表（List） │
│ │ ├── 创建（[]/list()） │
│ │ ├── 索引与切片 │
│ │ ├── 添加（append/insert/extend） │
│ │ ├── 删除（remove/pop/clear/del） │
│ │ ├── 查找（index/count/in） │
│ │ ├── 排序（sort/sorted/reverse） │
│ │ ├── 复制（copy/切片/深拷贝） │
│ │ └── 推导式（基础/条件/嵌套） │
│ │ │
│ ├── 元组（Tuple） │
│ │ ├── 创建（()/tuple()） │
│ │ ├── 索引与切片 │
│ │ ├── 方法（count/index） │
│ │ └── 解包（基础/扩展/嵌套） │
│ │ │
│ ├── 列表 vs 元组 │
│ │ ├── 可变性（列表可变，元组不可变） │
│ │ ├── 性能（元组更快更省内存） │
│ │ └── 场景（列表灵活，元组安全） │
│ │ │
│ └── 实战应用 │
│ ├── 学生成绩管理系统 │
│ ├── 购物车系统 │
│ └── 待办事项列表 │
│ │
└─────────────────────────────────────────────────────────────┘
✅ 学习检查清单
- 理解列表的可变特性
- 掌握列表的增删改查方法
- 熟练使用列表推导式
- 理解元组的不可变特性
- 掌握元组解包技巧
- 清楚列表与元组的区别
- 完成 3 个实战项目
🚀 下一篇预告
《Python 零基础入门系列（六）：字典与集合——映射与去重操作》
┌─────────────────────────────────────────────────────────────┐
│ 第六篇内容预告 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 1️⃣ 字典基础 │
│ • 字典的创建与表示 │
│ • 字典的访问与修改 │
│ • 字典的遍历方法 │
│ │
│ 2️⃣ 字典常用方法 │
│ • 添加与更新（update/setdefault） │
│ • 删除（pop/popitem/clear/del） │
│ • 查找（get/keys/values/items） │
│ • 字典推导式 │
│ │
│ 3️⃣ 集合基础 │
│ • 集合的创建 │
│ • 集合的增删操作 │
│ • 集合的数学运算（交集/并集/差集） │
│ │
│ 4️⃣ 字典 vs 集合：特点与区别 ★重点 │
│ • 数据结构对比 │
│ • 使用场景对比 │
│ • 性能对比 │
│ │
│ 5️⃣ 综合实战 │
│ • 通讯录管理系统 │
│ • 词频统计工具 │
│ • 数据去重处理器 │
│ │
└─────────────────────────────────────────────────────────────┘
📅 完整系列更新计划
┌─────────────────────────────────────────────────────────────┐
│ 🐍 Python 零基础入门系列 · 完整规划（12 篇版） │
├─────────────────────────────────────────────────────────────┤
│ │
│ 📌 第一篇：Python 认知 + 环境搭建 + 基础语法 │
│ ✅ 已完成 │
│ │
│ 📌 第二篇：常用运算符完全详解 │
│ ✅ 已完成 │
│ │
│ 📌 第三篇：流程控制——条件判断与循环结构 │
│ ✅ 已完成 │
│ │
│ 📌 第四篇：字符串常用操作详解 │
│ ✅ 已完成 │
│ │
│ 📌 第五篇（本篇）：列表与元组——序列操作全解析 │
│ ✅ 已完成 │
│ │
│ 📌 第六篇：字典与集合——映射与去重操作 │
│ 🔜 即将发布 │
│ │
│ 📌 第七篇：函数基础知识（上） │
│ 🔜 敬请期待 │
│ • 什么是函数 │
│ • 函数的定义和调用 │
│ • 函数的参数 │
│ • 函数的返回值 │
│ │
│ 📌 第八篇：函数基础知识（下） │
│ 🔜 敬请期待 │
│ • 函数的文档注释 │
│ • 函数的嵌套调用 │
│ • 局部变量和全局变量 │
│ │
│ 📌 第九篇：函数进阶知识 │
│ 🔜 敬请期待 │
│ • 匿名函数（lambda） │
│ • 递归函数 │
│ • 高阶函数 │
│ │
│ 📌 第十篇：闭包和装饰器 │
│ 🔜 敬请期待 │
│ • 闭包的概念与原理 │
│ • 装饰器的语法与用法 │
│ • 带参数的装饰器 │
│ │
│ 📌 第十一篇：模块和包 │
│ 🔜 敬请期待 │
│ • 模块的导入与使用 │
│ • 常用标准库模块 │
│ • 包的创建与结构 │
│ │
│ 📌 第十二篇及后续：更多进阶内容 │
│ 🔜 敬请期待 │
│ • 文件操作 │
│ • 异常处理 │
│ • 面向对象编程 │
│ │
└─────────────────────────────────────────────────────────────┘
📊 系列进度可视化
进度条：████████████████░░░░░░░░ 5/12 完成
✅ ✅ ✅ ✅ ✅ 🔜 🔜 🔜 🔜 🔜 🔜 🔜
📚 推荐学习资源
| 类型 | 名称 | 链接 |
|---|---|---|
| 官网 | Python 官方网站 | https://www.python.org |
| 文档 | Python 官方文档（中文） | https://docs.python.org/zh-cn/3/ |
| 教程 | 菜鸟教程 Python | https://www.runoob.com/python3/ |
| 教程 | 廖雪峰 Python 教程 | https://www.liaoxuefeng.com/wiki/1016959663602400 |
| 练习 | LeetCode | https://leetcode.cn |
| 练习 | CheckiO（游戏化学习） | https://checkio.org |
| 社区 | Stack Overflow | https://stackoverflow.com |
| 社区 | Python 中文社区 | https://python-china.org |
💬 结语
"列表和元组是 Python 数据结构的基石，掌握它们，你就掌握了组织和管理数据的基本能力。"
恭喜你完成了 Python 入门系列的第五篇！现在你已经：
- ✅ 掌握了列表的创建、访问、增删改查
- ✅ 学会了列表推导式的高效用法
- ✅ 理解了元组的不可变特性与解包技巧
- ✅ 清楚列表与元组的区别与使用场景
- ✅ 完成了学生管理、购物车、待办事项 3 个实战项目
下一步建议：
- 把实战代码亲手敲一遍，尝试添加新功能
- 用列表和元组解决日常数据管理问题
- 复习前五篇内容，形成完整知识体系
- 准备迎接第六篇——字典与集合！
记住：选择合适的数据结构是编程的关键，多思考、多实践！
📅 更新时间：2026 年 3 月 17 日
✍️ 作者：书到用时方恨少! | 专注 Python 教学与 AI 技术分享
💌 如有疑问，欢迎在评论区留言讨论！
如果觉得这篇文章有帮助，请点赞👍、收藏⭐、转发🔄，让更多的小伙伴一起加入 Python 学习的行列！
📢 系列文章索引
| 篇数 | 主题 | 状态 | 链接 |
|---|---|---|---|
| 第一篇 | Python 认知 + 环境搭建 + 基础语法 | ✅ 已完成 | 点击查看 |
| 第二篇 | 常用运算符完全详解 | ✅ 已完成 | 点击查看 |
| 第三篇 | 流程控制——条件判断与循环结构 | ✅ 已完成 | 点击查看 |
| 第四篇 | 字符串常用操作详解 | ✅ 已完成 | 点击查看 |
| 第五篇 | 列表与元组——序列操作全解析 | ✅ 已完成 | 当前文章 |
| 第六篇 | 字典与集合——映射与去重操作 | 🔜 即将发布 | 敬请期待 |
| 第七篇 | 函数基础知识（上） | 🔜 敬请期待 | 敬请期待 |
| 第八篇 | 函数基础知识（下） | 🔜 敬请期待 | 敬请期待 |
| 第九篇 | 函数进阶知识 | 🔜 敬请期待 | 敬请期待 |
| 第十篇 | 闭包和装饰器 | 🔜 敬请期待 | 敬请期待 |
| 第十一篇 | 模块和包 | 🔜 敬请期待 | 敬请期待 |
| 第十二篇 | 更多进阶内容 | 🔜 敬请期待 | 敬请期待 |
🔔 订阅提醒：关注我，不错过每一篇更新！
Agent 垂直技术社区，欢迎活跃、内容共建。
更多推荐
9
0- 0
已为社区贡献10条内容
所有评论(0)