数据的仓库 · 容器

第12章 不变的信物与去重神器

元组与集合

第 12 章 不变的信物与去重神器:元组与集合

📖 本章目标:认识元组(tuple)和集合(set),以及它们各自的独门绝技。
学完本章,你会知道:有些东西"不许改",有些东西"不许重复"。
这两个容器是列表的亲戚,性格却截然相反。元组是"保守派",集合是"洁癖派"。搞懂它们,你选容器的眼光就正式入行了。


【开场小剧场】列表的两个亲戚

学生: 皮皮,除了列表,还有别的"容器"吗?

皮皮: 有,而且各有怪癖。今天介绍两个亲戚:

学生: 什么怪癖?

皮皮: 一个是元组,它跟列表长得一模一样,但有个死脾气——东西放进去就不能改了;另一个是集合,它专治重复——同一种东西只能放一个。

学生: 那要它们干嘛?能改能重复不是挺好的?

皮皮: 嘿嘿,等你看到元组能当字典的钥匙、集合一行去重、还自带交并差运算,你就知道这些"怪癖"有多香了。今天全给你安排上。


12.1 元组:不肯变心的列表

元组(Tuple) 用圆括号 () 表示,别的跟列表差不多:

point = (3, 5)          # 一个坐标
color = (255, 0, 0)     # 一个 RGB 颜色
person = ("皮皮", 30, "爱吃糖葫芦")

元组和列表最大的区别:元组不可变。 列表能增删改,元组一律不行:

point = (3, 5)
point[0] = 99    # ❌ 报错:TypeError:'tuple' object does not support item assignment

报错信息翻译:"元组不支持修改里面的元素。" 东西放进去,就当上了"定海神针",谁也别想动。

元组怎么创建? 圆括号 () 是它的标志:

t1 = (1, 2, 3)      # 标准写法
t2 = 1, 2, 3        # 不加括号也可以!(逗号造元组)
t3 = ()             # 空元组
t4 = (5,)           # 只有一个元素的元组,别忘了逗号!(见翻车现场坑 2)

既然不能改,为什么还需要它?

  1. 当"信物":有些数据天生不该变。比如坐标 (3, 5)、日期、RGB 颜色——它们是"事实",改了就不对了。用元组等于向看代码的人宣告:"这个不允许改,别动它。"
  2. 当字典的钥匙(第 13 章):字典的"键"必须是不可变的,列表不能当键,元组可以。
  3. 运行更快一点:不可变让 Python 能做更多优化(细节不深究)。

🐍"皮皮注:元组的哲学是'定了就不反悔'。坐标是 (3, 5) 就是 (3, 5),你总不能昨天在这,今天坐标就变成 (99, 88) 吧?那地球都要抗议了。"

配套代码文件:code/ch12/coord.py。


12.2 元组拆包:一次拿走全部

元组有个超级好用的特性叫拆包(解包):把元组里每个值直接"拆"给变量:

point = (3, 5)
x, y = point          # 一行拿走两个值!
print(x)              # 3
print(y)              # 5

逐行拆解:
- x, y = point:左边两个变量,右边一个二元元组,Python 自动把 (3, 5) 拆开,3 给 x,5 给 y。

甚至不需要括号,直接用逗号就能造元组(这叫"逗号造元组"):

x, y = 3, 5           # 等价于 (3, 5) 拆包
print(x, y)           # 3 5

交换两个变量的值,第 3 章我们写了好几行,现在一行搞定:

a = 1
b = 2
a, b = b, a           # 交换!Python 帮你自动拆包再装包
print(a, b)           # 2 1

逐行拆解 a, b = b, a: 先把右边 (b, a) 打包成元组 (2, 1),再拆包装给左边的 a, b。"先打包,再拆包"两个动作同时发生,所以交换是安全的。

🐍"皮皮注:还记得第 3 章挑战题的'交换 a 和 b'吗?那题的标准答案是用中间变量。现在 Python 给你开外挂:a, b = b, a。这就是语言的优雅之处——别人三行,它一行。"

拆包还能"拆一半":

head, *rest = (1, 2, 3, 4)     # *rest 把剩下的全接住
print(head)                    # 1
print(rest)                    # [2, 3, 4]

*rest 前面的星号表示"剩下的一坨都归我"。第 16 章学函数参数时,这个 * 还会再出现。


12.3 集合:自动去重的神器

集合(Set) 用花括号 {} 表示(注意:空花括号 {} 是字典,不是集合,空集合要写 set()):

fruits = {"苹果", "香蕉", "苹果", "橘子", "香蕉"}
print(fruits)       # {'橘子', '苹果', '香蕉'}

看到没,你塞了两个苹果、两个香蕉,输出时重复的自动消失了——这就是集合的看家本领:自动去重。

注意集合的另一个特点:顺序是乱的。 输出时元素的顺序不保证和你输入一致。所以集合只适合"有没有"这种问题,不适合"第几个"这种问题。

打个比方: 集合像一个"打卡机",每个人进去前先"滴"一下。你来两次,机器只记一个"已打卡"。它不管你先来后来,只在乎"这个人来了没有"。

最经典的用途:给列表去重,一行搞定:

names = ["皮皮", "小美", "皮皮", "阿强", "小美", "皮皮"]
unique = set(names)        # 转成集合,自动去重
print(unique)              # {'皮皮', '小美', '阿强'}

back_to_list = list(unique)   # 想变回列表?再转回来
print(back_to_list)

逐行拆解:
- set(names):把列表"塞进"集合,重复的自动合并;
- list(unique):把集合转回列表(注意:顺序不保证)。

💡 set(列表) 去重 → list(集合) 转回,这个"去重组合拳"你以后会天天用到。去重这件事,集合一个电话就能搞定。

配套代码文件:code/ch12/word_set.py。


12.4 集合运算:交集、并集、差集

集合在数学课上的那些运算,Python 全支持:

a = {"皮皮", "小美", "阿强"}
b = {"小美", "小明", "阿强"}

print(a & b)     # 交集:两个集合都有的  → {'小美', '阿强'}
print(a | b)     # 并集:合并所有不重复的 → {'皮皮', '小美', '阿强', '小明'}
print(a - b)     # 差集:a 里有但 b 没有 → {'皮皮'}
print(a ^ b)     # 对称差:只在一个里有的 → {'皮皮', '小明'}
运算 符号 含义 例子(a-b)
交集 & 两边都有的 {'小美', '阿强'}
并集 \| 合起来不重复 {皮皮,小美,阿强,小明}
差集 - a 有 b 没有 {'皮皮'}
对称差 ^ 只在一边的 {'皮皮','小明'}

逐行拆解:
- a & b:两个集合里都有的——小美、阿强;
- a | b:全部并起来、重复的只留一个;
- a - b:属于 a、不属于 b 的——皮皮;
- a ^ b:只出现在一边的(不能两边都有)——皮皮、小明。

记忆符号的方法: 把这几个符号想成"手势"——& 是"两边都要握住"(交集),| 是"往两边摊开全要"(并集),- 是"去掉",^ 是"两头翘"(只要单边)。

经典场景:对比两份名单。 比如"谁同时报名了两个社团""谁只报了一个"——集合运算三行搞定。


12.5 集合的方法:add 和 discard

集合的增删有个讲究:它没有顺序,所以没有"下标"这一说。

s = {"苹果"}

s.add("香蕉")        # 添加
print(s)             # {'苹果', '香蕉'}
s.add("苹果")        # 已存在的,加不进去(自动去重)
print(s)             # 还是 {'苹果', '香蕉'}

s.discard("香蕉")    # 删除(不存在也不报错)
print(s)             # {'苹果'}
s.discard("西瓜")    # 没有也不报错,很温柔

逐行拆解:
- s.add("香蕉"):加一个新元素;
- s.add("苹果"):苹果已经在了,加不进去——集合自动去重,多余的被无视;
- s.discard("香蕉"):删掉香蕉;
- s.discard("西瓜"):西瓜根本不在,但不报错,安静地跳过。

注意两个删除方法的区别:

s = {"苹果"}
s.remove("西瓜")     # ❌ 报错:KeyError: '西瓜'
s.discard("西瓜")    # ✅ 什么都不发生

🐍"皮皮注:discard 是集合独有的温柔,像个不记仇的朋友。要'删不存在的也不崩',选 discard;要'严格提醒',选 remove。"


12.6 综合实战:统计文章里有哪些单词

用集合和列表,统计一段话里"一共用了多少个不同的词":

text = "the quick brown fox jumps over the lazy dog the fox"
words = text.split()        # 拆成单词列表
print("总词数:", len(words))

unique_words = set(words)   # 集合去重
print("不同单词数:", len(unique_words))
print("出现的单词:", unique_words)

运行结果:

总词数: 12
不同单词数: 8
出现的单词: {'quick', 'the', 'fox', 'over', 'dog', 'brown', 'lazy', 'jumps'}

逐行拆解:
- text.split():第 5 章学过,把句子按空格拆成单词列表;
- len(words):总共 12 个词(包括重复的);
- set(words):转成集合,重复的 the、fox 自动合并;
- len(unique_words):去重后剩 8 个不同的词;
- 最后把出现的单词都打印出来(顺序随机)。

"总词数"和"不同单词数"的区别,就是"说了几句话"和"一共用了哪些词"的区别。这个能力在做文本分析(比如统计词频)时是地基。

换例加深:找出两段话共有的单词:

text_a = "python is fun but sometimes hard"
text_b = "hard work is the key to python"

common = set(text_a.split()) & set(text_b.split())
print("两段话共有的词:", common)   # {'python', 'is', 'hard'}

集合的交集运算 + 拆词,两段文字"找出共同点"三行搞定。

配套代码文件:code/ch12/word_set.py。


【皮皮小课堂】本章要点


【翻车现场】本章的坑

坑 1:空花括号 {} 是字典,不是空集合

s = {}          # ❌ 这是空字典!
s.add(1)        # 报错:AttributeError:'dict' object has no attribute 'add'

空集合必须用 set():

s = set()       # ✅ 真正的空集合

记忆:{} 是字典专属的表情,集合看到花括号想用,得先有内容。 想要"空的花括号容器",字典(第 13 章)才是正主。

坑 2:想改元组 → 报错

t = (1, 2, 3)
t[0] = 99       # ❌ TypeError:'tuple' object does not support item assignment

元组不能改。真想改,先转成列表:list(t) 改完再转回 tuple(...):

t = (1, 2, 3)
lst = list(t)      # [1, 2, 3]
lst[0] = 99
t = tuple(lst)     # (99, 2, 3)

坑 3:给集合用下标

s = {"苹果", "香蕉"}
print(s[0])     # ❌ TypeError:'set' object is not subscriptable

集合没有顺序,没有"第 0 个"。想按顺序取,先转成列表 list(s)[0](但顺序也不保证)。

坑 4:集合去重只去"完全相同"的

"Python" 和 "python" 是不同的字符串,集合认为它们是两个不同的东西。想忽略大小写去重,先 lower() 再放进去:

words = ["Python", "python", "PYTHON"]
unique = set(w.lower() for w in words)   # {'python'}

(这里用了推导式,第 14 章正式学,先感受一下。)

坑 5:单元素元组忘写逗号

t = (5)        # ❌ 这不是元组,是整数 5!
print(type(t)) # <class 'int'>

t = (5,)       # ✅ 加个逗号才是元组
print(type(t)) # <class 'tuple'>

只有一个元素的元组,必须带逗号 (5,)。 不带逗号的 (5) 只是"圆括号包了个数字",Python 不认它是元组。

坑 6:拆包数量不匹配

point = (3, 5, 7)
x, y = point    # ❌ 报错:ValueError: too many values to unpack

左边变量数 ≠ 右边元组元素数,报错。要么写全 x, y, z = point,要么用 *rest 接住多余部分:

x, y, *rest = point   # x=3, y=5, rest=[7]

【本章习题】

一、选择题

1. (★) 运行 print(len(set([1, 2, 2, 3, 3, 3]))) 的结果是?

2. (★★) {1, 2, 3} & {2, 3, 4} 的结果是?

3. (★★) 下列哪个操作会报错?

4. (★★ 多选) 关于元组和集合,下列说法正确的是?

5. (★★ 多选) 关于拆包和集合运算,下列说法正确的是?

二、判断题

1. (★) (1, 2) == (1, 2) 的结果是 True。( )

2. (★★) 集合 {"a", "b"} 和 {"b", "a"} 是相等的。( )

3. (★★) a, b = b, a 可以交换两个变量的值。( )

4. (★★) t = (5) 创建了一个只含元素 5 的元组。( )

三、代码纠错题

1. (★★) 下面代码想创建一个空集合,但运行时 add 报错,请改正:

s = {}
s.add("皮皮")

2. (★★) 下面代码想给元组换一个元素,但报错,请指出正确的改法:

t = (1, 2, 3)
t[1] = 99

四、编程实战题

1. (基础 ★) 用一行代码,把列表 [1, 1, 2, 2, 3, 3, 3] 去重,输出去重后的结果。

2. (基础 ★★) 有甲乙两份名单(列表),请分别输出:同时出现在两份名单的人、只出现在甲名单的人。用集合运算实现。

3. (基础 ★★) 读入一行单词(空格分隔),输出:总共有几个单词、其中不同的单词有几个、这些不同的单词是什么。

4. (挑战 ★★★) 写程序统计下面这段文字里不同的汉字(忽略标点、数字、空格)有多少个:

皮皮爱吃冰糖葫芦,小美爱吃烧烤,阿强说烧烤才是最好吃的。

提示:先去掉标点(用 replace),拆成字符,再用集合去重,数长度。



【参考答案与解析】

一、选择题

1. 答案:A
set([1,2,2,3,3,3]) 去重后是 {1, 2, 3},长度 3。

2. 答案:B
& 是交集,取两边都有的:{2, 3}。

3. 答案:B
元组不可变,t[0] = 99 会报 TypeError。其他都是合法操作。

4. 答案:A、B、D
A 对:元组不可变;B 对:集合自动去重;C 错:{} 是空字典,空集合要写 set();D 对:集合无序。

5. 答案:A、B、C
A 对:拆包交换;B 对:| 是并集,去重合并得 {1, 2, 3};C 对:- 是差集,{1, 2} 去掉 {2, 3} 里有的(2),剩 {1};D 错:discard 不存在不报错,remove 才会。

二、判断题

1. 正确(√)。元组可以比较相等,内容相同就相等。

2. 正确(√)。集合无序,顺序不影响相等性,{"a","b"} 和 {"b","a"} 是同一个集合。

3. 正确(√)。元组拆包让交换一行搞定。

4. 错误(×)。t = (5) 是整数 5,不是元组。单元素元组必须带逗号 (5,)。

三、代码纠错题

1. 解析: {} 是空字典,没有 add 方法。空集合要用 set():

s = set()
s.add("皮皮")

2. 解析: 元组不可变,不能直接改元素。正确做法是先转列表、改完再转回:

t = (1, 2, 3)
lst = list(t)     # [1, 2, 3]
lst[1] = 99
t = tuple(lst)    # (1, 99, 3)

四、编程实战题

1. 参考代码:

nums = [1, 1, 2, 2, 3, 3, 3]
unique = list(set(nums))
print(unique)     # [1, 2, 3](顺序可能不同)

2. 参考代码:

team_a = ["皮皮", "小美", "阿强", "小明"]
team_b = ["小美", "小明", "阿红"]

a_set = set(team_a)
b_set = set(team_b)

print("两边都有:", a_set & b_set)     # {'小明', '小美'}
print("只在甲名单:", a_set - b_set)   # {'皮皮', '阿强'}

3. 参考代码:

line = input("请输入一行单词(空格分隔):")
words = line.split()

unique_words = set(words)

print(f"总单词数: {len(words)}")
print(f"不同单词数: {len(unique_words)}")
print(f"不同的单词: {unique_words}")

4. 参考代码:

text = "皮皮爱吃冰糖葫芦,小美爱吃烧烤,阿强说烧烤才是最好吃的。"

# 去掉标点
text = text.replace(",", "").replace("。", "")

# 拆成一个个字符,集合去重
chars = set(text)

# 去掉空格
chars.discard(" ")

print("不同的汉字有:", len(chars))
print("它们分别是:", sorted(chars))

🐍"皮皮注:注意我们处理了逗号、句号,但没处理'冰糖葫芦'这种多个字的词——这里我们只按'单个字'统计。如果想按'词语'统计,就复杂了(涉及分词),那是以后爬虫和文本分析的功课。"


📖 下一章,终极容器登场——字典,那个用"钥匙"开"柜子"的前台登记表。

📦 本章配套代码

运行方式:命令行进入目录后执行 py 文件名.py(Windows)或 python3 文件名.py(Mac/Linux)