本章是Python学习中的一个核心章节，因为它涵盖了Python中最基本、最常用的三种数据结构,理解它们的特性和操作对于编写高效的Python代码至关重要。

第六章：序列：字符串、列表和元组

本章主要围绕Python的三种序列类型展开：字符串、列表 和 元组，它们都共享一些通用的序列操作,但各自又有独特的特性和用途。

本章核心概念总结

在学习具体答案之前,先快速回顾一下本章的核心知识点：

1. 序列的共同操作：

   • 索引：seq[index]，从0开始，支持负数索引（-1表示最后一个）。
   • 分片：seq[start:stop:step],用于提取序列的一部分。
   • 序列相加：seq1 + seq2,连接两个同类型的序列。
   • 乘法：seq * n,将序列重复n次。
   • 成员资格：item in seq,检查元素是否存在于序列中。
   • 长度、最大值、最小值：len(), max(), min()。

2. 字符串：

   
   （图片来源网络，侵删）
   • 不可变性：字符串创建后不能被修改，任何修改操作都会返回一个新的字符串。
   • 格式化： 操作符和 .format() 方法是两种主要的格式化方式。
   • 字符串方法：.upper(), .lower(), .find(), .split(), .join(), .strip() 等非常常用。

3. 列表：

   • 可变性：列表是可变的，可以随时修改其内容（增、删、改、查）。
   • 列表操作：除了序列的通用操作，还有 .append(), .insert(), .remove(), .pop(), .sort() 等专门用于修改列表的方法。
   • 列表推导式：一种简洁、高效地创建列表的方式。

4. 元组：

   • 不可变性：元组创建后不能被修改，可以看作是“只读”的列表。
   • 用途：通常用于存储不同类型的相关数据，作为字典的键,或者函数返回多个值时使用。
   • 单元素元组：创建只有一个元素的元组时，需要在元素后加一个逗号，如 (1,),以避免与普通括号表达式混淆。

5. 内置函数：

   • enumerate(): 在迭代时同时获取索引和值。
   • zip(): 将多个序列“缝合”在一起,返回一个包含元组的迭代器。

章节习题答案与解析

以下是《Python核心编程（第三版）》第六章部分典型习题的答案和详细解析。

1 字符串

习题 6-1. 字符串

a. 创建一个名为 my_string 的字符串变量，并将其赋值为 "Hello World"。 b. 打印 my_string 的第一个字符。 c. 打印 my_string 的最后一个字符。 d. 打印 my_string 的前三个字符。 e. 打印 my_string 的最后三个字符。 f. 打印 my_string 的第二个到第五个字符。 g. 打印 my_string 中所有字符，除了最后一个。 h. 打印 my_string 中所有字符，除了第一个。 i. 打印 my_string 的长度。 j. 使用 操作符将 my_string 与 " Python Programming" 连接起来，并打印结果。 k. 使用 操作符将 my_string 重复打印3次。

答案与解析：

# a. 创建字符串
my_string = "Hello World"
# b. 打印第一个字符 (索引从0开始)
print(f"a. 第一个字符: {my_string[0]}")
# c. 打印最后一个字符 (负数索引，-1表示最后一个)
print(f"b. 最后一个字符: {my_string[-1]}")
# d. 打印前三个字符 (分片 [start:stop]，stop是 exclusive 的)
print(f"c. 前三个字符: {my_string[0:3]}") # 或者 my_string[:3]
# e. 打印最后三个字符
print(f"d. 最后三个字符: {my_string[-3:]}")
# f. 打印第二个到第五个字符 (索引1到4)
print(f"e. 第二个到第五个字符: {my_string[1:5]}")
# g. 打印除了最后一个字符的所有字符
print(f"f. 除了最后一个字符: {my_string[:-1]}")
# h. 打印除了第一个字符的所有字符
print(f"g. 除了第一个字符: {my_string[1:]}")
# i. 打印长度
print(f"h. 字符串长度: {len(my_string)}")
# j. 使用 + 连接字符串
new_string = my_string + " Python Programming"
print(f"i. 连接后的字符串: {new_string}")
# k. 使用 * 重复字符串
print(f"j. 重复三次:\n{my_string * 3}")

核心要点：

• 索引：[i] 用于获取单个元素。
• 分片：[start:stop:step] 是提取子序列的强大工具。stop 索引本身不包含在结果中。
• 不可变性：虽然可以通过索引访问字符，但不能直接修改，my_string[0] = 'h' 会引发 TypeError。

2 列表

习题 6-2. 列表

a. 创建一个名为 my_list 的列表，包含整数 1, 2, 3, 4, 5。 b. 打印 my_list 的第二个元素。 c. 打印 my_list 的最后一个元素。 d. 使用 append() 方法向 my_list 添加一个整数 6。 e. 使用 insert() 方法在索引 1 的位置插入一个整数 10。 f. 使用 pop() 方法移除并返回最后一个元素。 g. 使用 remove() 方法移除值为 10 的元素。 h. 打印修改后的 my_list 的长度。 i. 对 my_list 进行排序（从小到大）。 j. 对 my_list 进行排序（从大到小）。

答案与解析：

# a. 创建列表
my_list = [1, 2, 3, 4, 5]
print(f"a. 初始列表: {my_list}")
# b. 打印第二个元素 (索引1)
print(f"b. 第二个元素: {my_list[1]}")
# c. 打印最后一个元素
print(f"c. 最后一个元素: {my_list[-1]}")
# d. 使用 append() 添加元素
my_list.append(6)
print(f"d. 添加6后: {my_list}")
# e. 使用 insert() 在指定位置插入元素
my_list.insert(1, 10) # 在索引1的位置插入10
print(f"e. 在索引1插入10后: {my_list}")
# f. 使用 pop() 移除并返回最后一个元素
last_element = my_list.pop()
print(f"f. 弹出的元素: {last_element}")
print(f"    弹出后的列表: {my_list}")
# g. 使用 remove() 移除指定值的元素
# 注意：如果列表中有多个10，remove()只会移除第一个
my_list.remove(10)
print(f"g. 移除10后: {my_list}")
# h. 打印长度
print(f"h. 列表长度: {len(my_list)}")
# i. 从小到大排序 (原地排序，修改原列表)
my_list.sort()
print(f"i. 从小到大排序后: {my_list}")
# j. 从大到小排序
my_list.sort(reverse=True)
print(f"j. 从大到小排序后: {my_list}")

核心要点：

• 可变性：列表是可变的，.append(), .insert(), .pop(), .remove(), .sort() 等方法都会直接修改原始列表。
• pop() vs remove()：pop() 根据索引移除元素并返回该元素；remove() 根据值移除元素，不返回任何值（返回 None）。
• sort() vs sorted()：list.sort() 是列表的一个方法，会原地排序，不返回新列表。sorted(list) 是一个内置函数，会返回一个新的已排序列表,原列表不变。

3 字符串与列表

习题 6-3. 字符串与列表

a. 创建一个字符串变量 s，赋值为 "a,b,c,d,e"。 b. 使用 split() 方法将字符串 s 分割成一个列表。 c. 打印这个新列表。 d. 创建一个列表 l，包含字符串 'a', 'b', 'c', 'd', 'e'。 e. 使用 join() 方法将列表 l 的元素连接成一个字符串，用逗号作为分隔符。 f. 打印这个新字符串。

答案与解析：

# a. 创建字符串
s = "a,b,c,d,e"
# b. 使用 split() 分割字符串
# 默认按空白分割，这里指定按逗号分割
list_from_string = s.split(',')
print(f"b. 分割后的列表: {list_from_string}")
# c. (已在b中打印)
# d. 创建列表
l = ['a', 'b', 'c', 'd', 'e']
# e. 使用 join() 连接列表
# 注意：join() 是字符串的方法，列表中的元素也必须是字符串
string_from_list = ','.join(l)
print(f"e. 连接后的字符串: {string_from_list}")
# f. (已在e中打印)

核心要点：

• split()：将字符串根据指定的分隔符（默认为任意空白字符）拆分成一个列表,这是将文本数据转换为结构化数据的关键方法。
• join()：将一个可迭代对象（如列表）中的字符串元素用指定的分隔符连接成一个新的字符串，这是 split() 的逆操作，非常高效,注意调用者是分隔符字符串本身。

4 列表推导式

习题 6-4. 列表推导式

使用列表推导式生成一个包含数字 1 到 10 的平方的列表。

答案与解析：

列表推导式提供了一种简洁、Pythonic的方式来创建列表。

标准列表推导式

# 生成一个包含1到10的平方的列表
squares = [x**2 for x in range(1, 11)]
print(squares)
# 输出: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

解析：

• [ ... ]：方括号表示这是一个列表推导式,最终会生成一个列表。
• x**2：这是要生成的列表元素的表达式，对于 range 中的每一个 x，都会计算 x**2。
• for x in range(1, 11)：这是迭代部分，它遍历 range(1, 11) 生成的数字序列（从1到10）。

进阶：带条件的列表推导式 （虽然本章可能未明确要求,但这是列表推导式的重要延伸）

假设我们只想要1到10中偶数的平方：

even_squares = [x**2 for x in range(1, 11) if x % 2 == 0]
print(even_squares)
# 输出: [4, 16, 36, 64, 100]

解析：在 for 循环后加上 if 条件，只有满足条件的 x 才会参与计算。

5 元组

习题 6-5. 元组

a. 创建一个名为 my_tuple 的元组，包含整数 1, 2, 3。 b. 尝试修改 my_tuple 的第一个元素为 99，并观察会发生什么。 c. 打印 my_tuple 的长度。 d. 打印 my_tuple 的第二个元素。 e. 创建一个名为 single_element_tuple 的元组，只包含一个整数 100。 f. 打印 single_element_tuple 的类型，并解释为什么它不是 int 类型。

答案与解析：

# a. 创建元组
my_tuple = (1, 2, 3)
print(f"a. 初始元组: {my_tuple}")
# b. 尝试修改元组 (会引发错误)
try:
    my_tuple[0] = 99
except TypeError as e:
    print(f"b. 尝试修改元组时发生错误: {e}")
    # 错误信息: 'tuple' object does not support item assignment
# c. 打印长度
print(f"c. 元组长度: {len(my_tuple)}")
# d. 打印第二个元素
print(f"d. 第二个元素: {my_tuple[1]}")
# e. 创建单元素元组 (注意逗号!)
single_element_tuple = (100,)
print(f"e. 单元素元组: {single_element_tuple}")
# f. 打印类型并解释
print(f"f. single_element_tuple 的类型是: {type(single_element_tuple)}")
print("    解释: 为了区分单个元组和括号内的数学表达式或函数调用，Python要求单元素元组必须在元素后加一个逗号。")

核心要点：

• 不可变性：元组的最大特点就是不可变，一旦创建，就不能添加、删除或修改其元素,这保证了数据的安全性。
• 单元素元组：(100) 会被解释为整数 100，而 (100,) 才是包含一个整数100的元组,这个逗号是必须的。
• 用途：当数据不应该被改变时，使用元组可以防止意外修改,函数返回的多个值实际上就是作为一个元组返回的。

第六章是Python基础中承上启下的一章，掌握了字符串、列表和元组的操作,你就掌握了处理大部分基础数据的能力。

• 字符串用于处理文本，记住其不可变性。
• 列表是功能最强大的序列，用于存储可变的数据集合,熟练掌握其方法是关键。
• 元组用于存储固定的、不应被修改的数据集合,是字典的理想键。

通过完成这些习题，你应该能够熟练运用索引、分片、序列方法以及列表推导式来处理这些核心数据结构。