元组基础

Python 中的元组（tuple）本质是不可变的有序序列，使用圆括号 () 定义。元组的声明和初始化可以通过以下方式实现：

tuple1 = ("Hello",)  # 单元素元组需要逗号
tuple2 = (1, 2, 3, 4, 5)  # 多元素元组
tuple3 = 10, 20, 30  # 括号可省略
tuple4 = ()  # 空元组

元组解包与多重赋值

使用元组可以方便地进行变量解包和多重赋值操作：

# 元组解包
coordinates = (10, 20)
x, y = coordinates
print(f"x = {x}, y = {y}")

# 多重赋值
a, b = 5, 10
print(f"a = {a}, b = {b}")

# 使用 * 收集剩余元素
first, *rest = (1, 2, 3, 4, 5)
print(f"first = {first}, rest = {rest}")

常用元组操作

Python 内置了丰富的元组处理方法和函数：

tuple1 = (1, 2, 3, 4, 5)
tuple2 = ("a", "b", "c")

# 元组连接
combined = tuple1 + tuple2
print(f"combined: {combined}")

# 元组重复
repeated = tuple1 * 2
print(f"repeated: {repeated}")

# 元组长度
print(f"Length of tuple1: {len(tuple1)}")

# 元素计数
numbers = (1, 2, 2, 3, 2, 4)
print(f"Count of 2: {numbers.count(2)}")

# 元素索引
print(f"Index of 3: {numbers.index(3)}")

# 成员判断
if 3 in tuple1:
    print("3 is in tuple1")
else:
    print("3 is not in tuple1")

元组与列表

元组与列表密切相关，但元组是不可变的，列表是可变的：

# 元组不可变特性
my_tuple = (1, 2, 3)
# my_tuple[0] = 10  # 这会引发 TypeError

# 列表可变特性
my_list = [1, 2, 3]
my_list[0] 10  # 合法操作

# 元组转列表
list_from_tuple = list(my_tuple)
print(f"List from tuple: {list_from_tuple}")

# 列表转元组
tuple_from_list = tuple(my_list)
print(f"Tuple from list: {tuple_from_list}")

嵌套元组

处理复杂数据时可以使用嵌套元组：

# 嵌套元组
nested = ((1, 2), (3, 4), (5, 6))

# 遍历嵌套元组
for item in nested:
    print(f"Item: {item}")

# 访问嵌套元素
print(f"nested[0][1] = {nested[0][1]}")

# 元组中包含列表（列表内容可变）
mixed = (1, [2, 3], 4)
mixed[1].append(5)  # 合法：修改的是列表，不是元组
print(f"Mixed after append: {mixed}")

元组切片操作

元组切片是一个常见操作，可以使用索引实现：

numbers = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

# 基本切片
print(f"numbers[2:5] = {numbers[2:5]}")

# 步长切片
print(f"numbers[::2] = {numbers[::2]}")

# 反向切片
print(f"numbers[::-1] = {numbers[::-1]}")

# 负索引
print(f"numbers[-3:] = {numbers[-3:]}")

命名元组

为增强代码可读性，推荐使用命名元组（namedtuple）：

from collections import namedtuple

# 定义命名元组
Point = namedtuple('Point', ['x', 'y'])
Person = namedtuple('Person', 'name age city')

# 创建实例
p = Point(10, 20)
person = Person('Alice', 30, 'Beijing')

# 通过名称访问
print(f"Point: x={p.x}, y={p.y}")
print(f"Person: {person.name}, {person.age}岁, 来自{person.city}")

# 不可变性
# person.age = 31  # 这会引发 AttributeError

自定义元组函数

实现自定义的元组处理函数可以加深对元组的理解：

def tuple_sum(t):
    """计算元组中所有数字的和"""
    total = 0
    for num in t:
        total += num
    return total

def find_max(t):
    """查找元组中的最大值"""
    if not t:
        return None
    maximum = t[0]
    for item in t[1:]:
        if item > maximum:
            maximum = item
    return maximum

# 测试
test = (3, 1, 4, 1, 5, 9, 2, 6)
print(f"Sum: {tuple_sum(test)}")
print(f"Max: {find_max(test)}")

性能注意事项

元组操作在 Python 中需要特别注意性能和适用场景：

• 元组比列表更轻量，迭代速度更快
• 不可变性使元组可作为字典的键和集合的元素
• 函数返回多个值时优先使用元组
• 大量数据固定不变时，使用元组可节省内存

以上代码示例涵盖了 Python 元组的主要概念和操作，从基础用法到高级技巧，为开发者提供了全面的参考。