Python入门（2-2）：元组

# 空元组
t1 = ()
t2 = tuple()

# 单元素元组（注意逗号）
t3 = (42,)  # 必须加逗号
t4 = 42,    # 括号可选，逗号必需

# 多元素元组
t5 = (1, 2, 3)
t6 = 1, 2, 3  # 括号可选
t7 = tuple([1, 2, 3])  # 从可迭代对象创建

# 元组解包
a, b, c = (1, 2, 3)  # a=1, b=2, c=3

元组特性

不可变性：创建后不能修改
有序性：元素保持插入顺序
异构性：可以包含不同类型的元素
可哈希性：可作为字典的键（当所有元素都可哈希时）

2.2 元组操作

访问元素

t = ('a', 'b', 'c', 'd', 'e')

# 索引访问
print(t[0])   # 'a'
print(t[-1])  # 'e'（负索引从末尾开始）

# 切片操作
print(t[1:3])  # ('b', 'c')
print(t[::2])  # ('a', 'c', 'e')（步长2）

元组拼接

t1 = (1, 2)
t2 = (3, 4)
combined = t1 + t2  # (1, 2, 3, 4)

重复元组

t = ('a', 'b')
repeated = t * 3  # ('a', 'b', 'a', 'b', 'a', 'b')

比较元组

# 按元素顺序比较
(1, 2) < (1, 3)  # True
(1, 2, 3) < (1, 2)  # False（前者更长）

zip函数与元组

names = ['Alice', 'Bob']
scores = [85, 92]
paired = list(zip(names, scores))  # [('Alice', 85), ('Bob', 92)]

2.3 元组的方法

由于不可变性，元组只有两个内置方法：

1 count

功能：返回元素来元组中出现的次数

参数：1个。

element：待计数的元素

返回值：一个整数。其值为待计数元素的个数

2 index

功能：返回元素第一次出现的索引

参数：1个。

element：待查找的元素

返回值：一个整数。其值为待查找元素的索引下标

2.4 元组和列表对比

特性	元组	列表
可变性	不可变	可变
语法	圆括号（可选）	方括号
性能	更快（创建和访问）	稍慢
内存	更节省内存	占用更多内存
用途	固定数据、字典键	动态数据
方法	只有count()和index()	多种方法

2.5 元组解包

基本解包

point = (10, 20)
x, y = point  # x=10, y=20

扩展解包（Python 3+）

values = (1, 2, 3, 4, 5)
a, b, *rest = values  # a=1, b=2, rest=[3,4,5]
first, *middle, last = values  # first=1, middle=[2,3,4], last=5

函数返回多值

def get_stats(numbers):
    return min(numbers), max(numbers), len(numbers)

minimum, maximum, length = get_stats([1, 2, 3])

2.6 元组与不可变性

不可变性的含义

元组一旦创建，不能添加、删除或修改元素
但若元素本身是可变对象（如列表），其内容可修改

t = (1, [2, 3], 4)
t[1].append(5)  # 合法：t变为 (1, [2, 3, 5], 4)
# t[0] = 10     # 非法：TypeError

不可变性的优势

线程安全
可哈希（可作为字典键）
保护数据不被意外修改
性能优化（Python 会缓存小元组）

2.7 元组推导式

Python 没有真正的"元组推导式"，但可以使用生成器表达式：

# 生成器表达式转元组
t = tuple(x**2 for x in range(5))  # (0, 1, 4, 9, 16)

# 类似列表推导式语法（实际是生成器表达式）
t = (x for x in range(5))  # 这是一个生成器对象，不是元组

2.8 实际应用场景

1. 函数返回多个值（返回值用逗号隔开，返回的是一个元组）

def get_user_info(user_id):
    # 从数据库获取数据
    return name, age, email  # 作为元组返回

2. 字典键

locations = {
    (35.6895, 139.6917): "Tokyo",
    (40.7128, -74.0060): "New York"
}

3. 格式化字符串

person = ('Alice', 25)
print("%s is %d years old" % person)  # 旧式格式化
print(f"{person[0]} is {person[1]} years old")  # f-string

4. 数据保护

def process_data(data):
    # 确保输入数据不被修改
    data = tuple(data)
    # 处理数据...

3 元组使用常见问题与解决方案

问题1：修改元组

t = (1, 2, 3)
# t[0] = 10  # 错误

# 解决方案：创建新元组
t = (10,) + t[1:]

问题2：单元素元组

not_a_tuple = (42)    # 这是一个整数
is_a_tuple = (42,)    # 这才是单元素元组

问题3：性能误区

# 频繁拼接元组效率低（每次拼接都创建新对象）
t = ()
for i in range(1000):
    t += (i,)  # 低效

# 更高效的做法
items = []
for i in range(1000):
    items.append(i)
t = tuple(items)

4 元组内部实现原理

Python 的元组实现特点：

固定大小的数组存储元素
小整数范围内的元组会被缓存（如 (1,2,3) 可能被复用）
比列表少一个过度分配的机制（因为不可变）

5 元组与函数式编程

元组常用于函数式编程模式：

# 不可变数据结构
point = (2, 3)
moved_point = (point[0]+1, point[1]+2)  # (3, 5)

# 高阶函数中使用
coordinates = [(1,2), (3,4), (5,6)]
sum_x = sum(x for x, y in coordinates)