Python 元组

Python 元组(Tuple) 全面指南

元组(Tuple)是Python中不可变的有序序列，与列表(List)相似但不可修改。元组用圆括号()表示，是Python中的基本数据结构之一。

1. 元组创建

# 空元组
empty_tuple = ()
empty_tuple = tuple()

# 单元素元组 (注意必须有逗号)
single_item = (42,)  # 正确
not_a_tuple = (42)   # 这不是元组，是整数

# 多元素元组
numbers = (1, 2, 3, 4, 5)
mixed = (1, "hello", 3.14, True)  # 可以包含不同类型
nested = ((1, 2), (3, 4))       # 嵌套元组

# 从其他序列创建
tuple_from_list = tuple([1, 2, 3])  # (1, 2, 3)
tuple_from_str = tuple("Python")    # ('P', 'y', 't', 'h', 'o', 'n')

2. 元组基本操作

访问元素

colors = ('red', 'green', 'blue')
print(colors[0])   # 'red' (正向索引，从0开始)
print(colors[-1])  # 'blue' (负向索引，-1表示最后一个)

切片操作

numbers = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
print(numbers[2:5])    # (2, 3, 4) (索引2到4)
print(numbers[:3])     # (0, 1, 2) (开始到索引2)
print(numbers[6:])     # (6, 7, 8, 9) (索引6到末尾)
print(numbers[::2])    # (0, 2, 4, 6, 8) (步长为2)
print(numbers[::-1])   # (9, 8, 7, 6, 5, 4, 3, 2, 1, 0) (反转元组)

元组拆包

point = (3, 4)
x, y = point  # 拆包赋值
print(x, y)   # 3 4

# 交换变量值
a, b = 1, 2
a, b = b, a   # 使用元组拆包交换
print(a, b)   # 2 1

# 使用*收集剩余元素
first, *middle, last = (1, 2, 3, 4, 5)
print(first)   # 1
print(middle)  # [2, 3, 4] (注意变成列表)
print(last)    # 5

3. 元组不可变性

元组一旦创建不能修改，尝试修改会引发TypeError：

colors = ('red', 'green', 'blue')
# colors[1] = 'yellow'  # TypeError: 'tuple' object does not support item assignment

但可以包含可变对象（如列表），这些对象自身可以修改：

mixed = (1, [2, 3], 4)
mixed[1].append(5)  # 可以修改元组中的列表
print(mixed)        # (1, [2, 3, 5], 4)

4. 元组常用方法

由于元组不可变，方法比列表少：

count() - 统计元素出现次数

numbers = (1, 2, 3, 2, 4, 2)
print(numbers.count(2))  # 3

index() - 查找元素索引

print(numbers.index(3))  # 2 (返回第一个匹配项的索引)
# print(numbers.index(5))  # ValueError (元素不存在)

5. 元组与列表比较

特性	元组(Tuple)	列表(List)
可变性	不可变	可变
语法	`()`	`[]`
性能	更快（创建和访问）	稍慢
方法	只有count()和index()	多种方法
用途	固定数据、字典键	动态数据集合

6. 元组优势与应用场景

优势

性能更好：创建和访问比列表快
数据安全：不可变性防止意外修改
可哈希：可作为字典键或集合元素

适用场景

存储不应修改的数据（如配置、常量）
函数返回多个值（实际上是返回元组）
作为字典的键（因为不可变）
保证数据完整性（线程安全）

7. 实际应用示例

函数返回多个值

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

data = [10, 20, 30, 40]
min_val, max_val, avg_val = get_stats(data)
print(f"Min: {min_val}, Max: {max_val}, Avg: {avg_val}")

字典中的键

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

格式化字符串

person = ("Alice", 25, "Engineer")
print("%s is %d years old, working as %s" % person)
# Alice is 25 years old, working as Engineer

8. 元组与列表转换

# 列表转元组
lst = [1, 2, 3]
tup = tuple(lst)  # (1, 2, 3)

# 元组转列表
tup = ('a', 'b', 'c')
lst = list(tup)   # ['a', 'b', 'c']

9. 命名元组（collections.namedtuple）

from collections import namedtuple

# 创建命名元组类型
Point = namedtuple('Point', ['x', 'y'])

# 实例化
p = Point(11, y=22)

# 访问字段
print(p.x)        # 11
print(p[0])       # 11 (仍支持索引)
print(p._asdict()) # {'x': 11, 'y': 22}

10. 常见错误

忘记单元素元组的逗号

not_a_tuple = (42)    # 这是整数
is_a_tuple = (42,)    # 这才是元组

尝试修改元组
```
t = (1, 2, 3)
# t[1] = 5  # TypeError
```

混淆可变元素

t = (1, [2, 3])
t[1].append(4)  # 可以，因为修改的是列表
# t[1] = [5, 6]  # 不可以，因为尝试修改元组

总结

Python元组是不可变的有序序列，具有以下特点：

不可变性：创建后不能修改（安全、可哈希）
有序性：元素保持插入顺序
异构性：可以包含不同类型的元素
轻量级：比列表更高效

元组适合存储不应修改的数据集合，特别是需要作为字典键或保证数据完整性的场景。命名元组(collections.namedtuple)提供了更友好的字段访问方式。