Python(二十四) 元组 tuple 详解

1. 什么是元组 tuple

在 Python 中，tuple 是一种用来保存多个数据的数据类型，中文通常叫做“元组”。

元组和列表很像，都可以用来存放一组数据。

但是它们最大的区别是：

列表 list 可以修改。
元组 tuple 创建后不能修改。

例如：

names = ("张三", "李四", "王五")
print(names)

输出：

('张三', '李四', '王五')

这个 names 就是一个元组。

可以把元组理解成一个“固定内容的列表”。

如果一组数据创建之后不希望被随便修改，就可以使用元组。

2. 元组的核心特点

元组有几个非常重要的特点：

特点	说明
有序	元素有固定顺序，可以使用下标访问
可重复	允许出现重复元素
不可变	创建后不能增加、删除、修改元素
可遍历	可以使用 `for` 循环遍历
可存放多种类型	一个元组中可以同时存放数字、字符串、列表等不同类型

2.1 有序

元组中的元素是有顺序的。

t = ("Python", "Java", "C++")

print(t[0])
print(t[1])
print(t[2])

输出：

Python
Java
C++

下标从 0 开始：

第 1 个元素的下标是 0
第 2 个元素的下标是 1
第 3 个元素的下标是 2

2.2 可重复

元组中允许有重复元素。

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

输出：

(1, 2, 2, 3, 3, 3)

元组不会自动去重。

如果需要去重，可以把元组转换成集合 set。

t = (1, 2, 2, 3, 3, 3)
result = set(t)

print(result)

输出：

{1, 2, 3}

2.3 不可变

元组创建后，不能修改里面的元素。

t = (10, 20, 30)
t[0] = 100  # 错误

这段代码会报错。

因为元组不支持修改元素。

2.4 可以存放不同类型的数据

元组中可以同时存放不同类型的数据。

student = ("张三", 18, 89.5, True)
print(student)

输出：

('张三', 18, 89.5, True)

这种写法常用于保存一条固定结构的数据，比如：

姓名、年龄、成绩、是否通过

3. 如何创建元组

3.1 使用小括号创建元组

最常见的方式是使用小括号 ()。

t = (1, 2, 3)
print(t)
print(type(t))

输出：

(1, 2, 3)
<class 'tuple'>

3.2 元组中的元素可以是任意类型

t = ("张三", 18, 3.14, True)
print(t)

输出：

('张三', 18, 3.14, True)

3.3 创建空元组

空元组使用 ()。

t = ()
print(t)
print(type(t))

输出：

()
<class 'tuple'>

3.4 创建只有一个元素的元组

这是元组中最容易出错的地方。

如果元组中只有一个元素，必须在元素后面加逗号。

正确写法：

t = (10,)
print(t)
print(type(t))

输出：

(10,)
<class 'tuple'>

错误写法：

t = (10)
print(t)
print(type(t))

输出：

10
<class 'int'>

为什么？

因为 (10) 只是普通的数学括号，不是元组。

真正决定它是不是元组的关键是逗号。

t1 = (10,)
t2 = 10,

print(type(t1))
print(type(t2))

输出：

<class 'tuple'>
<class 'tuple'>

教学时可以让学生记住：

单元素元组，逗号不能少。

3.5 不使用小括号创建元组

在 Python 中，可以省略小括号，直接使用逗号创建元组。

t = 1, 2, 3
print(t)
print(type(t))

输出：

(1, 2, 3)
<class 'tuple'>

不过教学和实际开发中，建议初学者写上小括号，可读性更好。

t = (1, 2, 3)

3.6 使用 tuple() 创建元组

可以使用 tuple() 把其他可迭代对象转换成元组。

把列表转换成元组：

lst = [1, 2, 3]
t = tuple(lst)

print(t)

输出：

(1, 2, 3)

把字符串转换成元组：

t = tuple("hello")
print(t)

输出：

('h', 'e', 'l', 'l', 'o')

注意，字符串会被拆成一个个字符。

3.7 tuple() 不能直接接收多个普通参数

错误写法：

t = tuple(1, 2, 3)  # 错误

正确写法：

t = tuple([1, 2, 3])
print(t)

输出：

(1, 2, 3)

或者直接写：

t = (1, 2, 3)

4. 元组的访问方式

4.1 使用正向下标访问

元组支持下标访问。

t = ("张三", "李四", "王五")

print(t[0])
print(t[1])
print(t[2])

输出：

张三
李四
王五

下标从 0 开始。

t[0] 表示第 1 个元素
t[1] 表示第 2 个元素
t[2] 表示第 3 个元素

4.2 使用负数下标访问

元组也支持负数下标。

t = ("张三", "李四", "王五")

print(t[-1])
print(t[-2])
print(t[-3])

输出：

王五
李四
张三

负数下标从右往左数：

t[-1] 表示最后一个元素
t[-2] 表示倒数第二个元素
t[-3] 表示倒数第三个元素

4.3 下标越界会报错

t = (10, 20, 30)
print(t[3])  # 错误

因为这个元组只有 3 个元素，下标最大是 2。

t[0] -> 10
t[1] -> 20
t[2] -> 30

访问不存在的位置会出现 IndexError。

5. 元组切片

切片可以从元组中取出一部分元素。

语法：

元组[开始位置:结束位置:步长]

注意：

切片包含开始位置，不包含结束位置。

5.1 基本切片

t = (10, 20, 30, 40, 50)

print(t[1:4])

输出：

(20, 30, 40)

解释：

t[1:4] 表示从下标 1 开始，取到下标 4 之前。
也就是取 t[1]、t[2]、t[3]。

5.2 从开头切到指定位置

t = (10, 20, 30, 40, 50)
print(t[:3])

输出：

(10, 20, 30)

5.3 从指定位置切到结尾

t = (10, 20, 30, 40, 50)
print(t[2:])

输出：

(30, 40, 50)

5.4 复制整个元组

t = (10, 20, 30)
new_t = t[:]

print(new_t)

输出：

(10, 20, 30)

5.5 使用步长

t = (10, 20, 30, 40, 50, 60)
print(t[::2])

输出：

(10, 30, 50)

意思是从头到尾，每隔一个取一个。

5.6 反转元组

t = (10, 20, 30, 40, 50)
print(t[::-1])

输出：

(50, 40, 30, 20, 10)

6. 元组的遍历

6.1 使用 for 循环遍历

t = ("Python", "Java", "C++")

for item in t:
    print(item)

输出：

Python
Java
C++

6.2 使用下标遍历

t = ("Python", "Java", "C++")

for i in range(len(t)):
    print(i, t[i])

输出：

0 Python
1 Java
2 C++

6.3 使用 enumerate() 遍历

enumerate() 可以同时得到下标和元素。

t = ("Python", "Java", "C++")

for index, value in enumerate(t):
    print(index, value)

输出：

0 Python
1 Java
2 C++

这种方式在教学和实际开发中都很常见。

7. 元组常用操作

7.1 获取元组长度：len()

t = ("张三", "李四", "王五")
print(len(t))

输出：

len() 返回元组中元素的个数。

7.2 判断元素是否存在：in

t = ("张三", "李四", "王五")

print("张三" in t)
print("赵六" in t)

输出：

True
False

7.3 判断元素是否不存在：not in

t = ("张三", "李四", "王五")

print("赵六" not in t)

输出：

True

7.4 统计元素出现次数：count()

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

print(t.count(1))
print(t.count(2))
print(t.count(3))

输出：

1
2
3

count() 用来统计某个元素在元组中出现了几次。

如果元素不存在，返回 0。

t = (1, 2, 3)
print(t.count(4))

输出：

7.5 查找元素位置：index()

t = ("张三", "李四", "王五")
print(t.index("李四"))

输出：

index() 返回指定元素第一次出现的位置。

如果元素重复，只返回第一次出现的位置。

t = (10, 20, 20, 30)
print(t.index(20))

输出：

如果元素不存在，index() 会报错。

t = (10, 20, 30)
print(t.index(40))  # 错误

如果不确定元素是否存在，建议先用 in 判断。

t = (10, 20, 30)

if 40 in t:
    print(t.index(40))
else:
    print("没有找到")

7.6 元组拼接：+

可以使用 + 拼接两个元组，得到一个新元组。

t1 = (1, 2, 3)
t2 = (4, 5, 6)

t3 = t1 + t2
print(t3)

输出：

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

注意：这不是修改原元组，而是创建了一个新元组。

t1 = (1, 2, 3)
t2 = (4, 5, 6)

t3 = t1 + t2

print(t1)
print(t2)
print(t3)

输出：

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

7.7 元组重复：*

可以使用 * 重复元组。

t = ("Python",)
result = t * 3

print(result)

输出：

('Python', 'Python', 'Python')

再比如：

t = (1, 2)
print(t * 4)

输出：

(1, 2, 1, 2, 1, 2, 1, 2)

8. 元组的不可变性

元组最重要的特点就是不可变。

不可变的意思是：

元组一旦创建，里面的元素不能被增加、删除、修改。

8.1 不能修改元素

t = (1, 2, 3)
t[0] = 100  # 错误

会报错，因为元组不支持修改元素。

8.2 不能添加元素

列表可以使用 append() 添加元素。

lst = [1, 2, 3]
lst.append(4)
print(lst)

输出：

[1, 2, 3, 4]

但是元组没有 append() 方法。

t = (1, 2, 3)
t.append(4)  # 错误

8.3 不能删除元素

列表可以删除元素。

lst = [1, 2, 3]
lst.remove(2)
print(lst)

输出：

[1, 3]

但是元组不能直接删除某个元素。

t = (1, 2, 3)
t.remove(2)  # 错误

8.4 元组中的可变元素可以被修改

这里是一个非常重要的注意点。

虽然元组本身不可变，但如果元组中放的是列表这样的可变对象，列表内部的内容是可以修改的。

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

t[2].append(5)

print(t)

输出：

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

很多初学者会疑惑：

不是说元组不能修改吗？
为什么这里又变了？

要这样理解：

元组不能修改的是它保存的元素位置和引用。
但是如果某个元素本身是可变对象，这个对象内部的内容仍然可以变。

通俗一点说：

元组像一个固定的座位表。
座位上的人不能换。
但如果某个座位上坐的是一个“可以变内容的盒子”，盒子里的东西可以改变。

例如：

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

t[2] = [3, 4, 5]  # 错误，不能换掉整个列表

但是：

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

t[2].append(5)  # 正确，可以修改列表内部
print(t)

9. 元组解包

元组解包是 Python 中非常常见、非常好用的语法。

所谓解包，就是把元组中的元素分别赋值给多个变量。

9.1 基本解包

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

name, age, score = student

print(name)
print(age)
print(score)

输出：

张三
18
90

这比使用下标更清晰。

name = student[0]
age = student[1]
score = student[2]

9.2 解包时变量数量必须匹配

t = (1, 2, 3)

a, b, c = t  # 正确

变量数量和元素数量一样。

错误写法：

t = (1, 2, 3)

a, b = t  # 错误

错误写法：

t = (1, 2, 3)

a, b, c, d = t  # 错误

9.3 使用星号接收多个元素

如果元素数量不确定，可以使用 * 接收多个元素。

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

first, *middle, last = t

print(first)
print(middle)
print(last)

输出：

1
[2, 3, 4]
5

注意：带星号的变量接收到的是列表，不是元组。

再比如：

t = ("张三", "语文", "数学", "英语")

name, *subjects = t

print(name)
print(subjects)

输出：

张三
['语文', '数学', '英语']

9.4 忽略不需要的值

如果有些值不需要，可以用 _ 表示。

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

name, _, score = student

print(name)
print(score)

输出：

张三
90

这里 _ 表示这个位置的数据不关心。

9.5 交换两个变量的值

Python 中交换两个变量的值，本质上也用到了元组打包和解包。

a = 10
b = 20

a, b = b, a

print(a)
print(b)

输出：

20
10

这比其他语言中使用临时变量更简洁。

9.6 函数返回多个值

Python 函数可以返回多个值，本质上返回的是元组。

def get_student():
    return "张三", 18, 90

result = get_student()
print(result)
print(type(result))

输出：

('张三', 18, 90)
<class 'tuple'>

也可以直接解包：

def get_student():
    return "张三", 18, 90

name, age, score = get_student()

print(name)
print(age)
print(score)

输出：

张三
18
90

10. 元组和列表的转换

10.1 列表转换成元组

lst = [1, 2, 3]
t = tuple(lst)

print(t)

输出：

(1, 2, 3)

如果一组数据不希望被修改，可以把列表转换成元组。

10.2 元组转换成列表

t = (1, 2, 3)
lst = list(t)

print(lst)

输出：

[1, 2, 3]

如果想修改元组中的数据，常见做法是：

先把元组转换成列表。
修改列表。
再把列表转换回元组。

示例：

t = (1, 2, 3)

lst = list(t)
lst[0] = 100
t = tuple(lst)

print(t)

输出：

(100, 2, 3)

注意：这不是直接修改原来的元组，而是创建了一个新的元组。

11. 元组和列表的区别

对比项	list 列表	tuple 元组
符号	`[]`	`()`
是否有序	有序	有序
是否可重复	可以重复	可以重复
是否可修改	可以修改	不可以修改
是否支持下标	支持	支持
常见用途	保存需要变化的数据	保存不希望变化的数据

11.1 什么时候使用列表

如果数据后续可能会增加、删除、修改，适合使用列表。

例如，购物车中的商品：

cart = ["苹果", "牛奶"]
cart.append("面包")
cart.remove("苹果")

print(cart)

输出：

['牛奶', '面包']

购物车内容经常变化，所以适合用列表。

11.2 什么时候使用元组

如果数据创建后不希望被修改，适合使用元组。

例如，一个点的坐标：

point = (10, 20)

一个日期：

date = (2026, 7, 2)

一个学生的固定信息：

student = ("张三", 18, "一班")

这些数据通常结构固定，适合用元组。

11.3 教学中的简单判断

可以这样告诉学生：

数据要经常改，用 list。
数据不希望改，用 tuple。

12. 元组可以作为字典的键

因为元组是不可变类型，所以在很多情况下可以作为字典的键。

例如，用坐标作为键：

locations = {
    (0, 0): "原点",
    (1, 2): "A 点",
    (3, 4): "B 点"
}

print(locations[(1, 2)])

输出：

A 点

这种写法在坐标、棋盘、地图等场景中很常见。

12.1 不是所有元组都能作为字典的键

如果元组里面包含列表，就不能作为字典的键。

错误示例：

d = {
    (1, [2, 3]): "错误"
}

原因是列表是可变类型，不能参与哈希计算。

正确示例：

d = {
    (1, (2, 3)): "正确"
}

print(d[(1, (2, 3))])

输出：

正确

教学时可以这样总结：

元组能不能作为字典的键，要看元组里面的元素是否也都不可变。

13. 元组可以作为集合的元素

元组也可以放进集合中。

points = {(0, 0), (1, 2), (3, 4)}
print(points)

输出可能是：

{(1, 2), (3, 4), (0, 0)}

这在保存不重复坐标时很有用。

points = [(0, 0), (1, 2), (0, 0), (3, 4)]
unique_points = set(points)

print(unique_points)

输出可能是：

{(1, 2), (3, 4), (0, 0)}

但是如果元组里包含列表，就不能放进集合。

s = {(1, [2, 3])}  # 错误

14. 元组排序

元组本身不能被修改，所以它没有 sort() 方法。

错误写法：

t = (3, 1, 2)
t.sort()  # 错误

如果想排序，可以使用 sorted()。

t = (3, 1, 2)
result = sorted(t)

print(result)
print(type(result))

输出：

[1, 2, 3]
<class 'list'>

注意：sorted() 返回的是列表，不是元组。

如果希望结果仍然是元组，可以再转换一次。

t = (3, 1, 2)
result = tuple(sorted(t))

print(result)
print(type(result))

输出：

(1, 2, 3)
<class 'tuple'>

15. 元组比较

元组之间可以进行比较。

Python 会从第一个元素开始，一个一个比较。

print((1, 2, 3) < (1, 2, 4))

输出：

True

解释：

第一个元素都为 1，相等。
第二个元素都为 2，相等。
第三个元素比较：3 < 4，所以结果为 True。

再看一个例子：

print((1, 5) > (1, 2, 100))

输出：

True

解释：

第一个元素都为 1，相等。
第二个元素比较：5 > 2，所以直接得到 True。
后面的 100 不再影响结果。

这个特性在排序时经常用到。

例如：

students = [
    ("张三", 90),
    ("李四", 85),
    ("王五", 95)
]

print(sorted(students))

默认会先按第一个元素排序，也就是按姓名排序。

如果想按成绩排序，可以使用 key。

students = [
    ("张三", 90),
    ("李四", 85),
    ("王五", 95)
]

result = sorted(students, key=lambda item: item[1])
print(result)

输出：

[('李四', 85), ('张三', 90), ('王五', 95)]

16. *args 和元组

在函数中，*args 可以接收任意数量的位置参数。

这些参数会被保存成一个元组。

def add_all(*args):
    print(args)
    print(type(args))

add_all(1, 2, 3)

输出：

(1, 2, 3)
<class 'tuple'>

可以遍历 args 来求和。

def add_all(*args):
    total = 0
    for num in args:
        total += num
    return total

print(add_all(1, 2, 3))
print(add_all(10, 20, 30, 40))

输出：

6
100

教学时可以这样讲：

*args 会把多余的位置参数打包成一个元组。

17. 元组的常见应用场景

17.1 保存坐标

point = (10, 20)

x, y = point

print("x 坐标：", x)
print("y 坐标：", y)

输出：

x 坐标： 10
y 坐标： 20

坐标通常由固定数量的数据组成，适合用元组。

17.2 保存日期

date = (2026, 7, 2)

year, month, day = date

print(year)
print(month)
print(day)

输出：

2026
7
2

17.3 保存学生信息

student = ("张三", 18, "一班")

name, age, class_name = student

print(name)
print(age)
print(class_name)

输出：

张三
18
一班

17.4 函数返回多个结果

def get_max_min(nums):
    max_num = max(nums)
    min_num = min(nums)
    return max_num, min_num

result = get_max_min([3, 1, 8, 2])
print(result)

输出：

(8, 1)

也可以直接解包：

max_num, min_num = get_max_min([3, 1, 8, 2])

print("最大值：", max_num)
print("最小值：", min_num)

输出：

最大值： 8
最小值： 1

17.5 作为固定配置

如果有一组固定选项，不希望被修改，可以使用元组。

weekdays = ("周一", "周二", "周三", "周四", "周五", "周六", "周日")

for day in weekdays:
    print(day)

这种数据通常不会变，用元组更合适。

18. 元组常见错误和注意事项

18.1 单元素元组必须加逗号

错误写法：

t = (10)
print(type(t))

输出：

<class 'int'>

正确写法：

t = (10,)
print(type(t))

输出：

<class 'tuple'>

记忆：

单元素元组不是看括号，而是看逗号。

18.2 元组不能修改元素

错误写法：

t = (1, 2, 3)
t[0] = 100

如果确实需要修改，可以转换成列表。

t = (1, 2, 3)

lst = list(t)
lst[0] = 100
t = tuple(lst)

print(t)

输出：

(100, 2, 3)

18.3 元组没有 append()、remove()、pop() 等修改方法

下面这些写法都是错误的：

t = (1, 2, 3)

t.append(4)   # 错误
t.remove(2)   # 错误
t.pop()       # 错误

这些方法属于列表，不属于元组。

18.4 tuple("abc") 会拆分字符串

t = tuple("abc")
print(t)

输出：

('a', 'b', 'c')

如果想创建只包含一个字符串的元组，要这样写：

t = ("abc",)
print(t)

输出：

('abc',)

18.5 tuple([1, 2, 3]) 和 (1, 2, 3) 都可以

t1 = tuple([1, 2, 3])
t2 = (1, 2, 3)

print(t1)
print(t2)

输出：

(1, 2, 3)
(1, 2, 3)

如果数据已经是列表，可以使用 tuple() 转换。

如果是直接写固定数据，通常使用小括号更简单。

18.6 元组的不可变不是绝对的“深层不可变”

看这个例子：

t = (1, 2, [3, 4])
t[2].append(5)

print(t)

输出：

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

解释：

元组本身不能改。
但元组里面的列表可以改。

所以，如果想让数据尽量不被修改，元组里面也尽量放不可变对象。

例如：

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

18.7 使用 + 拼接元组不会修改原元组

t1 = (1, 2)
t2 = (3, 4)

t3 = t1 + t2

print(t1)
print(t2)
print(t3)

输出：

(1, 2)
(3, 4)
(1, 2, 3, 4)

+ 会创建新元组，不会修改原元组。

18.8 t += (...) 看起来像修改，实际是创建新元组

t = (1, 2, 3)
print(id(t))

t += (4, 5)
print(t)
print(id(t))

输出结果中，两次 id(t) 通常不同。

这说明：

t += (4, 5) 不是在原元组上添加元素，而是创建了一个新元组，再让 t 指向它。

18.9 不要频繁用 + 拼接大量元组

如果在循环中不断拼接元组，会不断创建新元组，效率较低。

不推荐：

t = ()

for i in range(1000):
    t = t + (i,)

更推荐先使用列表收集数据，最后再转换成元组。

lst = []

for i in range(1000):
    lst.append(i)

t = tuple(lst)

18.10 元组能不能作为字典键，要看内部元素

可以：

d = {
    (1, 2): "A"
}

不可以：

d = {
    (1, [2, 3]): "B"
}

原因：

元组里面包含了列表，列表是可变的。

19. 综合案例

19.1 记录学生成绩

student = ("张三", 18, 92)

name, age, score = student

print("姓名：", name)
print("年龄：", age)
print("成绩：", score)

输出：

姓名： 张三
年龄： 18
成绩： 92

19.2 统计成绩最高和最低值

def get_score_info(scores):
    max_score = max(scores)
    min_score = min(scores)
    avg_score = sum(scores) / len(scores)
    return max_score, min_score, avg_score

scores = (88, 95, 76, 90, 85)

max_score, min_score, avg_score = get_score_info(scores)

print("最高分：", max_score)
print("最低分：", min_score)
print("平均分：", avg_score)

输出：

最高分： 95
最低分： 76
平均分： 86.8

19.3 使用元组保存坐标并去重

points = [
    (0, 0),
    (1, 2),
    (0, 0),
    (3, 4),
    (1, 2)
]

unique_points = set(points)

print(unique_points)

输出可能是：

{(1, 2), (3, 4), (0, 0)}

这里元组作为集合元素，用来表示不可变坐标。

19.4 使用字典记录坐标对应的位置

map_data = {
    (0, 0): "起点",
    (1, 0): "道路",
    (2, 0): "终点"
}

position = (2, 0)

print(map_data[position])

输出：

终点

19.5 函数接收任意数量的成绩

def get_average(*scores):
    total = sum(scores)
    count = len(scores)
    return total / count

print(get_average(80, 90, 100))
print(get_average(70, 85, 95, 100))

输出：

90.0
87.5

这里的 scores 是一个元组。

20. 课堂练习

练习 1：创建元组

请创建一个元组，保存三个学生姓名：

张三、李四、王五

参考答案：

students = ("张三", "李四", "王五")
print(students)

练习 2：访问元组元素

有如下元组：

t = ("Python", "Java", "C++")

请输出第一个元素和最后一个元素。

参考答案：

t = ("Python", "Java", "C++")

print(t[0])
print(t[-1])

练习 3：创建单元素元组

请创建一个只包含数字 100 的元组。

参考答案：

t = (100,)
print(t)
print(type(t))

练习 4：元组解包

有如下元组：

student = ("张三", 18, 95)

请把姓名、年龄、成绩分别赋值给三个变量并打印。

参考答案：

student = ("张三", 18, 95)

name, age, score = student

print(name)
print(age)
print(score)

练习 5：函数返回多个值

请写一个函数，接收两个数字，返回它们的和与差。

参考答案：

def calc(a, b):
    return a + b, a - b

result = calc(10, 3)
print(result)

也可以解包：

def calc(a, b):
    return a + b, a - b

total, diff = calc(10, 3)

print("和：", total)
print("差：", diff)

练习 6：判断元素是否存在

有如下元组：

languages = ("Python", "Java", "C++")

请判断 "Python" 是否在元组中。

参考答案：

languages = ("Python", "Java", "C++")

if "Python" in languages:
    print("存在")
else:
    print("不存在")

练习 7：列表和元组转换

有如下列表：

nums = [1, 2, 3]

请把它转换成元组。

参考答案：

nums = [1, 2, 3]
t = tuple(nums)

print(t)

练习 8：统计元素出现次数

有如下元组：

nums = (1, 2, 2, 3, 3, 3)

请统计数字 3 出现了几次。

参考答案：

nums = (1, 2, 2, 3, 3, 3)
count = nums.count(3)

print(count)

练习 9：使用元组保存坐标

请用元组表示一个坐标点 (10, 20)，并分别输出 x 坐标和 y 坐标。

参考答案：

point = (10, 20)

x, y = point

print("x 坐标：", x)
print("y 坐标：", y)

练习 10：理解不可变性

下面代码是否会报错？

t = (1, 2, 3)
t[0] = 100

答案：

会报错。
因为元组创建后不能修改元素。

21. 课堂总结

元组 tuple 是 Python 中非常常用的数据类型。

可以用一句话总结：

tuple 是一种有序、可重复、不可修改的数据容器。

元组最重要的特点：

使用小括号 () 表示。
元素有顺序，可以使用下标访问。
元素可以重复。
创建后不能修改。
单元素元组必须加逗号。
可以用于解包。
可以作为函数返回多个值的常见形式。

最常用代码：

t = (1, 2, 3)        # 创建元组
t = ()               # 创建空元组
t = (10,)            # 创建单元素元组
t[0]                 # 访问第一个元素
t[-1]                # 访问最后一个元素
t[1:3]               # 切片
len(t)               # 获取长度
x in t               # 判断元素是否存在
t.count(x)           # 统计元素出现次数
t.index(x)           # 查找元素位置
a, b = (1, 2)        # 元组解包
tuple([1, 2, 3])     # 列表转换成元组
list((1, 2, 3))      # 元组转换成列表

教学记忆口诀：

元组 tuple 很稳定，
小括号里放数据。
有序可重复，
创建不能改。
单个元素别忘逗号。

再补充一句：

需要修改，用 list。
不想修改，用 tuple。