元组是 Python 中另一个重要的序列数据类型，与列表类似但不可变（immutable）。下面详细介绍元组的特性和使用方法。

一、元组的基本特性

1. 创建元组

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

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

# 多元素元组
numbers = (1, 2, 3, 4, 5)
colors = ('red', 'green', 'blue')
mixed = (1, 'hello', 3.14, True)

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

2. 元组与列表的区别

二、元组的基本操作

1. 访问元素

weekdays = ('Mon', 'Tue', 'Wed', 'Thu', 'Fri')

# 正索引访问
print(weekdays[0])   # 'Mon'
print(weekdays[2])   # 'Wed'

# 负索引访问
print(weekdays[-1])  # 'Fri'
print(weekdays[-3])  # 'Wed'

# 切片操作
print(weekdays[1:4])   # ('Tue', 'Wed', 'Thu')
print(weekdays[:3])    # ('Mon', 'Tue', 'Wed')
print(weekdays[::2])   # ('Mon', 'Wed', 'Fri') (步长为2)

2. 元组解包（Unpacking）

# 基本解包
point = (10, 20)
x, y = point
print(x, y)  # 10 20

# 交换变量值
a, b = 1, 2
a, b = b, a  # 交换后 a=2, b=1

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

3. 元组方法（有限的几个）

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

# count() - 统计元素出现次数
print(t.count(2))  # 3

# index() - 返回元素第一次出现的索引
print(t.index(3))  # 2

三、元组的高级用法

1. 作为字典的键

# 列表不能作为字典键（因为可变）
# 但元组可以（只要它包含的所有元素都是不可变的）

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

print(locations[(35.6895, 139.6917)])  # "Tokyo"

2. 函数返回多个值

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

data = [10, 20, 30, 40]
stats = get_stats(data)  # (10, 40, 25.0)
min_val, max_val, avg_val = get_stats(data)

3. 命名元组（NamedTuple）

from collections import namedtuple

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

# 创建命名元组实例
p = Point(10, y=20)

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

四、元组的不可变性

1. 不可变性的含义

t = (1, 2, 3)

# 以下操作会引发TypeError
try:
    t[0] = 10  # 不能修改元素
except TypeError as e:
    print(e)  # "'tuple' object does not support item assignment"

try:
    t.append(4)  # 没有append方法
except AttributeError as e:
    print(e)  # "'tuple' object has no attribute 'append'"

2. "可变"元组的特殊情况

# 元组可以包含可变对象
mixed_tuple = (1, [2, 3], 4)

# 可以修改元组中的可变元素
mixed_tuple[1].append(5)  # 合法
print(mixed_tuple)  # (1, [2, 3, 5], 4)

# 但不能替换整个元素
try:
    mixed_tuple[1] = [7, 8]  # 非法
except TypeError:
    print("不能修改元组元素")

五、元组的性能优势

1. 创建速度更快

%timeit [1, 2, 3, 4, 5]   # 约 100 ns
%timeit (1, 2, 3, 4, 5)   # 约 15 ns (快6-7倍)

2. 占用内存更少

import sys
sys.getsizeof([1, 2, 3, 4, 5])  # 120 bytes (64位Python)
sys.getsizeof((1, 2, 3, 4, 5))  # 80 bytes (节省33%)

3. 字典键查找更快

%timeit d[(1,2)]  # 比d[[1,2]]快（如果列表能作键的话）

六、实际应用场景

1. 保护数据不被修改

CONSTANTS = (3.14, 2.718, 1.618)  # 定义常量

2. 线程安全的数据传递

# 在多线程环境中，不可变对象更安全

3. 数据库查询结果

# 通常数据库API返回元组形式的记录

4. 函数参数传递

def process_data(*args):  # 收集任意数量的位置参数为元组
    print(type(args))  # <class 'tuple'>

七、元组与列表的转换

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

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

元组是 Python 中一个简单但强大的数据结构，特别适合用于保证数据不被意外修改的场景。虽然它的方法比列表少，但在许多情况下，它的不可变性反而成为优势。