介绍 Python 中的 tuple（元组）

_oP_i

578人浏览 · 2025-10-14 15:07:33

_oP_i · 2025-10-14 15:07:33 发布

什么是元组？

元组是 Python 中一种核心的内置数据结构，用于存储有序的、不可变的元素集合。

你可以把它理解为一个 “不可变的列表”。

核心特性

有序性：元素按照定义的顺序进行存储和访问。
不可变性：一旦创建，元组的内容（它包含的元素引用）不能被修改、添加或删除。
异构性：可以包含任意类型、任意组合的对象（整数、字符串、列表，甚至其他元组等）。
允许重复：元组中可以包含重复的元素。

如何创建元组？

创建元组主要有两种方式：

1. 使用圆括号 ()（最常见）

# 空元组
empty_tuple = ()
print(empty_tuple)  # 输出: ()

# 包含一个元素的元组 (注意：必须加逗号！)
single_tuple = (42,)  # 如果没有逗号，(42) 只是一个整数 42
print(single_tuple)   # 输出: (42,)

# 包含多个元素的元组
fruits = ("apple", "banana", "cherry")
numbers = (1, 2, 3, 4, 5)
mixed = ("hello", 42, 3.14, True, [1, 2, 3])

2. 使用 tuple() 构造函数

# 从列表创建
my_list = [1, 2, 3]
my_tuple = tuple(my_list)
print(my_tuple)  # 输出: (1, 2, 3)

# 从字符串创建 (会将字符串拆分为单个字符)
my_tuple = tuple("hello")
print(my_tuple)  # 输出: ('h', 'e', 'l', 'l', 'o')

# 从可迭代对象创建
my_tuple = tuple(range(5))
print(my_tuple)  # 输出: (0, 1, 2, 3, 4)

访问元组元素

访问方式与列表完全相同，使用索引和切片。

my_tuple = ("a", "b", "c", "d", "e")

# 正向索引 (从0开始)
print(my_tuple[0])   # 输出: 'a'
print(my_tuple[2])   # 输出: 'c'

# 负向索引 (从-1开始，表示倒数第一个)
print(my_tuple[-1])  # 输出: 'e'
print(my_tuple[-2])  # 输出: 'd'

# 切片 [start:end:step]
print(my_tuple[1:4])    # 输出: ('b', 'c', 'd')
print(my_tuple[::2])    # 输出: ('a', 'c', 'e') 每隔一个取一个
print(my_tuple[::-1])   # 输出: ('e', 'd', 'c', 'b', 'a') 反转元组

元组的不可变性

这是元组与列表最根本的区别。你不能修改元组本身。

my_tuple = (1, 2, 3)

# 尝试修改会抛出 TypeError
my_tuple[0] = 100  # TypeError: 'tuple' object does not support item assignment

# 尝试添加元素也会失败
my_tuple.append(4)  # AttributeError: 'tuple' object has no attribute 'append'

# 尝试删除元素也会失败
del my_tuple[1]     # TypeError: 'tuple' object doesn't support item deletion

但是请注意：不可变性是 “浅层的”。如果元组中包含可变对象（如列表），那么这个可变对象本身是可以被修改的。

my_tuple = (1, 2, [3, 4])
print(my_tuple)  # 输出: (1, 2, [3, 4])

# 你不能修改元组本身，但可以修改元组中的列表
my_tuple[2][0] = "changed"  # 这是允许的！
print(my_tuple)  # 输出: (1, 2, ['changed', 4])

元组的操作和方法

由于不可变性，元组的方法比列表少得多。

1. 基本操作

tuple1 = (1, 2, 3)
tuple2 = (4, 5)

# 连接 +
combined = tuple1 + tuple2
print(combined)  # 输出: (1, 2, 3, 4, 5)

# 重复 *
repeated = tuple1 * 3
print(repeated)  # 输出: (1, 2, 3, 1, 2, 3, 1, 2, 3)

# 成员检测 in
print(2 in tuple1)  # 输出: True
print(6 in tuple1)  # 输出: False

2. 常用方法

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

# count(x) - 返回元素 x 在元组中出现的次数
print(my_tuple.count(2))  # 输出: 3

# index(x) - 返回元素 x 第一次出现的索引
print(my_tuple.index(3))  # 输出: 3

# 如果元素不存在，index() 会抛出 ValueError
# my_tuple.index(10)  # ValueError: tuple.index(x): x not in tuple

3. 内置函数

my_tuple = (5, 2, 8, 1, 9)

print(len(my_tuple))   # 输出: 5 (元素个数)
print(max(my_tuple))   # 输出: 9 (最大值)
print(min(my_tuple))   # 输出: 1 (最小值)
print(sum(my_tuple))   # 输出: 25 (求和)

# 排序 (返回一个新的列表)
sorted_tuple = sorted(my_tuple)
print(sorted_tuple)    # 输出: [1, 2, 5, 8, 9] (注意：返回的是列表！)

元组的解包

这是元组一个非常强大和常用的特性。

# 基本解包
person = ("Alice", 30, "Engineer")
name, age, job = person  # 元组解包
print(name)  # 输出: Alice
print(age)   # 输出: 30
print(job)   # 输出: Engineer

# 在函数返回多个值时特别有用
def get_user_info():
    return "Bob", 25, "bob@example.com"

name, age, email = get_user_info()  # 函数返回的是一个元组

# 使用 * 收集多余的元素
numbers = (1, 2, 3, 4, 5)
first, *middle, last = numbers
print(first)   # 输出: 1
print(middle)  # 输出: [2, 3, 4] (注意：被收集成列表)
print(last)    # 输出: 5

元组 vs 列表：如何选择？

特性	元组	列表
语法	圆括号 `()`	方括号 `[]`
可变性	不可变	可变
性能	通常更快，占用内存更少	稍慢，占用内存稍多
安全性	数据更安全，防止意外修改	数据可能被意外修改
用途	保证数据完整性，用作字典键	需要动态修改的数据集合
方法	较少 (`count`, `index`)	丰富 (`append`, `remove`, `sort`等)

选择指南：

使用元组当：
- 数据是固定的，不应该被改变（如配置常量、函数返回多个值）。
- 你需要将集合作为字典的键（因为字典键必须是不可变的）。
- 你希望数据不会被意外修改，保证程序的安全性。
- 追求性能优化（元组的创建和访问比列表稍快）。
使用列表当：
- 数据需要动态变化（添加、删除、修改元素）。
- 你需要使用丰富的方法来操作数据。