7.1 什么是元组？

元组（Tuple）是 Python 中另一种重要的有序集合，与列表类似，它也可以存储多个不同类型的元素。但元组与列表最大的区别在于：元组是不可变的（Immutable），即一旦创建，其元素就不能被修改、添加或删除。

元组就像一个 “密封的容器”，里面的元素在创建后就固定不变。这种特性使得元组在某些场景下比列表更安全、更高效，例如存储一组不希望被修改的数据（如坐标、日期等）。

7.2 元组的创建

元组使用圆括号（()）来表示，元素之间用逗号（,）分隔。创建元组的基本语法如下：

元组名 = (元素1, 元素2, 元素3, ...)

示例：

# 存储整数的元组

numbers = (1, 2, 3, 4, 5)

# 存储字符串的元组

fruits = ("apple", "banana", "orange")

# 存储不同数据类型的元组

mixed = (10, "hello", 3.14, True)

# 空元组（不包含任何元素）

empty_tuple = ()

# 元组中包含元组（嵌套元组）

nested = ((1, 2), (3, 4), (5, 6))

# 单个元素的元组（必须在元素后加逗号，否则会被视为普通变量）

single_element = (5,)

print(type(single_element)) # 输出：<class 'tuple'>

# 不加括号的元组（Python允许省略括号，但不推荐，易混淆）

without_parentheses = 1, 2, 3

print(type(without_parentheses)) # 输出：<class 'tuple'>

注意：创建只包含一个元素的元组时，必须在元素后面加上逗号（,），否则 Python 会将其视为该元素本身的数据类型，而不是元组。例如，(5)会被视为整数5，而(5,)才是元组。

7.3 访问元组元素

元组的元素访问方式与列表完全相同，可以通过正向索引或反向索引来访问元素。

7.3.1 正向索引

元组的正向索引从0开始，依次递增。

示例：

fruits = ("apple", "banana", "orange", "grape")

# 访问第一个元素（索引0）

print(fruits[0]) # 输出：apple

# 访问第三个元素（索引2）

print(fruits[2]) # 输出：orange

7.3.2 反向索引

元组的反向索引从-1开始，依次递减（-1表示最后一个元素，-2表示倒数第二个元素，以此类推）。

示例：

fruits = ("apple", "banana", "orange", "grape")

# 访问最后一个元素（反向索引-1）

print(fruits[-1]) # 输出：grape

# 访问倒数第三个元素（反向索引-3）

print(fruits[-3]) # 输出：banana

7.3.3 索引越界

与列表一样，如果使用的索引超出了元组的范围，会导致 “索引越界” 错误（IndexError）。

示例：

numbers = (1, 2, 3)

print(numbers[3]) # 会报错：IndexError: tuple index out of range

7.4 元组的切片

元组的切片操作与列表也完全相同，用于从元组中截取一部分元素，形成一个新的元组。切片的语法如下：

元组名[start:stop:step]

• start：起始索引（包含该索引对应的元素，可选，默认从 0 开始）。

• stop：结束索引（不包含该索引对应的元素，必须指定）。

• step：步长（可选，默认是 1，即每次取一个元素；步长为负数表示反向切片）。

示例：

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

# 截取索引1到4的元素（包含1，不包含4）

print(numbers[1:4]) # 输出：(1, 2, 3)

# 截取从索引2开始到末尾的元素

print(numbers[2:]) # 输出：(2, 3, 4, 5, 6, 7, 8, 9)

# 步长为2，截取索引0到8的元素

print(numbers[0:8:2]) # 输出：(0, 2, 4, 6)

# 反向切片（步长为-1），从末尾到开头

print(numbers[::-1]) # 输出：(9, 8, 7, 6, 5, 4, 3, 2, 1, 0)

7.5 元组的不可变性

元组的不可变性是其最核心的特性，这意味着元组创建后，我们不能：

1. 修改元组中的元素；

2. 向元组中添加新元素；

3. 从元组中删除元素。

示例：尝试修改元组元素会报错

fruits = ("apple", "banana", "orange")

fruits[1] = "pear" # 会报错：TypeError: 'tuple' object does not support item assignment

示例：尝试添加元素会报错

fruits = ("apple", "banana", "orange")

fruits.append("grape") # 会报错：AttributeError: 'tuple' object has no attribute 'append'

示例：尝试删除元素会报错

fruits = ("apple", "banana", "orange")

del fruits[1] # 会报错：TypeError: 'tuple' object doesn't support item deletion

但需要注意的是：如果元组中包含可变元素（如列表），那么该可变元素内部的值是可以修改的。例如：

# 元组中包含列表（列表是可变的）

mixed_tuple = (1, 2, [3, 4, 5])

# 修改元组中的列表元素

mixed_tuple[2][0] = 100

print(mixed_tuple) # 输出：(1, 2, [100, 4, 5])

这种情况下，元组本身的结构（元素的数量和位置）没有改变，只是其中的可变元素内部发生了变化，这并不违反元组的不可变性。

7.6 元组的常用操作和方法

由于元组是不可变的，它的操作和方法比列表少很多，主要包括以下几种：

7.6.1 计算长度（len ()）

len()函数用于获取元组中元素的个数。

fruits = ("apple", "banana", "orange")

print(len(fruits)) # 输出：3

7.6.2 元素计数（count ()）

count()方法用于统计指定元素在元组中出现的次数。

numbers = (1, 2, 2, 3, 3, 3)

print(numbers.count(2)) # 输出：2（元素2出现了2次）

print(numbers.count(3)) # 输出：3（元素3出现了3次）

7.6.3 查找索引（index ()）

index()方法用于查找指定元素在元组中第一次出现的索引（如果元素不存在，会报错）。

fruits = ("apple", "banana", "orange", "banana")

print(fruits.index("banana")) # 输出：1（第一个"banana"的索引是1）

print(fruits.index("orange")) # 输出：2

7.6.4 元组的拼接

可以使用加号（+）拼接两个元组，返回一个新的元组（原元组不会被修改）。

tuple1 = (1, 2, 3)

tuple2 = (4, 5, 6)

tuple3 = tuple1 + tuple2

print(tuple3) # 输出：(1, 2, 3, 4, 5, 6)

7.6.5 元组的重复

可以使用乘号（*）让元组中的元素重复指定的次数，返回一个新的元组。

tuple1 = ("a", "b")

tuple2 = tuple1 * 3

print(tuple2) # 输出：('a', 'b', 'a', 'b', 'a', 'b')

7.7 元组推导式

与列表推导式类似，Python 也支持元组推导式，但它返回的不是元组，而是一个生成器对象（Generator）。如果需要将其转换为元组，可以使用tuple()函数。

元组推导式的语法如下：

(表达式 for 变量 in 可迭代对象 if 条件表达式)

示例：

# 创建一个生成器对象

generator = (x** 2 for x in range(1, 6))

print(generator) # 输出：<generator object <genexpr> at 0x000001...>

# 将生成器转换为元组

squares = tuple(generator)

print(squares) # 输出：(1, 4, 9, 16, 25)

生成器对象的特点是按需生成元素，而不是一次性生成所有元素，这在处理大量数据时可以节省内存。

7.8 元组与列表的区别

为了更好地理解元组，我们总结一下元组与列表的主要区别：

7.9 示例：元组的综合应用

使用元组存储学生的信息（姓名、年龄、成绩），并进行简单的处理。

# 定义学生信息元组（姓名、年龄、成绩）

student1 = ("张三", 18, 90)

student2 = ("李四", 19, 85)

student3 = ("王五", 17, 95)

# 存储所有学生信息的元组（元组中包含元组）

students = (student1, student2, student3)

# 遍历学生信息并打印

for student in students:

name, age, score = student # 元组解包（将元组中的元素分别赋值给变量）

print(f"姓名：{name}，年龄：{age}，成绩：{score}")

# 找出成绩最高的学生

max_score = 0

max_student = None

for student in students:

if student[2] > max_score:

max_score = student[2]

max_student = student

print(f"成绩最高的学生：{max_student[0]}，成绩：{max_student[2]}")

运行结果：

姓名：张三，年龄：18，成绩：90

姓名：李四，年龄：19，成绩：85

姓名：王五，年龄：17，成绩：95

成绩最高的学生：王五，成绩：95

在上述代码中，我们使用了 “元组解包” 的技巧，将元组中的元素分别赋值给多个变量，使代码更简洁。

7.10 小结

本章我们学习了 Python 中的元组，包括元组的创建、元素访问、切片操作，重点理解了元组的不可变性，还学习了元组的常用操作和方法，以及元组与列表的区别。

元组的不可变性使其在存储固定数据时非常有用，它可以保证数据的安全性，避免意外修改。在实际编程中，我们需要根据具体需求选择使用元组还是列表：如果数据需要频繁修改，选择列表；如果数据固定不变，选择元组。

下一章，我们将学习 Python 中的字典，它是一种以键值对形式存储数据的数据结构。