元组（Tuple）是 Python 中一种基础且重要的不可变序列类型，用于存储有序、可重复的元素集合。它与列表（List）功能相似，但核心区别在于不可变性，这使得元组在数据安全、性能优化和特定场景（如字典键、集合元素）中具有独特价值。
一、元组的基本定义与创建
1. 核心特性
- 不可变性：创建后无法修改、添加或删除元素（元素本身若为可变对象，其内部内容可改）。
- 有序性：元素按插入顺序排列，支持索引和切片操作。
- 元素多样性：可存储不同类型的元素（数字、字符串、列表、元组等）。
- 可重复性：允许包含重复元素。
2. 创建方式
（1）使用圆括号 () 直接创建
# 普通元组
t1 = (1, 2, 3)
t2 = ("a", 100, True, [4, 5]) # 混合类型，包含可变元素列表
# 单元素元组（必须加逗号，否则会被解析为对应类型）
t3 = (5,) # 正确：元组类型
t4 = (5) # 错误：int 类型
# 空元组
t5 = () # 方式1：空括号
t6 = tuple() # 方式2：使用 tuple() 函数
（2）使用 tuple() 函数创建
可将可迭代对象（列表、字符串、字典等）转换为元组：
# 列表转元组
list1 = [1, 2, 3]
t7 = tuple(list1) # 结果：(1, 2, 3)
# 字符串转元组（每个字符作为元素）
str1 = "hello"
t8 = tuple(str1) # 结果：('h', 'e', 'l', 'l', 'o')
# 字典转元组（仅取键）
dict1 = {"name": "Alice", "age": 20}
t9 = tuple(dict1) # 结果：('name', 'age')
（3）省略括号创建（简化写法）
当上下文明确时，可省略圆括号：
t10 = 10, 20, 30 # 结果：(10, 20, 30)
a, b, c = 1, 2, 3 # 元组解包（本质是创建元组后拆分）
二、元组的核心操作
1. 访问元素
（1）索引访问
通过正索引（从 0 开始）或负索引（从 -1 开始，表示倒数第 n 个元素）访问单个元素：
t = (10, 20, 30, 40)
print(t[0]) # 结果：10（正索引）
print(t[-2]) # 结果：30（负索引）
（2）切片访问
通过 [start:end:step] 截取元组的子序列（左闭右开，步长默认为 1），返回新元组：
t = (1, 2, 3, 4, 5)
print(t[1:4]) # 结果：(2, 3, 4)（从索引1到3）
print(t[:3]) # 结果：(1, 2, 3)（从开头到索引2）
print(t[2:]) # 结果：(3, 4, 5)（从索引2到结尾）
print(t[::2]) # 结果：(1, 3, 5)（步长2，隔一个取一个）
print(t[::-1]) # 结果：(5, 4, 3, 2, 1)（步长-1，反转元组）
2. 元素操作限制
由于元组不可变，以下修改操作会报错：
t = (1, 2, 3)
t[0] = 100 # 报错：TypeError: 'tuple' object does not support item assignment
t.append(4) # 报错：AttributeError: 'tuple' object has no attribute 'append'
del t[1] # 报错：TypeError: 'tuple' object doesn't support item deletion
注意：若元组包含可变元素（如列表），可变元素的内部内容可修改：
t = (1, [2, 3], 4)
t[1].append(5) # 合法：修改列表内部内容
print(t) # 结果：(1, [2, 3, 5], 4)
3. 元组的常用方法
元组的方法较少（因不可变），核心方法如下：
| 方法 | 功能描述 |
|---|---|
count(value) |
返回元素 value 在元组中出现的次数。 |
index(value) |
返回元素 value 在元组中首次出现的索引，若元素不存在则报错。 |
示例：
t = (1, 2, 2, 3, 2)
print(t.count(2)) # 结果：3（元素2出现3次）
print(t.index(3)) # 结果：3（元素3首次出现的索引）
# print(t.index(4)) # 报错：ValueError: tuple.index(x): x not in tuple
4. 内置函数操作元组
| 函数 | 功能描述 |
|---|---|
len(tuple) |
返回元组的长度（元素个数）。 |
max(tuple) |
返回元组中的最大值（元素需支持比较）。 |
min(tuple) |
返回元组中的最小值（元素需支持比较）。 |
sum(tuple) |
返回元组中所有数字元素的和（元素需为数字类型）。 |
sorted(tuple) |
对元组元素排序，返回新列表（元组本身不变）。 |
示例：
t = (5, 2, 8, 1)
print(len(t)) # 结果：4
print(max(t)) # 结果：8
print(min(t)) # 结果：1
print(sum(t)) # 结果：16
print(sorted(t)) # 结果：[1, 2, 5, 8]（返回列表）
5. 元组解包
将元组的元素拆分并赋值给多个变量，是元组的常用高级特性：
# 基础解包
t = (10, 20, 30)
a, b, c = t
print(a, b, c) # 结果：10 20 30
# 忽略部分元素（用 _ 占位）
t = (1, 2, 3, 4)
a, _, c, _ = t
print(a, c) # 结果：1 3
# 可变长度解包（用 * 接收多个元素，返回列表）
t = (1, 2, 3, 4, 5)
a, *b, c = t
print(a) # 结果：1
print(b) # 结果：[2, 3, 4]（列表类型）
print(c) # 结果：5
6. 元组的拼接与重复
（1）拼接（+）
将两个或多个元组合并为新元组（原元组不变）：
t1 = (1, 2)
t2 = (3, 4)
t3 = t1 + t2
print(t3) # 结果：(1, 2, 3, 4)
（2）重复（*）
将元组元素重复指定次数，返回新元组：
t = (1, 2)
t_repeat = t * 3
print(t_repeat) # 结果：(1, 2, 1, 2, 1, 2)
7. 成员判断（in / not in）
判断元素是否存在于元组中：
t = (10, 20, 30)
print(20 in t) # 结果：True
print(40 not in t) # 结果：True
三、元组与列表的区别
| 特性 | 元组（Tuple） | 列表（List） |
|---|---|---|
| 语法标识 | 圆括号 ()（可省略） |
方括号 [] |
| 可变性 | 不可变（无法修改元素） | 可变（可添加、删除、修改元素） |
| 方法支持 | 仅支持 count()、index() 等少量方法 |
支持 append()、remove() 等大量方法 |
| 性能 | 读取速度快，占用内存少 | 读取速度较慢，占用内存多 |
| 适用场景 | 存储固定数据、字典键、函数返回多值 | 存储动态数据、需要频繁修改的场景 |
| 哈希性 | 可哈希（可作为字典键、集合元素） | 不可哈希（不能作为字典键、集合元素） |
示例：元组可作为字典键，列表不可：
# 元组作为字典键（合法）
dict1 = {(1, 2): "a", (3, 4): "b"}
print(dict1) # 结果：{(1, 2): 'a', (3, 4): 'b'}
# 列表作为字典键（报错）
# dict2 = {[1, 2]: "a"} # 报错：TypeError: unhashable type: 'list'
四、元组的应用场景
1. 存储固定不变的数据
当数据不需要修改时，用元组比列表更安全，避免误操作修改数据：
# 存储坐标（固定不变）
point = (100, 200)
# 存储配置信息（固定参数）
config = ("localhost", 8080, "utf-8")
2. 函数返回多值
Python 函数默认只能返回一个值，通过元组可间接返回多个值（本质是返回一个元组，自动解包）：
def get_user_info():
name = "Alice"
age = 20
gender = "female"
return name, age, gender # 本质返回元组 (name, age, gender)
user_name, user_age, user_gender = get_user_info()
print(user_name, user_age, user_gender) # 结果：Alice 20 female
3. 作为字典键或集合元素
由于元组可哈希，可用于字典的键或集合的元素，而列表不行：
# 元组作为集合元素
s = {(1, 2), (3, 4)}
print(s) # 结果：{(1, 2), (3, 4)}
# 元组作为字典键存储多维度数据
student_scores = {
("Class1", "Alice"): 95,
("Class1", "Bob"): 88
}
print(student_scores[("Class1", "Alice")]) # 结果：95
4. 优化性能
元组的内存占用比列表小，读取速度更快，适合存储大量固定数据：
# 列表与元组内存对比
import sys
list1 = [1, 2, 3, 4, 5]
tuple1 = (1, 2, 3, 4, 5)
print(sys.getsizeof(list1)) # 结果：约 104 字节
print(sys.getsizeof(tuple1)) # 结果：约 88 字节
五、注意事项
- 单元素元组的逗号不可省略：
(5)是 int 类型，(5,)才是元组类型。 - 元组的不可变性是 “表层” 的：若元素是可变对象（如列表、字典），其内部内容可修改，但元素本身的引用无法改变。
- 元组的拼接 / 重复会创建新元组：原元组不变，频繁拼接会产生大量临时对象，效率较低（如需频繁修改，建议用列表）。
- 元组的切片返回新元组：与列表切片类似，但结果是元组类型。
六、总结
元组是 Python 中高效、安全的序列类型，核心优势在于不可变性和哈希性。它适合存储固定数据、作为函数返回多值的载体、以及作为字典键 / 集合元素。在实际开发中，应根据数据是否需要修改来选择元组或列表：固定数据用元组，动态数据用列表。掌握元组的创建、访问、解包等操作，能提升代码的安全性和性能。