Python “元组” ——Python面试100道实战题目练习，巩固知识、检查技术、成功就业

长风清留扬

于 2024-09-14 10:15:00 发布

阅读量556

点赞数 15

分类专栏：最新Python入门基础合集文章标签：面试 python 数据结构元组就业学习练习题

本文链接：https://blog.csdn.net/qq_51431069/article/details/142214476

版权

最新Python入门基础合集专栏收录该内容

16 篇文章 1 订阅

订阅专栏

本文主要是作为Python中列表的一些题目，方便学习完Python的元组之后进行一些知识检验，感兴趣的小伙伴可以试一试，含选择题、判断题、实战题、填空题，答案在第五章。

在做题之前可以先学习或者温习一下Python的列表，推荐阅读下面这篇文章：

Python全网最全基础课程笔记(十)——元组，跟着思维导图和图文来学习，爆肝2w字，无数代码案例！

通过这些题目，学习者可以检验自己对Python字典基础知识的掌握程度。

编程不仅是技术的堆砌，更是灵魂的创造，每一次代码的跳动，都是向世界宣告你的不凡！

博客主页：长风清留扬-CSDN博客
系列专栏：Python基础专栏
每天更新大数据相关方面的技术，分享自己的实战工作经验和学习总结，尽量帮助大家解决更多问题和学习更多新知识，欢迎评论区分享自己的看法
感谢大家点赞👍收藏⭐评论

第一章选择题

1. 在Python中，元组是一种什么类型的数据结构？
A. 可变序列
B. 不可变序列
C. 字典的另一种形式
D. 集合的另一种形式

2. 下列哪个符号用于定义元组？
A. {}
B. []
C. ()
D. <>

3. 元组一旦创建，其内部元素可以：
A. 随意修改
B. 通过索引访问但不能修改
C. 通过切片操作修改
D. 不能被访问

4. 下列哪个操作是合法的，用于向元组中添加元素？
A. tuple.append(element)
B. tuple = tuple + (element,)
C. tuple.insert(index, element)
D. 以上都不是

5. 下列哪个函数可以用来计算元组中元素的数量？
A. len()
B. count()
C. size()
D. length()

6. 元组支持哪些操作？（多选）
A. 索引访问
B. 切片操作
C. 排序（sort）
D. 拼接

7. 下列哪个表达式的结果是一个元组？
A. (1, 2, 3)
B. [1, 2, 3]
C. {1, 2, 3}
D. 1, 2, 3（在表达式中）

8. 下列关于元组和列表的说法，哪个是正确的？
A. 元组和列表都是可变的
B. 元组和列表都是不可变的
C. 元组是不可变的，列表是可变的
D. 元组是可变的，列表是不可变的

9. 使用元组存储数据时，相比于列表，其主要优势是什么？
A. 访问速度更快
B. 可以存储不同类型的数据
C. 支持更多的内置方法
D. 占用内存更少

10. 下列哪个不是元组（tuple）的特性？
A. 不可变性
B. 支持索引和切片
C. 可以包含重复的元素
D. 自动排序

11. 在Python中，以下哪个表达式创建了一个空元组？
A. tuple()
B. ()
C. {}
D. []

12. 假设有一个元组 t = (1, 2, 3, 4, 5)，那么 t[2:4] 的结果是什么？
A. (3, 4)
B. (2, 3)
C. (3, 4, 5)
D. (2, 3, 4)

13. 元组中的元素可以是哪些类型？（多选）
A. 整数
B. 浮点数
C. 字符串
D. 另一个元组
E. 列表

14. 下列哪个操作是尝试修改元组中元素的行为，且是非法的？
A. t[0] = 10
B. t = (10,) + t[1:]
C. t.append(6)
D. del t[0]

15. 假设 t = (1, 2, 3)，t * 2 的结果是什么？
A. (1, 2, 3, 1, 2, 3)
B. (2, 4, 6)
C. (1, 2, 3, 2, 3)
D. 引发错误

16. 元组 t = (1, 'a', 3.14) 中，t.index('a') 的结果是什么？
A. 0
B. 1
C. 2
D. 引发错误，因为元组没有 index 方法

17. 下列哪个函数可以返回元组中某个元素出现的次数？
A. len()
B. index()
C. count()
D. find()

18. 元组 t = (1,) 和 t = 1 在Python中是否等价？
A. 是
B. 否

19. 哪个操作可以检查元组中是否包含某个值？
A. if value in t:
B. t.contains(value)
C. t.find(value)
D. if value == t[some_index]:

20. 元组可以作为字典的哪个部分？
A. 键（key）
B. 值（value）
C. 都可以
D. 都不可以

21. 元组可以作为另一个元组的元素吗？
A. 可以
B. 不可以

22. 下列哪个表达式创建了一个包含单个元素的元组？
A. (1)
B. 1
C. (1,)
D. ['1']

23. 假设 t = (1, 2, 3, 4, 5)，t[-1] 的结果是什么？
A. 1
B. 5
C. 引发错误
D. (5,)

24. 哪个内置函数可以用于获取元组中元素的索引位置？（多选）
A. index()
B. find()
C. len()
D. count()

25. 元组的哪个特性使得它成为字典键的理想选择？
A. 可变性
B. 不可变性
C. 可以包含任意类型的元素
D. 支持排序

26. 假设 t = (1, 2, 2, 3)，t.count(2) 的结果是什么？
A. 1
B. 2
C. 3
D. 引发错误，因为元组没有 count 方法

27. 元组支持哪些形式的迭代？（多选）
A. for循环
B. while循环（通过索引）
C. 列表推导式
D. 字典推导式（用于生成字典）

28. 哪个操作符可以用来连接两个元组？
A. +
B. -
C. *
D. //

29. 假设 t = (1, 2, 3)，以下哪个表达式不是合法的？
A. t[0]
B. t[-1]
C. t[3]
D. t[0:2]

30. 下列哪个函数不能直接用于元组，因为它会尝试修改原数据结构？
A. append()
B. sort()
C. len()
D. count()

31. 元组与列表的主要区别是什么？
A. 元组可以包含列表，但列表不能包含元组
B. 元组是不可变的，而列表是可变的
C. 元组只能包含数字，列表可以包含任意类型
D. 元组有特定的方法，而列表没有

32. 假设 t = (1, 2, 3)，以下哪个表达式会返回一个新的元组，其中包含 t 的所有元素以及额外的元素 4？
A. t.append(4)
B. t + (4,)
C. t.extend((4,))
D. t.insert(3, 4)

33. 哪个内置函数可以用来检查元组是否为空？
A. is_empty()
B. empty()
C. not t
D. len(t) == 0

34. 假设 t = (1, 2, 3, 4, 5)，t[::-1] 的结果是什么？
A. (5, 4, 3, 2, 1)
B. (1, 2, 3, 4, 5)
C. 引发错误
D. None

35. 元组是否支持切片操作？
A. 是
B. 否

36. 假设 t = (1, 2, 3) 和 s = (4, 5, 6)，t + s 的结果是什么？
A. (1, 2, 3, 4, 5, 6)
B. (5, 10, 15)
C. 引发错误，因为元组不能相加
D. (1, 4, 2, 5, 3, 6)

37. 哪个内置函数可以用来获取元组中元素的数量？
A. size()
B. count()
C. len()
D. get_length()

38. 假设 t = (1, 2, 3)，以下哪个表达式会返回 True？
A. t == (1, 2, 3)
B. t == [1, 2, 3]
C. t[0] == 2
D. t in (1, 2, 3)

39. 元组是否可以作为集合的元素？
A. 是
B. 否

40. 假设 t = (1, 2, 3)，t * 0 的结果是什么？
A. (0, 0, 0)
B. ()
C. 引发错误
D. None

第二章判断题

1. 元组是一种可变的数据结构。

A. 正确
B. 错误

2. 元组中的元素可以是任意类型，包括另一个元组。

A. 正确
B. 错误

3. t = (1) 声明了一个包含单个元素的元组。

A. 正确
B. 错误

4. 元组支持索引操作，但不支持切片操作。

A. 正确
B. 错误

5. 你可以使用 append() 方法向元组中添加元素。

A. 正确
B. 错误

6. t = (1, 2, 3); t[0] = 4 这行代码会成功修改元组的第一个元素。

A. 正确
B. 错误

7. 元组是Python中用于存储集合（如数学中的集合）的内置数据结构。

A. 正确
B. 错误

8. 使用 * 操作符可以将两个元组合并成一个新的元组。

A. 正确
B. 错误
（注意：这里的表述可能有些误导，因为直接使用 * 并不能直接合并两个元组，而是需要 (t1 + t2) 或类似的方式。但这里我们按题目的字面意思来判断。）

9. len(t) 函数可以用来获取元组 t 中元素的数量。

A. 正确
B. 错误

10. t = (1, 2, 3); t[-1] 返回元组的最后一个元素。

A. 正确
B. 错误

11. 元组可以作为字典的键，因为它们是可哈希的。

A. 正确
B. 错误

12. t = (1, 2, 3); del t[1] 这行代码可以删除元组中的第二个元素。

A. 正确
B. 错误

13. 元组支持列表推导式来创建新的元组。

A. 正确
B. 错误
（注意：虽然不能直接对元组使用列表推导式的语法，但可以通过列表推导式创建列表，然后将列表转换为元组。）

14. t = (1, 2, 3); t.count(2) 返回元组中元素2出现的次数。

A. 正确
B. 错误

15. 元组是不可变的，这意味着一旦创建，你就不能更改其元素的顺序或值。

A. 正确
B. 错误

16. 元组可以使用 in 关键字来检查某个元素是否存在于元组中。

A. 正确
B. 错误

17. t = (1,) 和 t = 1, 在Python中是完全等价的表达式。

A. 正确
B. 错误

18. 元组支持 + 操作符来连接两个元组，但不支持 * 操作符来重复元组。

A. 正确
B. 错误

19. t = (1, 2, 3); t.index(2) 返回元素2在元组中的索引位置。

A. 正确
B. 错误

20. 元组可以作为集合的元素，但不能作为字典的值。

A. 正确
B. 错误

21. t = (1, 2, 3); t.remove(2) 会从元组中移除元素2。

A. 正确
B. 错误

22. 元组支持嵌套，即元组中可以包含其他元组。

A. 正确
B. 错误

23. t = (1, 2, 3); t[1:3] 返回元组 (2, 3)。

A. 正确
B. 错误

24. 元组是不可变的，但你可以修改元组中可变元素的内部状态。

A. 正确
B. 错误

25. t = (1, 2, 3); t.sort() 会对元组中的元素进行排序。

A. 正确
B. 错误

26. 元组可以通过 tuple() 函数从其他可迭代对象（如列表）创建。

A. 正确
B. 错误

27. t = (1,) * 3 会创建一个包含三个元素 1 的元组 (1, 1, 1)。

A. 正确
B. 错误

28. 元组支持 len() 函数来获取其长度，但不支持 max() 和 min() 函数来找到其最大或最小元素。

A. 正确
B. 错误

29. t = (1, 2, 3); t.reverse() 会将元组中的元素顺序反转。

A. 正确
B. 错误

30. 元组可以作为函数的参数传递，也可以作为函数的返回值。

A. 正确
B. 错误

31. t = (1, 2, 3); 4 in t 会返回 True，因为 4 是元组 t 的一个元素。

A. 正确
B. 错误

32. 元组支持 count() 方法来统计某个元素在元组中出现的次数，但不支持 index() 方法来查找元素的索引。

A. 正确
B. 错误

33. 你可以使用 for 循环来遍历元组中的元素。

A. 正确
B. 错误

34. 元组是不可变的，但你可以通过切片和连接操作来创建新的元组。

A. 正确
B. 错误

35. t = (1, 2, 3); t.append(4) 会引发 AttributeError，因为元组没有 append() 方法。

A. 正确
B. 错误

36. 元组可以作为字典的键，因为它们是可哈希的。

A. 正确
B. 错误

37. t = (1, 2, [3, 4], 5) 是一个不可变的元组，但其中的列表 [3, 4] 是可变的。

A. 正确
B. 错误

38. 使用 tuple() 函数将列表转换为元组时，会创建列表的一个浅拷贝。

A. 正确
B. 错误

39. 元组支持负数索引，允许你从元组的末尾开始访问元素。

A. 正确
B. 错误

40. t = (1, 2, 3); t[2] = 4 会将元组中的第三个元素更改为 4。

A. 正确
B. 错误

41. 你可以通过 + 操作符将两个元组合并为一个新的元组，但不可以使用 - 操作符来从元组中移除元素。

A. 正确
B. 错误

42. 元组支持切片操作，但切片的结果仍然是元组类型。

A. 正确
B. 错误

43. t = (1, 2, 3); t.insert(2, 4) 会将元素 4 插入到元组 t 的索引位置 2。

A. 正确
B. 错误

44. 元组没有内置的排序方法，但你可以使用 sorted() 函数和元组切片来创建一个排序后的新元组。

A. 正确
B. 错误

45. 在Python中，空元组可以用 () 或 tuple() 来表示。

A. 正确
B. 错误

第三章填空题

1.元组是一种____的序列类型，一旦创建就不能被修改。

2.创建一个空元组的语法是____。

3.若要创建一个包含元素1, 2, 3的元组，应使用____语法。

4.元组索引从____开始。

5.使用____方法可以获取元组中元素的数量。

6.若元组t = (1, 2, 3, 4, 5)，则t[3]的值是____。

7.元组不支持____操作，因为它是不可变的。

8.要想将一个列表转换为元组，可以使用内置的____函数。

9.若元组t = (1, 2, 3, 4, 5)，则t[1:4]的结果是____。

10.元组可以使用____操作符进行连接。

第四章实战题

实战 1：访问元组中的元素

题目:
有一个元组tup，包含多个元素，请编写代码访问并打印出元组的第三个元素。

解题思路:
元组是有序的集合，可以通过索引来访问其中的元素。索引从0开始，所以第三个元素的索引是2。

# 定义一个元组  
tup = (1, 2, 3, 4, 5)

实战 2: 元组的不可变性

题目:
尝试修改元组中的一个元素，并捕获可能发生的异常（如果有的话），然后打印出修改前后的元组以展示其不可变性。

解题思路:
元组是不可变的，所以不能直接修改其元素。尝试修改会抛出TypeError。

# 定义一个元组  
tup = (1, 2, 3, 4, 5)

实战 3: 元组的切片

题目:
有一个元组tup，包含多个元素，请编写代码访问并打印出元组的第二个到第四个元素（包含第二个和第四个）。

解题思路:
使用切片操作来访问元组的一部分。切片操作通过指定起始索引和结束索引（结束索引的元素不包含在内）来工作。

# 定义一个元组  
tup = (1, 2, 3, 4, 5)

实战 4: 元组的拼接

题目:
有两个元组tup1和tup2，请编写代码将它们拼接成一个新的元组，并打印出来。

解题思路:
元组之间可以使用+运算符进行拼接。

# 定义两个元组  
tup1 = (1, 2, 3)  
tup2 = (4, 5, 6)

实战 5: 元组中的最大值和最小值

题目:
有一个包含整数的元组tup，请找出并打印出元组中的最大值和最小值。

解题思路:
使用Python内置的max()和min()函数来找出元组中的最大值和最小值。

# 定义一个包含整数的元组  
tup = (3, 1, 4, 1, 5, 9, 2)

答案

选择题

1. B. 不可变序列
解析：元组（Tuple）是一种不可变序列，一旦创建，其内部元素就不能被修改。

2. C. ()
解析：在Python中，元组是通过圆括号()来定义的，而{}用于定义字典，[]用于定义列表，<>在Python中不是有效的数据结构定义符号。

3. B. 通过索引访问但不能修改
解析：元组是不可变的，所以其内部元素不能通过任何方式修改，但可以通过索引访问。

4. B. tuple = tuple + (element,)
解析：虽然元组本身不可变，但你可以通过创建一个新的元组来“添加”元素，即通过将原元组与包含新元素的元组进行拼接。注意，添加单个元素时需要在元素后加逗号以形成元组。

5. A. len()
解析：len()函数用于获取容器（如列表、元组、字符串等）中元素的数量。

6. A, B, D
解析：元组支持索引访问、切片操作以及拼接操作。但元组是不可变的，所以不支持排序（sort）操作。

7. A, D
解析：选项A直接用圆括号定义了元组，而选项D在表达式中，逗号分隔的值自动形成元组（称为元组打包）。选项B是列表，选项C是集合。

8. C. 元组是不可变的，列表是可变的
解析：元组（Tuple）是不可变的，而列表（List）是可变的。

9. A. 访问速度更快
解析：由于元组是不可变的，Python解释器可以对其进行优化，因此访问元组中的元素通常比访问列表中的元素要快。

10. D. 自动排序
解析：元组不支持自动排序，如果需要排序，需要先将元组转换为列表，排序后再转换回元组（如果需要）。元组的其他特性包括不可变性、支持索引和切片、可以包含重复的元素。

11. A, B
解析：tuple() 调用不带任何参数时创建一个空元组，而 () 也直接表示一个空元组。选项C {} 创建一个空字典，选项D [] 创建一个空列表。

12. A
解析：切片操作 t[2:4] 从索引2开始到索引4（不包括4）的元素，即 (3, 4)。

13. A, B, C, D
解析：元组中的元素可以是任意类型，包括整数、浮点数、字符串和另一个元组。列表不是元组元素的合法类型，因为元组是不可变的，而列表是可变的。

14. A, C, D
解析：尝试通过索引赋值（A）、调用 append() 方法（C，因为元组没有这个方法）或使用 del 语句删除元素（D）都是非法的，因为它们都会尝试修改元组的内容。选项B 是合法的，因为它创建了一个新的元组。

15. A
解析：t * 2 会将元组 t 重复两次并拼接起来，结果是 (1, 2, 3, 1, 2, 3)。

16. B
解析：index() 方法返回元组中某个元素第一次出现的索引位置。因此，t.index('a') 的结果是 1。

17. C
解析：count() 方法返回元组中某个元素出现的次数。

18. B
解析：t = (1,) 是一个包含单个元素1的元组，而 t = 1 只是将变量 t 绑定到整数1上，它们不是等价的。

19. A
解析：if value in t: 是检查元组中是否包含某个值的正确方法。

20. C
解析：元组既可以作为字典的键（只要它们是不可变的且可哈希的），也可以作为字典的值。在Python中，字典的键必须是不可变的类型，如字符串、数字或元组，而值可以是任意类型。

21. A. 可以
解析：元组可以包含任意类型的元素，包括另一个元组。

22. C. (1,)
解析：要创建一个包含单个元素的元组，必须在元素后面加上逗号。选项A (1) 在没有上下文的情况下可能不会被解释为元组，而选项B 1 只是一个整数，选项D ['1'] 是一个包含字符串 '1' 的列表。

23. B. 5
解析：t[-1] 访问元组 t 中的最后一个元素，即5。

24. A
解析：index() 方法返回元组中某个元素第一次出现的索引位置。find() 不是元组的方法，len() 返回元组的长度，count() 返回元素出现的次数。

25. B. 不可变性
解析：元组的不可变性使其成为字典键的理想选择，因为字典的键必须是不可变的。

26. B. 2
解析：count() 方法返回元组中指定元素出现的次数。在元组 (1, 2, 2, 3) 中，元素2出现了两次。

27. A, B, C
解析：元组支持通过for循环、while循环（通过索引）和列表推导式进行迭代。字典推导式用于生成字典，而不是直接迭代元组。

28. A. +
解析：+ 操作符可以用来连接两个元组，生成一个新的元组。

29. C. t[3]
解析：元组 t = (1, 2, 3) 的索引范围是0到2，所以 t[3] 会引发索引错误。

30. A. append()
解析：append() 方法是列表的方法，用于在列表末尾添加一个新元素。由于元组是不可变的，因此没有 append() 方法。sort() 也是列表的方法，但同样地，元组没有这个方法。len() 和 count() 是元组支持的合法方法。

31. B. 元组是不可变的，而列表是可变的
解析：元组和列表的主要区别在于它们的可变性。元组一旦创建就不能被修改（即不可变），而列表则可以被修改（即可变）。

32. B. t + (4,)
解析：append() 和 extend() 是列表的方法，不适用于元组。insert() 也不是元组的方法。要创建一个包含 t 所有元素以及额外元素 4 的新元组，应使用 t + (4,)。

33. D. len(t) == 0
解析：is_empty() 和 empty() 不是Python的内置函数。not t 在元组为空时（即 t = ()）会返回 True，但它不是专门用来检查元组是否为空的函数。len(t) == 0 是检查元组是否为空的正确方法。

34. A. (5, 4, 3, 2, 1)
解析：t[::-1] 使用切片操作来获取元组的反向副本，即 (5, 4, 3, 2, 1)。

35. A. 是
解析：元组支持切片操作，允许你获取元组的一个子集。

36. A. (1, 2, 3, 4, 5, 6)
解析：使用 + 操作符可以将两个元组合并成一个新的元组。

37. C. len()
解析：len() 函数返回元组中元素的数量。

38. A. t == (1, 2, 3)
解析：t == (1, 2, 3) 会比较元组 t 和元组 (1, 2, 3) 是否相等，并返回 True。t == [1, 2, 3] 会比较元组和列表，它们不相等。t[0] == 2 会检查元组的第一个元素是否等于2，这里不等于。t in (1, 2, 3) 会检查元组 t 是否是元组 (1, 2, 3) 的一个元素，显然不是。

39. A. 是
解析：元组可以作为集合的元素，因为元组是不可变的，而集合的元素必须是不可变的。

40. B. ()
解析：t * 0 会生成一个空元组，因为任何元素乘以0都会得到空的结果（对于序列类型而言）。

判断题

1. 答案：B. 错误

解析：元组是一种不可变的数据结构，一旦创建，其元素就不能被修改。

2. 答案：A. 正确

解析：元组可以包含任意类型的元素，包括整数、浮点数、字符串、列表、另一个元组等。

3. 答案：B. 错误

解析：要创建一个包含单个元素的元组，必须在元素后面加上逗号，如 (1,)。

4. 答案：B. 错误

解析：元组不仅支持索引操作，还支持切片操作，允许你获取元组的一个子集。

5. 答案：B. 错误

解析：元组没有 append() 方法，因为它是不可变的。

6. 答案：B. 错误

解析：元组是不可变的，你不能修改其元素的值或顺序。尝试这样做会引发 TypeError。

7. 答案：B. 错误

解析：Python中的集合（set）是另一种内置数据结构，用于存储不重复的元素。元组用于存储有序的元素集合，但不一定是唯一的。

8. 答案：B. 错误

解析：* 操作符在元组上下文中通常不用于合并元组。要合并两个元组，应使用 + 操作符，如 (t1 + t2)。

9. 答案：A. 正确

解析：len() 函数可以用来获取任何序列（包括元组）的长度。

10. 答案：A. 正确

解析：t[-1] 返回元组 t 的最后一个元素，这是Python中索引的常规用法。

11. 答案：A. 正确

解析：元组是不可变的，因此它们是可哈希的，可以用作字典的键。

12. 答案：B. 错误

解析：元组是不可变的，因此你不能使用 del 语句来删除其元素。

13. 答案：A. 正确

解析：虽然元组本身不支持列表推导式的语法，但你可以使用列表推导式来创建一个列表，然后使用 tuple() 函数将列表转换为元组。

14. 答案：A. 正确

解析：count() 方法是元组的一个内置方法，用于返回指定元素在元组中出现的次数。

15. 答案：A. 正确

解析：元组的不可变性意味着一旦它被创建，其内部元素就不能被修改（即不能更改其元素的顺序或值）。

16. 答案：A. 正确

解析：in 关键字在Python中用于检查某个元素是否存在于序列（如元组、列表、字符串等）中。

17. 答案：B. 错误

解析：t = (1,) 确实创建了一个包含单个元素的元组，但 t = 1, 在Python中是一个元组打包表达式，它实际上创建了一个元组 (1,)，但单独使用时（如赋值给变量）看起来可能不像元组。然而，在表达式或函数参数列表中，1, 会被视为元组。但在这个上下文中，t = 1, 并不是完全等价的表达式，因为它后面没有跟逗号来明确这是一个元组。

18. 答案：B. 错误

解析：元组确实支持 + 操作符来连接两个元组，同时也支持 * 操作符来重复元组。例如，(1, 2) * 3 会返回 (1, 2, 1, 2, 1, 2)。

19. 答案：A. 正确

解析：index() 方法是元组的一个内置方法，用于返回指定元素在元组中的索引位置。

20. 答案：B. 错误

解析：元组不仅可以作为集合的元素（因为它们是可哈希的），还可以作为字典的值。

21. 答案：B. 错误

解析：元组没有 remove() 方法，因为它是不可变的。你不能从元组中移除元素。

22. 答案：A. 正确

解析：元组支持嵌套，即你可以在元组中创建包含其他元组的元组。

23. 答案：A. 正确

解析：切片操作 t[1:3] 会返回元组 t 中从索引1（包含）到索引3（不包含）的子元组，即 (2, 3)。

24. 答案：A. 正确

解析：虽然元组本身是不可变的，但如果元组中包含可变元素（如列表），你可以修改这些可变元素的内部状态，但这不会改变元组的结构或大小。

25. 答案：B. 错误

解析：元组没有 sort() 方法，因为它是不可变的。你不能对元组进行排序。如果你需要排序的元组，可以先将其转换为列表，排序后再转换回元组（如果需要的话）。

26. 答案：A. 正确

解析：tuple() 函数可以接受任何可迭代对象（如列表、字符串、元组等）作为参数，并返回一个新的元组。

27. 答案：A. 正确

解析：t = (1,) * 3 确实会创建一个包含三个元素 1 的元组 (1, 1, 1)。这里 (1,) 是一个包含单个元素的元组，乘以 3 会重复这个元组三次。

28. 答案：B. 错误

解析：元组支持 len() 函数来获取其长度，同时也支持 max() 和 min() 函数来找到其最大或最小元素（前提是元组中的元素可以比较大小）。

29. 答案：B. 错误

解析：元组没有 reverse() 方法，因为它是不可变的。你不能改变元组中元素的顺序。

30. 答案：A. 正确

解析：元组可以作为函数的参数传递，也可以作为函数的返回值。这是Python中函数参数和返回值的基本用法之一。

31. 答案：B. 错误

解析：4 in t 会检查 4 是否是元组 t 的一个元素，但在这个例子中，4 不是元组 (1, 2, 3) 的元素，所以表达式会返回 False。

32. 答案：B. 错误

解析：元组既支持 count() 方法来统计某个元素在元组中出现的次数，也支持 index() 方法来查找元素的索引。

33. 答案：A. 正确

解析：你可以使用 for 循环来遍历元组中的每个元素，这是Python中遍历序列（如列表、元组、字符串等）的常用方法。

34. 答案：A. 正确

解析：元组是不可变的，但你可以通过切片操作来获取元组的一部分，并通过连接操作（使用 +）来创建新的元组。

35. 答案：A. 正确

解析：尝试在元组上使用 append() 方法会引发 AttributeError，因为元组没有 append() 方法。元组是不可变的，你不能向其中添加元素。

36. 答案：A. 正确

解析：元组在Python中是不可变的，因此它们是可哈希的，可以用作字典的键。

37. 答案：A. 正确

解析：虽然元组本身是不可变的，但元组中可以包含可变类型的元素（如列表）。这些可变元素的内部状态可以被修改，但不会影响元组的结构或不可变性。

38. 答案：B. 错误

解析：tuple() 函数在将列表转换为元组时，实际上会创建一个新的元组对象，但它不会创建列表的浅拷贝或深拷贝。元组中的元素（在这个例子中是列表）与原始列表共享相同的引用（如果列表是可变的）。然而，这个描述中的“浅拷贝”一词可能会引起混淆，因为通常我们不说元组是列表的浅拷贝；我们只是说元组包含了列表的引用。

39. 答案：A. 正确

解析：Python中的序列（包括元组）支持负数索引，允许你从序列的末尾开始访问元素。

40. 答案：B. 错误

解析：元组是不可变的，因此你不能更改其元素。尝试这样做会引发 TypeError。

41. 答案：A. 正确

解析：你可以使用 + 操作符将两个元组合并为一个新的元组。但是，元组没有 - 操作符来移除元素，因为它们是不可变的。

42. 答案：A. 正确

解析：元组支持切片操作，并且切片的结果仍然是元组类型。

43. 答案：B. 错误

解析：元组没有 insert() 方法，因为它是不可变的。你不能向元组中添加元素。

44. 答案：A. 正确

解析：虽然元组没有内置的排序方法，但你可以使用 sorted() 函数（它会返回一个新的列表）和列表推导式（或元组推导式，在Python 3.5及更高版本中可用）来创建一个排序后的新元组。

45. 答案：A. 正确

解析：在Python中，空元组可以用 () 来表示，这是最直接的方式。另外，tuple() 函数在没有任何参数的情况下也会创建一个空元组。

填空题

1.答案：不可变

解析：元组是一种一旦创建就不能被修改的数据结构，这意味着它的内容是不可变的。

2.答案：()

解析：在Python中，空元组用一对空的圆括号()来表示。

3.答案：(1, 2, 3)

解析：在Python中，使用圆括号()并在内部用逗号分隔元素来创建元组。

4.答案：0

解析：Python中的序列索引（包括元组）都是从0开始的。

5.答案：len()

解析：len()函数用于获取序列（包括元组）的长度。

6.答案：4

解析：由于元组的索引从0开始，所以t[3]访问的是元组中的第四个元素，即4。

7.答案：修改元素（或具体如append、remove、insert等）

解析：元组因其不可变性而不支持任何会改变其内部元素的操作，如添加、删除或修改元素。

8.答案：tuple()

解析：tuple()函数用于将可迭代对象（如列表）转换为元组。

9.答案：(2, 3, 4)

解析：切片操作t[1:4]从索引1开始（包含），到索引4结束（不包含），因此返回的是元组(2, 3, 4)。

10.答案：+

解析：元组支持使用+操作符来连接两个或多个元组，生成一个新的元组。

实战题

实战1：访问元组中的元素

# 定义一个元组  
tup = (1, 2, 3, 4, 5)  
  
# 访问并打印第三个元素  
# 注意：索引从0开始，所以第三个元素的索引是2  
third_element = tup[2]  
print("元组的第三个元素是:", third_element)  
  
# 运行结果  
# 元组的第三个元素是: 3

实战2：元组的不可变性

# 定义一个元组  
tup = (1, 2, 3, 4, 5)  
  
try:  
    # 尝试修改元组中的元素，这会引发TypeError  
    tup[2] = 10  # 这行代码会抛出异常  
    print("修改后的元组:", tup)  # 这行代码不会执行  
except TypeError as e:  
    print("错误:", e)  
    print("原始元组:", tup)  
  
# 运行结果  
# 错误: 'tuple' object does not support item assignment  
# 原始元组: (1, 2, 3, 4, 5)

实战3：元组的切片

# 定义一个元组  
tup = (1, 2, 3, 4, 5)  
  
# 访问并打印第二个到第四个元素（索引从1到3）  
# 注意：切片操作是左闭右开的，所以结束索引是4（但4不包含在结果中）  
sliced_tup = tup[1:4]  
print("元组的第二个到第四个元素是:", sliced_tup)  
  
# 运行结果  
# 元组的第二个到第四个元素是: (2, 3, 4)

实战 4: 元组的拼接

# 定义两个元组  
tup1 = (1, 2, 3)  
tup2 = (4, 5, 6)  
  
# 拼接元组  
concatenated_tup = tup1 + tup2  
  
# 打印结果  
print("拼接后的元组:", concatenated_tup)  
  
# 运行结果  
# 拼接后的元组: (1, 2, 3, 4, 5, 6)

实战 5: 元组中的最大值和最小值

# 定义一个包含整数的元组  
tup = (3, 1, 4, 1, 5, 9, 2)  
  
# 找出并打印最大值和最小值  
max_value = max(tup)  
min_value = min(tup)  
  
print("元组中的最大值是:", max_value)  
print("元组中的最小值是:", min_value)  
  
# 运行结果  
# 元组中的最大值是: 9  
# 元组中的最小值是: 1