Python 编程B14：组合数据类型（二）

9.3 元组类型

元组（tuple）与列表非常相似，也是一种有序序列类型，但最大的不同在于：元组是不可变对象（immutable）。一旦创建，就不能修改其中的元素。元组的不可变特性使其特别适合用于记录版本、日志快照或模型原始参数等可追溯历史的应用。

9.3.1 元组的创建

元组可通过逗号 , 分隔各元素来创建，一般会加上圆括号 () 。也可以使用内置函数 tuple() 创建。

t1 = 1, 2, 3t2 = (1, 2, 3)t3 = tuple(["a", "b", "c"])    # 列表 → 元组t4 = ()                        # 空元组print(t1, t2, t3, t4)

若只包含一个元素，必须加逗号 , ，否则不会被识别为元组：

single = (5,)        # 正确not_tuple = (5)      # 实际为 intprint(type(single), type(not_tuple))

元组也支持嵌套结构：

nested = (1, (2, 3), 4)

9.3.2 元组的常用操作

元组与列表非常相似，也是一种有序序列类型，因此共享大多数序列操作。

（1）序列运算（拼接、重复与比较）

a = (1, 2)b = (3, 4)print(a + b)   # (1, 2, 3, 4)print(a * 2)   # (1, 2, 1, 2)
# 按元素顺序逐个比较print((1, 2) < (1, 3))       # Trueprint((1, 2, 3) > (1, 2))    # True

（2）序列通用操作（索引、切片、遍历与成员判断）

t = (10, 20, 30, 40)
# 索引print(t[0])         # 10print(t[-1])        # 40
# 切片print(t[1:3])       # (20, 30)# 通过切片组合生成新元组modified = t[:2] + t[3:]    # (10, 20, 40)
# 遍历for value in t:    print(value)
# 成员判断print(20 in t)      # Trueprint(50 not in t)  # True

（3）搭配内置函数与使用元组方法

t1 = (5, 2, 9, 1)print(len(t1))     # 4 获取元组的长度print(max(t1))     # 9 获取最大值print(min(t1))     # 1 获取最小值print(sum(t1))     # 17 求所有元素之和
print(sorted(t1))  # [1, 2, 5, 9] 排序，注意，sorted() 返回的是列表# 若需要元组，可使用 tuple(sorted(t1))
# enumerate() 返回的结果中每个元素是 (index, value) 形式的元组fruits = ("apple", "banana", "cherry")for i, fruit in enumerate(fruits):    print(i, fruit)
# zip() 可将两个序列打包成对names = ['艾婉婷', '鞠子舟', '岳露珊']scores = [95, 85, 98]zipped = list(zip(names, scores))    print(zipped)    # [('艾婉婷', 95), ('鞠子舟', 85), ('岳露珊', 98)]# 使用 * 运算符可以解包已 zip 的数据names, scores = zip(*zipped)    print(names)     # ('艾婉婷', '鞠子舟', '岳露珊')print(scores)      # (95, 85, 98)

# 元组类方法t2 = (1, 2, 3, 2, 4, 5)count = t2.count(2)       # 2 统计元素出现的次数position = t2.index(2)    # 1 返回某个元素在元组中第一次出现的索引print(t2.index(2, 2))     # 3 从索引 2 之后继续查找

（4）修改元组中的可变对象元素

虽然元组本身不可变，但若其内部包含可变对象（如列表），则内部数据仍然可以被修改。

t = (1, [2, 3])t[1][0] = 99print(t)    # (1, [99, 3])

说明：这并不违反元组不可变性，因为改变的是内部可变对象本身，而不是元组的绑定关系。

（5）元组在函数设计中的应用

元组常被用作函数的返回值，使函数可以一次性返回多个结果。

def calc_stats(numbers):    return min(numbers), max(numbers), sum(numbers) / len(numbers)
low, high, avg = calc_stats([10, 20, 30, 40])print(low, high, avg)   # 10 40 25.0

说明：Python 函数永远只返回一个对象。当写作 “return a, b” 时，实际上是返回一个元组。

在函数的实参中，可以使用 * 进行位置参数解包传参：

def add(x, y):    return x + y
args = (3, 5)print(add(*args))  # 等价于 add(3, 5)

在函数的形参中，可以使用 * 捕获可变位置参数。

def avg(*args):    # 形参 args 是一个元组    return sum(args) / len(args)
print(avg(1, 2, 3, 4))

9.3.3 元组示例与应用

例 9.3.1：AI 模型参数对比（权重冻结示例）

在深度学习模型微调（fine-tuning）过程中，通常会固定部分预训练参数，只更新其他层。元组可以用来保存“冻结参数”，防止被意外修改。

# 固定模型权重base_weights = (0.5, 0.8, 0.9)
def compare_weights(new_weights):    for i in range(len(base_weights)):        diff = new_weights[i] - base_weights[i]        print(f"参数{i+1}变化：{diff:+.2f}")
compare_weights((0.55, 0.75, 0.95))

说明：

元组的不可变特性可确保模型关键参数的安全性，在 AI 模型微调或版本管理中常用于记录原始权重。

例 9.3.2 坐标转换

以下示例可将多个坐标点进行平移和缩放变换。

def coordinate_transform(*points, scale=1.0, offset=(0, 0)):    transformed_points = []    for point in points:        if len(point) == 2:  # 2D点            x, y = point            new_x = (x + offset[0]) * scale            new_y = (y + offset[1]) * scale            transformed_points.append((new_x, new_y))
    # 返回变换后的所有点，可以解包接收    return tuple(transformed_points)
# 使用示例p1, p2, p3 = (1, 2), (3, 4), (5, 6)scaled_points = coordinate_transform(p1, p2, p3, scale=2.0, offset=(1, 1))print(f"变换后的点: {scaled_points}")

输出：

变换后的点: ((4.0, 6.0), (8.0, 10.0), (12.0, 14.0))

9.4 集合类型

集合（set）是一种无序、可变、不重复的序列类型。集合中的元素必须是可哈希，也就是说，不能包含列表或字典等可变类型。

集合常用于去重、成员判断以及数学意义上的集合运算（交集、并集、差集等）。

9.4.1 集合的创建

集合可通过花括号 {} 或内置函数 set() 创建。

空集合必须使用 set()，否则 {} 会被识别为字典。

s1 = {1, 2, 3, 4}s2 = set([2, 3, 5])print(s1, s2)
empty = set()print(type(empty))   # <class 'set'>

也可以通过推导式来创建集合。

squares = {x**2 for x in range(-3, 4)}print(squares)  # 如 -3 与 3 的平方相同，因此被自动去重。

要注意的是，集合的输出顺序不固定，每次运行可能不同。

9.4.2 集合运算

集合支持丰富的运算符，用于实现数学集合操作。

A = {1, 2, 3}B = {3, 4, 5}
print(A | B)   # 并集：{1, 2, 3, 4, 5}print(A & B)   # 交集：{3}print(A - B)   # 差集：{1, 2}print(A ^ B)   # 对称差集：{1, 2, 4, 5}

这些运算也可以使用对应的方法实现：

print(A.union(B))print(A.intersection(B))print(A.difference(B))print(A.symmetric_difference(B))

9.4.3 集合的常用操作

除了上述集合运算，集合也像其它可变序列那样，进行成员判断、遍历以及搭配内置函数使用等常用操作。不过，由于集合基于哈希表存储且无固定顺序，因此无法使用索引访问和切片。

还可通过集合方法进行增删元素、关系测试等操作。

（1）添加与删除元素

fruits = {"apple", "banana"}fruits.add("cherry")           # 添加单个元素fruits.update(["orange", "pear"])  # 批量添加（可迭代对象）print(fruits)
fruits.remove("banana")        # 删除指定元素，不存在时报错fruits.discard("grape")        # 删除元素，不存在时不报错fruits.clear()                 # 清空集合

（2）关系测试

A = {1, 2}B = {1, 2, 3}print(A <= B)   # True，子集判断print(B > A)    # True，超集判断print(A.isdisjoint({4, 5}))  # True，无交集

集合基于哈希表实现，成员判断、添加与删除的平均时间复杂度为 O(1)。

9.4.4 集合示例与应用

例 9.4.1：数据去重与统计

集合可快速实现去重操作。

下面的例子演示如何去除重复用户 ID，并计算唯一数量。

users = ["A12", "B09", "A12", "C33", "B09", "D20"]unique_users = set(users)print("唯一用户数：", len(unique_users))print("用户集合：", unique_users)

说明：集合的唯一性使其成为数据分析中“去重”的高效工具。

例 9.4.2：用户兴趣交集推荐

在推荐系统中，集合可用于快速求出不同用户的共同兴趣，从而生成个性化推荐内容。

user_A = {"AI", "Python", "Data"}user_B = {"AI", "Music", "Data"}
common = user_A & user_Bprint("共同兴趣：", common)

说明：通过集合运算可高效实现兴趣标签匹配，是社交推荐与内容推荐算法的核心逻辑之一。

📘 小结

本次课介绍了两种重要的组合数据类型：元组（tuple）与集合（set）。元组是有序且不可变的序列，适合存储固定结构或不应被修改的数据；集合则是无序且元素唯一的容器，常用于去重、集合运算与快速关系判断。

在下一课中，我们将学习映射类型——字典（dict），它通过“键–值（key–value）”的结构存储与访问数据，是 Python 最核心、最强大的数据类型之一。

“点赞有美意，赞赏是鼓励”