关于元组是不可变的#

所谓元组的不可变指的是元组所指向的内存中的内容不可变。

1
>>> tup = ('r', 'u', 'n', 'o', 'o', 'b')
2
>>> tup[0] = 'g'  # 不支持修改元素
3
Traceback (most recent call last):
4
  File "<stdin>", line 1, in <module>
5
TypeError: 'tuple' object does not support item assignment
6
>>> id(tup)  # 查看内存地址
7
4440687904
8
>>> tup = (1, 2, 3)
9
>>> id(tup)
10
4441088800  # 内存地址不一样了

从以上实例可以看出，重新赋值的元组 tup，绑定到新的对象了，不是修改了原来的对象。

一、知识回顾（读完直接做下面的实践题）#

1. 创建元组：用小括号把逗号分隔的值括起来（tup1 = ('Google', 'Runoob', 1997, 2000)）；括号可以省略（tup3 = "a", "b", "c" 也是元组）；空元组写 ()
2. 只有一个元素的元组必须带逗号：(50,) 才是元组，(50) 会被当成整数 50
3. 元组的元素不能修改、不能删除——t[0] = 'g' 会报 TypeError: 'tuple' object does not support item assignment；del 只能把整个元组删掉
4. “元组不可变”指的是元组所指向的内存内容不可变；给变量重新赋值是让它绑定到了新对象（用 id() 看得出地址变了）
5. 访问元素：下标从 0 开始，也可以从尾部数（tup[-2] 是倒数第二个）；切片 tup[1:4] 含头不含尾
6. 运算符：+ 连接两个元组（生成新元组）、+= 同样能拼接、* 复制重复、in 判断元素在不在、len() 数元素个数
7. 遍历：for x in 元组: 逐个取出元素；想让输出挤在同一行，就把输出函数结尾的换行换成空格
8. 内置函数：len(tuple) 元素个数、max(tuple) 最大值、min(tuple) 最小值、tuple(可迭代对象) 转成元组
9. 与列表互转：list(元组) 转成列表（转完就能改了）、tuple(列表) 转成元组（转完就不能改了）
10. 怎么选：元组适合存”固定不变的一小串记录”（防止误改、更安全），列表适合要频繁增删改的有序数据

二、裸写题#

• 2-1 创建元组 创建文件 test_tuple.py，完成以下操作：

  • 创建元组 t1 = (1, 2, 3, 4, 5)
  • 创建元组 t2 = ("a", "b", "c")
  • 创建只有一个元素的元组 t3 = (10,)（注意逗号）
  • 打印每个元组及其类型

  批改（2026-09-28）：⚠️ 三个元组都创建正确（含 t3 = (10,) 的单元素写法），但只打印了类型（输出三遍 <class 'tuple'>），漏了元组本身的值；参考写法是 print(f"t1: {t1}, 类型: {type(t1)}") 这样三行分别打印。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：三个元组按题面写好（单元素那个别丢掉逗号），再一行一个地打印”元组本身 + 它的类型” 二级 · 方法：元组字面量 (元素1, 元素2, ...)，只有一个元素时要写成 (元素,)；类型用 type() 查 三级 · 骨架：print(f"t1: {t1}, 类型: {____(t1)}") / t3 = (10,____)

  参考答案（做完再点开）

  1
  # 2-1
  2
  t1 = (1, 2, 3, 4, 5)
  3
  t2 = ("a", "b", "c")
  4
  t3 = (10,)
  5
  
  6
  print(f"t1: {t1}, 类型: {type(t1)}")
  7
  print(f"t2: {t2}, 类型: {type(t2)}")
  8
  print(f"t3: {t3}, 类型: {type(t3)}")

• 2-2 访问元组元素 创建文件 test_access.py，完成以下操作：

  • 创建元组 t = ("苹果", "香蕉", "橘子", "葡萄", "西瓜")
  • 打印第一个元素、最后一个元素
  • 打印索引 1 到 3 的切片

  批改（2026-09-28）：✅ 正确（t[0] 得 苹果、t[-1] 得 西瓜，切片 t[1:3] 得 ('香蕉', '橘子')）。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：和列表一样按下标取元素、按区间切一段，只是括号换成了小括号；最后一个元素从尾部数 二级 · 方法：t[0] 第一个、t[-1] 最后一个、t[开始:结束] 切片（含头不含尾） 三级 · 骨架：print(f"第一个: {t[____]}") / print(f"切片 [1:3]: {t[1:____]}")

  参考答案（做完再点开）

  1
  # 2-2
  2
  t = ("苹果", "香蕉", "橘子", "葡萄", "西瓜")
  3
  
  4
  print(f"第一个: {t[0]}")      # 苹果
  5
  print(f"最后一个: {t[-1]}")   # 西瓜
  6
  print(f"切片 [1:3]: {t[1:3]}")  # ('香蕉', '橘子')

• 2-3 元组拼接与重复 创建文件 test_concat.py，完成以下操作：

  • 创建元组 a = (1, 2, 3) 和 b = (4, 5, 6)
  • 用 + 拼接两个元组
  • 用 * 重复元组 3 次

  批改（2026-09-28）：✅ 正确（拼接 (1, 2, 3, 4, 5, 6)、重复三次 (1, 2, 3, 1, 2, 3, 1, 2, 3)，+ 和 * 都用对了）。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：元组之间的拼接和重复跟字符串一样用加号和乘号；运算后拿到的是一个新元组，原来的没被改动 二级 · 方法：c = a + b 拼接、d = a * 3 重复 三级 · 骨架：c = a ____ b / d = a ____ 3

  参考答案（做完再点开）

  1
  # 2-3
  2
  a = (1, 2, 3)
  3
  b = (4, 5, 6)
  4
  
  5
  c = a + b
  6
  print(f"拼接: {c}")  # (1, 2, 3, 4, 5, 6)
  7
  
  8
  d = a * 3
  9
  print(f"重复: {d}")  # (1, 2, 3, 1, 2, 3, 1, 2, 3)

• 2-4 元组常用函数 创建文件 test_func.py，完成以下操作：

  • 创建元组 t = (3, 1, 4, 1, 5, 9, 2, 6)
  • 用 len() 计算长度
  • 用 max() 获取最大值
  • 用 min() 获取最小值

  批改（2026-09-28）：✅ 正确（长度 8、最大值 9、最小值 1 都对）。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：数个数、取最大、取最小都是内置函数，直接套在元组上 二级 · 方法：len(t) 长度、max(t) 最大值、min(t) 最小值 三级 · 骨架：print(f"长度: {____(t)}") / print(f"最大值: {____(t)}") / print(f"最小值: {____(t)}")

  参考答案（做完再点开）

  1
  # 2-4
  2
  t = (3, 1, 4, 1, 5, 9, 2, 6)
  3
  
  4
  print(f"长度: {len(t)}")    # 8
  5
  print(f"最大值: {max(t)}")  # 9
  6
  print(f"最小值: {min(t)}")  # 1

• 2-5 元组与列表转换 创建文件 test_convert.py，完成以下操作：

  • 创建列表 lst = [1, 2, 3, 4, 5]
  • 用 tuple() 将列表转换为元组
  • 创建元组 t = (6, 7, 8)
  • 用 list() 将元组转换为列表

  批改（2026-09-28）：✅ 正确（列表转元组 (1, 2, 3, 4, 5)、元组转列表 [6, 7, 8] 都对；转换结果直接赋回 lst、t 两个变量，不影响结果）。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：转换用与目标类型同名的内置函数，把要转的对象当参数传进去就行 二级 · 方法：tuple(lst) 列表转元组、list(t) 元组转列表 三级 · 骨架：t = ____(lst) / lst2 = ____(t2)

  参考答案（做完再点开）

  1
  # 2-5
  2
  lst = [1, 2, 3, 4, 5]
  3
  t = tuple(lst)
  4
  print(f"列表转元组: {t}")  # (1, 2, 3, 4, 5)
  5
  
  6
  t2 = (6, 7, 8)
  7
  lst2 = list(t2)
  8
  print(f"元组转列表: {lst2}")  # [6, 7, 8]

• 2-6 元组遍历与删除 创建文件 test_iter.py，完成以下操作：

  • 创建元组 t = (10, 20, 30, 40, 50)
  • 用 for 循环遍历打印每个元素
  • 用 in 判断 30 是否在元组中
  • 用 del 删除整个元组，观察结果

  批改（2026-09-28）：✅ 正确（for 循环逐个打印 10~50、30 in t 输出 True、del t 已执行）；你是一行一个数字，参考答案用 print(x, end=" ") 挤在同一行，题面只要求”遍历打印每个元素”。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：遍历就是用循环把元素一个个取出来打印；判断在不在用成员运算符；元组里的元素删不掉，但可以整个把元组删掉（删完再访问就会报错） 二级 · 方法：for x in t: 逐个遍历；30 in t 判断在不在；del t 删除整个元组 三级 · 骨架：for x in ____: / print(f"30是否在元组中: {30 ____ t}") / ____ t

  参考答案（做完再点开）

  1
  # 2-6
  2
  t = (10, 20, 30, 40, 50)
  3
  
  4
  # for 循环遍历
  5
  for x in t:
  6
      print(x, end=" ")  # 10 20 30 40 50
  7
  print()
  8
  
  9
  # in 判断
  10
  print(f"30是否在元组中: {30 in t}")  # True
  11
  
  12
  # del 删除
  13
  del t
  14
  # print(t)  # 报错：NameError: name 't' is not defined

• 2-7 元组不可变性验证 创建文件 test_immut.py，完成以下操作：

  • 创建元组 t = (1, 2, 3)
  • 尝试修改 t[0] = 10，观察报错信息
  • 用 id() 查看修改前后元组的内存地址

  批改（2026-09-28）：⚠️ t = (1, 2, 3) 和两次 id() 都对（实测地址 2630688678976 → 2630688670400，重新赋值后确实是新对象），但修改那行 # t[0]=10 是注释掉的，没有实际跑过、也没记下报错信息；把注释去掉会得到 TypeError: 'tuple' object does not support item assignment。

  提示（先自己想，实在想不出再点开）

  一级 · 思路：元组的元素不能改，那一行真的跑起来会直接报错，把报错信息记下来；想制造”改动后”的样子只能整个重新赋值，再用内存地址验证它已经是另一个对象 二级 · 方法：t[0] = 10 会抛 TypeError: 'tuple' object does not support item assignment；看内存地址用 id(t) 三级 · 骨架：# t[0] = 10（去掉注释运行看报错）/ print(f"修改前地址: {____(t)}") / t = (10, 2, 3)（整个重新赋值）

  参考答案（做完再点开）

  1
  # 2-7
  2
  t = (1, 2, 3)
  3
  print(f"修改前: {t}")
  4
  print(f"修改前地址: {id(t)}")
  5
  
  6
  # 尝试修改会报错：TypeError: 'tuple' object does not support item assignment
  7
  # t[0] = 10
  8
  
  9
  t = (10, 2, 3)  # 重新赋值
  10
  print(f"重新赋值后: {t}")
  11
  print(f"重新赋值后地址: {id(t)}")  # 地址不同，是新对象