Python 模拟考试 5 — 解析

📝 一、单选题

第 1 题

以下代码的运行结果是（）。

print(f"{2 + 3 ** 2}")

选项	内容
A	{2 + 3 ** 2}
B	11 ✅
C	25
D	报错

答案

B

📖 解析：

• f-string 中的 {} 内是 Python 表达式，会被计算后替换
• 3 ** 2 = 9（先算幂运算，优先级高于加法）
• 2 + 9 = 11
• 最终输出 "11"

# f-string 表达式计算
f"{2 + 3 ** 2}"    # "11"（先幂后加）
f"{(2 + 3) ** 2}"  # "25"（括号改变优先级）
f"{2 + 3}**2"      # "5**2"（**2 在花括号外，不参与计算）

🔑 知识点：f-string 与运算符优先级

• f-string 中 {} 内的代码作为 Python 表达式执行
• 运算符优先级：** > * / // % > + -
• 普通字符串中的 {} 不会被计算，只有 f-string（带 f 前缀）才会

优先级	运算符	示例
高	**	3**2 = 9
中	* / // %	10//3 = 3
低	+ -	2+9 = 11

📌 记忆要点

1. f-string 中 {} 内是表达式，会被计算
2. 幂运算 ** 优先级高于加法 +
3. 需要改变优先级时使用括号 ()

---

第 2 题

以下代码的运行结果是（）。

a, b = 10, 20
a, b = b, a
print(a, b)

选项	内容
A	10 20
B	20 10 ✅
C	报错
D	20 20

答案

B

📖 解析：

• a, b = 10, 20：元组打包赋值，a=10, b=20
• a, b = b, a：右侧先求值为 (20, 10)，然后同时赋值给左侧
• 这是 Python 中交换两个变量的标准写法，无需临时变量

# Python 交换变量的原理
a, b = 10, 20
# 等价于：
temp = (b, a)  # 先计算右侧 → (20, 10)
a, b = temp    # 再赋值 → a=20, b=10

# 对比其他语言的写法
# C/Java: int temp = a; a = b; b = temp;

🔑 知识点：元组解包赋值

• Python 支持多变量同时赋值（元组解包）
• 右侧表达式先全部求值，再同时赋给左侧变量
• 交换变量：a, b = b, a（一步完成，不会冲突）

写法	结果
a, b = b, a	交换 a 和 b ✅
a = b; b = a	a 和 b 都变成 b 的值 ❌

📌 记忆要点

1. a, b = b, a 是 Python 交换变量的简洁写法
2. 右侧先全部求值，再赋值给左侧
3. 支持更多变量的解包：a, b, c = 1, 2, 3

---

第 3 题

表达式 round(2.5) 的结果是（）。

选项	内容
A	2.5
B	2 ✅
C	3
D	2.0

答案

B

📖 解析：

• Python 3 的 round() 使用银行家舍入法（四舍六入五成双）
• 当小数部分恰好为 0.5 时，向最近的偶数取整
• round(2.5) → 2（2 是偶数，向 2 取整）
• round(3.5) → 4（4 是偶数，向 4 取整）

round(2.5)   # 2（向偶数2取整）
round(3.5)   # 4（向偶数4取整）
round(2.6)   # 3（非0.5，正常四舍五入）
round(2.4)   # 2（非0.5，正常四舍五入）
round(1.5)   # 2（向偶数2取整）
round(0.5)   # 0（向偶数0取整）

🔑 知识点：round() 函数与银行家舍入

表达式	结果	说明
round(2.5)	2	向偶数取整
round(3.5)	4	向偶数取整
round(2.6)	3	正常四舍五入
round(2.4)	2	正常四舍五入
round(2.56, 1)	2.6	保留1位小数

• 银行家舍入法（四舍六入五成双）：当值恰好为 0.5 时，向最近的偶数取整
• 这种方式可以减少大量数据计算时的累积误差

📌 记忆要点

1. Python 3 的 round(2.5) = 2，不是 3（银行家舍入）
2. 0.5 时向偶数取整：round(3.5) = 4
3. 非 0.5 时正常四舍五入

---

第 4 题

表达式 chr(ord('A') + 32) 的结果是（）。

选项	内容
A	'A'
B	'33'
C	'a' ✅
D	报错

答案

C

📖 解析：

• ord('A') 返回字符 'A' 的 ASCII 码值，即 65
• 65 + 32 = 97
• chr(97) 返回 ASCII 码 97 对应的字符，即 'a'
• 大写字母和小写字母在 ASCII 码中相差 32

ord('A')  # 65
ord('a')  # 97
97 - 65   # 32（大小写差值）

# 常用 ASCII 码
ord('0')  # 48
ord('9')  # 57
ord('A')  # 65
ord('Z')  # 90
ord('a')  # 97
ord('z')  # 122

🔑 知识点：ord() 与 chr() 函数

函数	功能	示例
ord(c)	字符 → ASCII 码	ord('A') → 65
chr(n)	ASCII 码 → 字符	chr(65) → 'A'

• 两者互为逆操作：chr(ord('A')) → 'A'
• 大写字母 A-Z：65-90
• 小写字母 a-z：97-122
• 数字 0-9：48-57

📌 记忆要点

1. ord() 字符转数字，chr() 数字转字符
2. 大小写差值固定为 32
3. 实际转换大小写推荐用 upper() / lower()

---

第 5 题

表达式 isinstance(True, int) 的结果是（）。

选项	内容
A	True ✅
B	False
C	报错
D	None

答案

A

📖 解析：

• 在 Python 中，bool 是 int 的子类
• True 本质上是整数 1，False 本质上是整数 0
• isinstance(True, int) 返回 True，因为 bool 继承自 int

isinstance(True, int)    # True
isinstance(True, bool)   # True
isinstance(False, int)   # True
isinstance(1, bool)      # False（1是int，不是bool）

True + True    # 2
True + 1       # 2
False + 1      # 1
int(True)      # 1
int(False)     # 0

🔑 知识点：bool 是 int 的子类

• Python 的类型继承关系：bool → int → object
• True 等价于 1，False 等价于 0
• isinstance() 检查类型时，子类实例也是父类的实例
• type(True) is int 返回 False，isinstance(True, int) 返回 True

表达式	结果	说明
type(True)	<class 'bool'>	精确类型
isinstance(True, int)	True	包含继承关系
type(True) is int	False	精确类型比较
True + True	2	可参与算术运算

📌 记忆要点

1. bool 是 int 的子类，True = 1，False = 0
2. isinstance() 考虑继承关系，type() 只看精确类型
3. 布尔值可以参与算术运算

---

第 6 题

以下代码的运行结果是（）。

print("Hello World".swapcase())

选项	内容
A	hello world
B	hELLO wORLD ✅
C	HELLO WORLD
D	Hello World

答案

B

📖 解析：

• swapcase() 方法将字符串中的大写字母转小写，小写字母转大写
• "Hello World" 中：H→h, e→E, l→L, l→L, o→O, 空格不变, W→w, o→O, r→R, l→L, d→D
• 结果："hELLO wORLD"

"Hello World".swapcase()   # "hELLO wORLD"
"Python3".swapcase()       # "pYTHON3"（数字不变）
"".swapcase()               # ""（空字符串不变）
"ABC".swapcase()            # "abc"
"abc".swapcase()            # "ABC"

🔑 知识点：字符串大小写转换方法

方法	功能	示例
upper()	全部转大写	"Hello".upper() → "HELLO"
lower()	全部转小写	"Hello".lower() → "hello"
capitalize()	首字母大写	"hello world".capitalize() → "Hello world"
title()	每个单词首字母大写	"hello world".title() → "Hello World"
swapcase()	大小写互换	"Hello".swapcase() → "hELLO"

📌 记忆要点

1. swapcase() 大写变小写，小写变大写，非字母不变
2. 所有字符串方法都返回新字符串，原字符串不变
3. 区分 capitalize()（仅首字母大写）和 title()（每个单词首字母大写）

---

第 7 题

表达式 dict.fromkeys([1, 2, 3]) 的结果是（）。

选项	内容
A	{1: 1, 2: 2, 3: 3}
B	[1, 2, 3]
C	{1: 0, 2: 0, 3: 0}
D	{1: None, 2: None, 3: None} ✅

答案

D

📖 解析：

• dict.fromkeys(seq) 用序列中的元素作为键，值默认为 None
• dict.fromkeys(seq, value) 可以指定所有键的默认值

dict.fromkeys([1, 2, 3])          # {1: None, 2: None, 3: None}
dict.fromkeys([1, 2, 3], 0)       # {1: 0, 2: 0, 3: 0}
dict.fromkeys("abc")              # {'a': None, 'b': None, 'c': None}
dict.fromkeys(["name", "age"], "") # {'name': '', 'age': ''}

🔑 知识点：dict.fromkeys() 方法

用法	结果
dict.fromkeys([1,2,3])	{1:None, 2:None, 3:None}
dict.fromkeys([1,2,3], 0)	{1:0, 2:0, 3:0}
dict.fromkeys("ab")	{'a':None, 'b':None}

• 注意陷阱：如果值是可变对象（如列表），所有键共享同一个对象

d = dict.fromkeys([1, 2, 3], [])
d[1].append(10)
print(d)  # {1: [10], 2: [10], 3: [10]}（全部被修改！）

📌 记忆要点

1. dict.fromkeys(seq) 默认值为 None
2. dict.fromkeys(seq, val) 指定统一默认值
3. 值为可变对象时，所有键共享同一对象（与默认参数陷阱类似）

---

第 8 题

表达式 list(enumerate(['a', 'b'], 1)) 的结果是（）。

选项	内容
A	[(0, 'a'), (1, 'b')]
B	[['a', 1], ['b', 2]]
C	[(1, 'a'), (2, 'b')] ✅
D	{1: 'a', 2: 'b'}

答案

C

📖 解析：

• enumerate(iterable, start) 为可迭代对象生成带索引的元组
• 第一个参数是可迭代对象，第二个参数是起始索引（默认为 0）
• enumerate(['a', 'b'], 1) 生成：(1, 'a'), (2, 'b')
• list() 将迭代器转为列表

list(enumerate(['a', 'b']))       # [(0, 'a'), (1, 'b')]（默认从0开始）
list(enumerate(['a', 'b'], 1))    # [(1, 'a'), (2, 'b')]（从1开始）
list(enumerate(['a', 'b'], 10))   # [(10, 'a'), (11, 'b')]（从10开始）

# 常见用法：for循环中同时获取索引和值
for i, v in enumerate(['a', 'b', 'c'], 1):
    print(i, v)
# 1 a
# 2 b
# 3 c

🔑 知识点：enumerate() 函数

用法	结果	说明
enumerate(seq)	索引从0开始	默认
enumerate(seq, start)	索引从start开始	自定义起始
for i, v in enumerate(seq)	同时获取索引和值	最常用

📌 记忆要点

1. enumerate() 返回 (索引, 值) 元组的迭代器
2. 第二个参数指定起始索引，默认为 0
3. 常用于 for i, v in enumerate(seq) 同时获取索引和值

---

第 9 题

表达式 divmod(20, 6) 的结果是（）。

选项	内容
A	(4, 2)
B	(3, 2) ✅
C	(2, 8)
D	3.33

答案

B

📖 解析：

• divmod(a, b) 返回 (a // b, a % b) 的元组
• 20 // 6 = 3（商）
• 20 % 6 = 2（余数）
• 结果：(3, 2)

divmod(20, 6)    # (3, 2)  → 20 = 6*3 + 2
divmod(17, 5)    # (3, 2)  → 17 = 5*3 + 2
divmod(10, 3)    # (3, 1)  → 10 = 3*3 + 1
divmod(9, 3)     # (3, 0)  → 9 = 3*3 + 0

# 等价于
quotient, remainder = divmod(20, 6)
# 等价于 quotient = 20 // 6; remainder = 20 % 6

🔑 知识点：divmod() 函数

• divmod(a, b) 等价于 (a // b, a % b)
• 返回商和余数的元组
• 常用于分页、时间转换等场景

表达式	结果	说明
divmod(20, 6)	(3, 2)	20÷6=3余2
divmod(100, 7)	(14, 2)	100÷7=14余2
divmod(125, 60)	(2, 5)	125秒=2分5秒

📌 记忆要点

1. divmod(a, b) 返回 (商, 余数) 元组
2. 等价于 (a // b, a % b)
3. 可用 q, r = divmod(a, b) 解包赋值

---

第 10 题

表达式 all([1, 2, 0, 3]) 的结果是（）。

选项	内容
A	True
B	0
C	False ✅
D	报错

答案

C

📖 解析：

• all() 对可迭代对象中的每个元素进行布尔判断
• 只有所有元素都为真时才返回 True，否则返回 False
• 列表中 0 是假值，所以 all([1, 2, 0, 3]) 返回 False

all([1, 2, 3])     # True（全部为真）
all([1, 2, 0, 3])  # False（0 是假值）
all([1, 2, "", 3])  # False（空字符串是假值）
all([])             # True（空序列，特殊情况）
any([1, 2, 0, 3])  # True（至少一个为真）
any([0, "", None])  # False（全部为假）
any([])             # False（空序列，特殊情况）

🔑 知识点：all() 与 any() 函数

函数	规则	空序列
all()	全部为真 → True	all([]) → True
any()	至少一个为真 → True	any([]) → False

常见假值：0, 0.0, "", [], (), {}, set(), None, False

📌 记忆要点

1. all() 全真才真，any() 一真即真
2. all([]) = True，any([]) = False（特殊规则）
3. 0 在布尔上下文中为 False

---

第 11 题

以下代码的运行结果是（）。

x = [3, 1, 2]
y = sorted(x)
print(x, y)

选项	内容
A	[1, 2, 3] [1, 2, 3]
B	[3, 1, 2] [1, 2, 3] ✅
C	[1, 2, 3] None
D	报错

答案

B

📖 解析：

• sorted() 返回一个新的排序列表，不修改原列表
• x 保持不变：[3, 1, 2]
• y 是排序后的新列表：[1, 2, 3]

# sorted() — 返回新列表，不修改原列表
x = [3, 1, 2]
y = sorted(x)
print(x)  # [3, 1, 2]（原列表不变）
print(y)  # [1, 2, 3]（新列表）

# sort() — 原地排序，修改原列表，返回 None
x = [3, 1, 2]
result = x.sort()
print(x)      # [1, 2, 3]（原列表被修改）
print(result)  # None

🔑 知识点：sorted() vs sort()

方法	是否修改原列表	返回值	适用对象
sorted(x)	否	新列表	任何可迭代对象
x.sort()	是（原地排序）	None	仅列表

• sorted() 可用于字符串、元组等任何可迭代对象
• sort() 只能用于列表
• 两者都支持 reverse=True 降序和 key 参数

📌 记忆要点

1. sorted() 不修改原列表，返回新列表
2. sort() 修改原列表，返回 None
3. sorted() 可用于任何可迭代对象，sort() 只能用于列表

---

第 12 题

以下代码的运行结果是（）。

lst = [10, 20, 30, 40]
x = lst.pop(1)
print(x, lst)

选项	内容
A	10 [20, 30, 40]
B	20 [10, 30, 40] ✅
C	40 [10, 20, 30]
D	1 [10, 20, 30, 40]

答案

B

📖 解析：

• pop(index) 删除并返回指定索引位置的元素
• lst.pop(1) 删除索引 1 的元素（值为 20），并返回 20
• 删除后 lst 变为 [10, 30, 40]

lst = [10, 20, 30, 40]
lst.pop(1)     # 返回 20，lst 变为 [10, 30, 40]
lst.pop()      # 返回 40（默认删除最后一个），lst 变为 [10, 30]
lst.pop(0)     # 返回 10，lst 变为 [30]

# pop() vs remove() vs del
lst = [10, 20, 30]
lst.pop(1)      # 按索引删除，返回被删元素：20
lst.remove(10)  # 按值删除第一个匹配，不返回值
del lst[0]      # 按索引删除，不返回值

🔑 知识点：列表删除方法

方法	按什么删除	是否返回值	示例
pop(index)	索引	返回被删元素	lst.pop(1)
pop()	末尾	返回被删元素	lst.pop()
remove(value)	值（第一个）	无返回值	lst.remove(20)
del lst[index]	索引	无返回值	del lst[1]

📌 记忆要点

1. pop(index) 按索引删除并返回元素
2. pop() 不传参时删除并返回最后一个元素
3. remove() 按值删除，del 按索引删除，都不返回值

---

第 13 题

以下代码的运行结果是（）。

print("hello world python".title())

选项	内容
A	Hello world python
B	Hello World Python ✅
C	HELLO WORLD PYTHON
D	hello world python

答案

B

📖 解析：

• title() 将字符串中每个单词的首字母转为大写，其余字母转为小写
• "hello world python" → "Hello World Python"

"hello world python".title()   # "Hello World Python"
"HELLO WORLD".title()          # "Hello World"（其余字母也变小写）
"it's a test".title()          # "It'S A Test"（注意：'s 中的 S 也大写了）
"hello world".capitalize()     # "Hello world"（仅第一个单词首字母大写）

🔑 知识点：title() 与 capitalize() 的区别

方法	功能	示例
title()	每个单词首字母大写	"hello world".title() → "Hello World"
capitalize()	仅第一个字母大写	"hello world".capitalize() → "Hello world"
upper()	全部大写	"hello".upper() → "HELLO"
lower()	全部小写	"HELLO".lower() → "hello"

注意：title() 对含撇号的单词可能不符合预期，如 "it's".title() → "It'S"

📌 记忆要点

1. title() 每个单词首字母大写，其余小写
2. capitalize() 仅第一个字母大写
3. title() 对撇号后的字母也会大写

---

第 14 题

表达式 list(zip([1, 2, 3, 4], ['a', 'b', 'c'])) 的结果是（）。

选项	内容
A	[(1, 'a'), (2, 'b'), (3, 'c'), (4, None)]
B	[(1, 'a'), (2, 'b'), (3, 'c'), (4, '')]
C	[(1, 'a'), (2, 'b'), (3, 'c')] ✅
D	报错

答案

C

📖 解析：

• zip() 将多个可迭代对象按位置配对
• 当可迭代对象长度不一致时，zip() 以最短的为准
• 第一个列表有 4 个元素，第二个有 3 个，结果只有 3 对

list(zip([1, 2, 3, 4], ['a', 'b', 'c']))
# [(1, 'a'), (2, 'b'), (3, 'c')]  — 以短的为准

list(zip([1, 2], ['a', 'b', 'c']))
# [(1, 'a'), (2, 'b')]  — 以短的为准

list(zip([1, 2, 3], ['a', 'b', 'c']))
# [(1, 'a'), (2, 'b'), (3, 'c')]  — 长度相同

# 常见用法：同时遍历多个列表
names = ['Alice', 'Bob', 'Charlie']
scores = [85, 92, 78]
for name, score in zip(names, scores):
    print(name, score)

🔑 知识点：zip() 函数

• zip() 将多个可迭代对象打包为元组的迭代器
• 长度不一致时，以最短的为准
• zip() 返回迭代器，需用 list() 等转换

用法	结果
zip([1,2], ['a','b'])	迭代器：(1,'a'), (2,'b')
zip([1,2,3], ['a','b'])	迭代器：(1,'a'), (2,'b')
zip(*[(1,'a'),(2,'b')])	解包：(1,2), ('a','b')

📌 记忆要点

1. zip() 按位置配对，以最短的可迭代对象为准
2. 返回迭代器，需要 list() 转换查看
3. zip(*pairs) 可做逆操作（解包）

---

第 15 题

以下代码的运行结果是（）。

a = b = [1]
a.append(2)
print(b)

选项	内容
A	[1]
B	[1, 2] ✅
C	[2]
D	报错

答案

B

📖 解析：

• a = b = [1] 让 a 和 b 指向同一个列表对象
• a.append(2) 修改了这个列表对象
• 因为 b 也指向同一个对象，所以 b 也变成了 [1, 2]

# 链式赋值 → 指向同一对象
a = b = [1]
a.append(2)
print(a)  # [1, 2]
print(b)  # [1, 2]  ← b 也变了！
print(a is b)  # True（同一对象）

# 独立创建 → 不同对象
a = [1]
b = [1]
a.append(2)
print(a)  # [1, 2]
print(b)  # [1]     ← b 不受影响
print(a is b)  # False

# 使用 copy 创建独立副本
a = [1]
b = a.copy()  # 或 b = a[:]
a.append(2)
print(b)  # [1]     ← b 不受影响

🔑 知识点：链式赋值与引用

• a = b = [1] 两个变量指向同一个对象
• 修改可变对象（列表、字典、集合）时，所有引用都能看到变化
• 如需独立副本，使用 copy() 或切片 [:]

写法	a 和 b 的关系	修改 a 是否影响 b
a = b = [1]	同一对象	是
a = [1]; b = [1]	不同对象	否
a = [1]; b = a.copy()	不同对象（浅拷贝）	否

📌 记忆要点

1. a = b = [1] 链式赋值，a 和 b 指向同一对象
2. 修改可变对象会影响所有引用
3. 需要独立副本时使用 .copy() 或 [:]

---

第 16 题

以下代码的运行结果是（）。

lst = [[1, 2], [3, [4, 5]]]
print(lst[1][1][0])

选项	内容
A	1
B	3
C	4 ✅
D	报错

答案

C

📖 解析：

逐步分析索引： - lst[1] → [3, [4, 5]]（第二个元素） - lst[1][1] → [4, 5]（其中的第二个元素） - lst[1][1][0] → 4（其中的第一个元素）

lst = [[1, 2], [3, [4, 5]]]
lst[0]       # [1, 2]
lst[1]       # [3, [4, 5]]
lst[1][0]    # 3
lst[1][1]    # [4, 5]
lst[1][1][0] # 4
lst[1][1][1] # 5

🔑 知识点：嵌套列表索引

• 多层嵌套时，从外向内逐层索引
• 每层索引对应一个维度

表达式	值	说明
lst[0]	[1, 2]	第一层第0个
lst[1]	[3, [4, 5]]	第一层第1个
lst[1][0]	3	第二层第0个
lst[1][1]	[4, 5]	第二层第1个
lst[1][1][0]	4	第三层第0个

📌 记忆要点

1. 嵌套列表从外向内逐层索引
2. lst[i][j][k] 先取第 i 个，再取第 j 个，再取第 k 个
3. 索引从 0 开始

---

第 17 题

以下代码的运行结果是（）。

d = {'a': 1}
result = d.setdefault('a', 100)
print(result)

选项	内容
A	100
B	1 ✅
C	None
D	报错

答案

B

📖 解析：

• setdefault(key, default) 的行为：
• 如果键存在，返回该键对应的值，不做任何修改
• 如果键不存在，添加键并设为 default，然后返回 default
• 字典 d 中键 'a' 已存在，值为 1
• d.setdefault('a', 100) 返回已存在的值 1，字典不变

d = {'a': 1}

# 键已存在 → 返回现有值，字典不变
d.setdefault('a', 100)   # 返回 1，d 仍为 {'a': 1}

# 键不存在 → 添加并返回默认值
d.setdefault('b', 200)   # 返回 200，d 变为 {'a': 1, 'b': 200}

# 不指定默认值 → 默认为 None
d.setdefault('c')         # 返回 None，d 变为 {'a': 1, 'b': 200, 'c': None}

🔑 知识点：dict.setdefault() 方法

情况	行为	返回值
键存在	不做修改	返回已有值
键不存在	添加键值对	返回默认值

• setdefault(key) — 默认值为 None
• setdefault(key, default) — 指定默认值

与 get() 的区别： |方法|键不存在时|是否修改字典| |---|---|---| |get(key)|返回 None|否| |get(key, default)|返回 default|否| |setdefault(key)|返回 None，添加键|是| |setdefault(key, default)|返回 default，添加键|是|

📌 记忆要点

1. setdefault() 键存在时返回已有值，不修改字典
2. setdefault() 键不存在时添加键值对，返回默认值
3. get() 不修改字典，setdefault() 可能修改字典

---

第 18 题

表达式 "12.5".isdigit() 的结果是（）。

选项	内容
A	True
B	12.5
C	False ✅
D	报错

答案

C

📖 解析：

• isdigit() 判断字符串是否全部由数字字符组成
• "12.5" 包含小数点 .，不是数字字符
• 因此返回 False

"123".isdigit()      # True（全是数字）
"12.5".isdigit()     # False（包含小数点）
"12a".isdigit()      # False（包含字母）
"".isdigit()         # False（空字符串）
"０１２".isdigit()   # True（全角数字也是数字字符）

🔑 知识点：字符串判断方法

方法	判断内容	"123"	"12.5"	"abc"
isdigit()	纯数字字符	True	False	False
isalpha()	纯字母	False	False	True
isalnum()	字母或数字	True	False	True
isnumeric()	数字字符（含中文数字）	True	False	False

• isdigit() 只认 0-9 和全角数字，不认小数点、负号
• isnumeric() 比 isdigit() 范围更广，还认中文数字（如 "一二三"）

📌 记忆要点

1. isdigit() 判断是否全是数字字符，小数点不是数字
2. 判断是否可转为数字应用 try: float(s) 而非 isdigit()
3. isalpha() 纯字母，isalnum() 字母或数字

---

第 19 题

表达式 "42".zfill(5) 的结果是（）。

选项	内容
A	"42 "
B	" 42"
C	"00042" ✅
D	"42000"

答案

C

📖 解析：

• zfill(width) 在字符串左侧填充零，使字符串达到指定宽度
• "42" 长度为 2，需要填充到 5，所以左侧补 3 个零
• 结果："00042"

"42".zfill(5)      # "00042"（补3个零）
"42".zfill(2)      # "42"（已够长，不补）
"42".zfill(10)     # "0000000042"
"-42".zfill(5)     # "-0042"（负号在零前面）
"abc".zfill(5)     # "00abc"（非数字也可以用）

🔑 知识点：字符串对齐方法

方法	功能	示例
zfill(width)	左侧补零	"42".zfill(5) → "00042"
ljust(width, char)	左对齐，右侧填充	"42".ljust(5, '-') → "42---"
rjust(width, char)	右对齐，左侧填充	"42".rjust(5, '-') → "---42"
center(width, char)	居中，两侧填充	"42".center(5, '-') → "-42--"

📌 记忆要点

1. zfill(width) 左侧补零到指定宽度
2. 负号处理特殊："-42".zfill(5) → "-0042"
3. 常用于数字格式化，如编号补零

---

第 20 题

表达式 list(map(str, [1, 2, 3])) 的结果是（）。

选项	内容
A	"123"
B	['1', '2', '3'] ✅
C	[1, 2, 3]
D	报错

答案

B

📖 解析：

• map(func, iterable) 对可迭代对象的每个元素应用函数
• map(str, [1, 2, 3]) 将每个整数转为字符串
• map() 返回迭代器，list() 转为列表
• 结果：['1', '2', '3']

list(map(str, [1, 2, 3]))        # ['1', '2', '3']
list(map(int, ["1", "2", "3"]))  # [1, 2, 3]
list(map(float, [1, 2, 3]))      # [1.0, 2.0, 3.0]
list(map(len, ["ab", "abc", "a"]))  # [2, 3, 1]

# 等价的列表推导式
[str(x) for x in [1, 2, 3]]  # ['1', '2', '3']

🔑 知识点：map() 函数

• map(func, iterable) 将函数应用到每个元素
• Python 3 中 map() 返回迭代器，需 list() 转换
• 可用列表推导式替代，列表推导式通常更 Pythonic

写法	结果
list(map(str, [1,2,3]))	['1', '2', '3']
[str(x) for x in [1,2,3]]	['1', '2', '3']（等价）
list(map(int, "123"))	[1, 2, 3]

📌 记忆要点

1. map(func, iterable) 对每个元素应用函数
2. Python 3 返回迭代器，需 list() 转换
3. 列表推导式可替代 map，通常更推荐

---

第 21 题

表达式 list(reversed([1, 2, 3])) 的结果是（）。

选项	内容
A	[1, 2, 3]
B	[1]
C	[3, 2, 1] ✅
D	报错

答案

C

📖 解析：

• reversed(seq) 返回序列的逆序迭代器
• list() 将迭代器转为列表
• reversed([1, 2, 3]) → [3, 2, 1]

list(reversed([1, 2, 3]))   # [3, 2, 1]
list(reversed("abc"))       # ['c', 'b', 'a']
list(reversed(range(5)))    # [4, 3, 2, 1, 0]

# reversed() vs 切片反转
lst = [1, 2, 3]
list(reversed(lst))   # [3, 2, 1]（返回迭代器，不修改原列表）
lst[::-1]             # [3, 2, 1]（返回新列表，不修改原列表）
lst.reverse()         # None（原地反转，lst 变为 [3, 2, 1]）

🔑 知识点：反转序列的三种方式

方式	是否修改原序列	返回值
reversed(seq)	否	迭代器
seq[::-1]	否	新序列
lst.reverse()	是（原地反转）	None

📌 记忆要点

1. reversed() 返回迭代器，不修改原序列
2. list.reverse() 原地反转，返回 None
3. [::-1] 切片反转，返回新序列

---

第 22 题

表达式 [1, 2] * 3 的结果是（）。

选项	内容
A	[1, 2, 3]
B	[[1, 2], [1, 2], [1, 2]]
C	[1, 2, 1, 2, 1, 2] ✅
D	报错

答案

C

📖 解析：

• 列表的 * 运算符表示重复（复制拼接）
• [1, 2] * 3 = [1, 2] + [1, 2] + [1, 2] = [1, 2, 1, 2, 1, 2]

[1, 2] * 3     # [1, 2, 1, 2, 1, 2]
[0] * 5        # [0, 0, 0, 0, 0]
["hi"] * 3     # ["hi", "hi", "hi"]
[[]] * 3       # [[], [], []]  ⚠️ 三个空列表指向同一对象！

# 注意：嵌套列表重复的陷阱
lst = [[]] * 3
lst[0].append(1)
print(lst)  # [[1], [1], [1]]  ← 三个子列表都被修改了！

🔑 知识点：序列重复运算

• * 运算符对序列进行重复拼接
• 字符串、列表、元组都支持

表达式	结果
[1, 2] * 3	[1, 2, 1, 2, 1, 2]
"ab" * 3	"ababab"
(1,) * 3	(1, 1, 1)
[0] * 5	[0, 0, 0, 0, 0]

• 陷阱：[[]] * 3 中的三个空列表是同一对象

📌 记忆要点

1. [1, 2] * 3 是重复拼接，不是嵌套
2. [0] * n 常用于初始化列表
3. [[]] * n 有陷阱，三个子列表共享同一对象

---

第 23 题

表达式 min(["banana", "apple", "pie"], key=len) 的结果是（）。

选项	内容
A	"banana"
B	"pie" ✅
C	"apple"
D	报错

答案

B

📖 解析：

• min(iterable, key=func) 根据 key 函数的返回值找最小元素
• key=len 意味着按字符串长度比较
• "banana" 长度 6，"apple" 长度 5，"pie" 长度 3
• 长度最短的是 "pie"，所以返回 "pie"

min(["banana", "apple", "pie"], key=len)    # "pie"（最短）
max(["banana", "apple", "pie"], key=len)    # "banana"（最长）
min(["banana", "apple", "pie"])             # "apple"（默认按字母序）
max(["banana", "apple", "pie"])             # "pie"（默认按字母序）

# 其他 key 用法
min([-5, -3, 2, 4], key=abs)    # 2（绝对值最小）
max(["Hello", "world", "Hi"], key=str.lower)  # "world"（不区分大小写最大）
sorted([3, 1, 4, 1, 5], key=lambda x: -x)     # [5, 4, 3, 1, 1]（按相反顺序）

🔑 知识点：key 参数

• min()、max()、sorted() 等函数都支持 key 参数
• key 接收一个函数，根据函数返回值进行比较

用法	说明
key=len	按长度
key=str.lower	不区分大小写
key=lambda x: -x	自定义规则
key=abs	按绝对值

📌 记忆要点

1. key 参数指定比较规则，key=len 按长度比较
2. min() 找最小，max() 找最大
3. 不指定 key 时按默认规则比较（字符串按字母序）

---

第 24 题

表达式 eval("2 + 3 * 4") 的结果是（）。

选项	内容
A	"2 + 3 * 4"
B	20
C	14 ✅
D	报错

答案

C

📖 解析：

• eval() 将字符串作为 Python 表达式执行
• "2 + 3 * 4" 作为表达式执行，遵循运算优先级
• 3 * 4 = 12，2 + 12 = 14
• 返回整数 14

eval("2 + 3 * 4")     # 14（先乘后加）
eval("2 + 3") * 4     # 20（先eval再乘）
eval("[1, 2, 3]")      # [1, 2, 3]（字符串转列表）
eval("{'a': 1}")       # {'a': 1}（字符串转字典）

# 危险！不要对不可信的输入使用 eval
user_input = "__import__('os').system('rm -rf /')"
eval(user_input)       # ⚠️ 可能执行恶意代码！

🔑 知识点：eval() 函数

• eval(string) 将字符串作为 Python 表达式执行并返回结果
• 可以执行数学表达式、转换字符串为对象等

用法	结果
eval("1 + 2")	3
eval("'hello'")	'hello'
eval("2 ** 10")	1024
eval("[1, 2, 3]")	[1, 2, 3]

• 安全警告：不要对用户输入使用 eval()，可能导致代码注入

📌 记忆要点

1. eval() 将字符串当表达式执行，遵循 Python 语法规则
2. 运算遵循优先级：先乘除后加减
3. 不要对不可信输入使用 eval()，有安全风险

✅ 二、判断题

---

第 1 题 ✅ 对

题目： Python中，list.copy() 方法创建的是浅拷贝，如果列表中包含嵌套列表，修改副本中的嵌套列表会影响原列表。

答案

✔ 对

解析：

• list.copy() 创建的是浅拷贝（shallow copy）
• 对于简单元素（数字、字符串等），副本独立
• 对于嵌套的可变对象（如嵌套列表），副本和原列表共享引用

# 浅拷贝：嵌套对象共享引用
a = [[1, 2], [3, 4]]
b = a.copy()
b[0].append(99)
print(a)  # [[1, 2, 99], [3, 4]] ← a 也被修改了！

# 简单元素不受影响
a = [1, 2, 3]
b = a.copy()
b.append(4)
print(a)  # [1, 2, 3] ← a 不受影响

🔑 知识点：浅拷贝与深拷贝

类型	方法	嵌套对象	简单元素
浅拷贝	a.copy() 或 a[:]	共享引用	独立
深拷贝	copy.deepcopy(a)	完全独立	完全独立

📌 记忆要点

1. copy() 是浅拷贝，嵌套可变对象仍共享引用
2. 需要完全独立副本用 copy.deepcopy()
3. 切片 a[:] 也是浅拷贝

---

第 2 题 ✅ 对

题目： dict.fromkeys([1, 2, 3]) 创建的字典中，所有值默认为 None。

答案

✔ 对

解析：

• dict.fromkeys(seq) 不指定第二个参数时，所有值默认为 None
• dict.fromkeys(seq, value) 可以指定默认值

dict.fromkeys([1, 2, 3])       # {1: None, 2: None, 3: None}
dict.fromkeys([1, 2, 3], 0)    # {1: 0, 2: 0, 3: 0}
dict.fromkeys("abc", "x")      # {'a': 'x', 'b': 'x', 'c': 'x'}

📌 记忆要点

1. dict.fromkeys(seq) 默认值为 None
2. dict.fromkeys(seq, val) 可指定默认值

---

第 3 题 ❌ 错

题目： Python 3中，map() 函数返回的是一个列表。

答案

✘ 错

解析：

• Python 3 中 map() 返回的是迭代器（map object），不是列表
• 需要用 list() 转换才能得到列表
• Python 2 中 map() 返回列表，Python 3 做了改变以节省内存

# Python 3
result = map(str, [1, 2, 3])
print(type(result))   # <class 'map'>（迭代器）
print(list(result))   # ['1', '2', '3']

# 类似情况：zip(), filter(), range() 在 Python 3 中都返回迭代器

🔑 知识点：Python 3 返回迭代器的函数

函数	Python 2 返回	Python 3 返回
map()	列表	迭代器
filter()	列表	迭代器
zip()	列表	迭代器
range()	列表	range 对象

📌 记忆要点

1. Python 3 中 map()、filter()、zip() 返回迭代器
2. 需要用 list() 转换查看内容
3. 迭代器只能遍历一次，遍历后为空

---

第 4 题 ❌ 错

题目： 列表推导式只能生成列表，不能生成字典或集合。

答案

✘ 错

解析：

• 列表推导式用 []，生成列表
• 字典推导式用 {}，格式为 {k: v for ...}
• 集合推导式用 {}，格式为 {x for ...}

# 列表推导式
[x**2 for x in range(5)]         # [0, 1, 4, 9, 16]

# 字典推导式
{x: x**2 for x in range(5)}      # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# 集合推导式
{x % 3 for x in range(10)}       # {0, 1, 2}

🔑 知识点：推导式类型

类型	语法	示例
列表推导式	[x for x in ...]	[x**2 for x in range(5)]
字典推导式	{k:v for k,v in ...}	{x:x**2 for x in range(5)}
集合推导式	{x for x in ...}	{x%3 for x in range(10)}

📌 记忆要点

1. [] 列表推导式，{k:v} 字典推导式，{x} 集合推导式
2. 三种推导式语法类似，只是括号和表达式不同

---

第 5 题 ✅ 对

题目： Python中，lambda 函数只能包含一个表达式，不能包含多条语句。

答案

✔ 对

解析：

• lambda 是匿名函数，只能包含一个表达式
• 不能包含语句（如 if 语句、for 循环、赋值等）
• 表达式的结果就是返回值

# lambda 语法：lambda 参数: 表达式
add = lambda x, y: x + y      # ✅ 一个表达式
add(3, 5)                       # 8

# lambda 不能包含语句
# lambda x: if x > 0: return x  # ❌ 语法错误

# 可以用条件表达式（三元运算符）
abs_val = lambda x: x if x >= 0 else -x   # ✅ 条件表达式
abs_val(-5)  # 5

📌 记忆要点

1. lambda 只能有一个表达式
2. 条件判断可用三元表达式 x if cond else y
3. lambda 的返回值就是表达式的值，无需 return

---

第 6 题 ❌ 错

题目： 在Python中，try 语句必须包含 except 子句。

答案

✘ 错

解析：

• try 语句可以和 except、else、finally 组合使用
• try...finally 是合法的，不需要 except
• finally 无论是否发生异常都会执行

# try...except...else...finally（完整形式）
try:
    f = open("data.txt", "r")
except FileNotFoundError:
    print("文件不存在")
else:
    print("文件打开成功")
finally:
    print("无论如何都执行")

# try...finally（无需 except）
try:
    f = open("data.txt", "r")
    content = f.read()
finally:
    f.close()  # 确保文件关闭

🔑 知识点：try 语句组合

组合	说明
try...except	捕获异常
try...finally	确保清理（无需 except）
try...except...else	无异常时执行 else
try...except...finally	捕获异常 + 清理
try...except...else...finally	完整形式

📌 记忆要点

1. try 不一定要有 except，try...finally 是合法的
2. finally 始终执行，常用于资源清理
3. else 在没有异常时执行

---

第 7 题 ✅ 对

题目： Python 3中，for 循环结束后，循环变量仍然可以访问。

答案

✔ 对

解析：

• Python 3 中，for 循环结束后，循环变量保留最后一次迭代的值
• 这与某些语言（如 C++）不同，Python 的循环变量在循环外仍可访问

for i in range(5):
    pass
print(i)  # 4（循环结束后 i 仍可访问，值为最后一次迭代的值）

# 注意：如果循环体从未执行，变量不存在
for x in range(0):
    pass
# print(x)  # ❌ NameError: name 'x' is not defined

📌 记忆要点

1. Python 的 for 循环变量在循环外仍可访问
2. 如果循环未执行（如 range(0)），变量不存在
3. 循环变量的值为最后一次迭代的值

---

第 8 题 ✅ 对

题目： float("inf") 可以表示正无穷大。

答案

✔ 对

解析：

• float("inf") 表示正无穷大
• float("-inf") 表示负无穷大
• 任何有限数都比正无穷小，比负无穷大

float("inf")            # inf
float("-inf")           # -inf
1e308                   # 1e+308（很大的有限数）
1e309                   # inf（超出范围，变为无穷）

# 比较
float("inf") > 1e308    # True
float("-inf") < -1e308  # True

# 特殊值
float("inf") + 1        # inf（无穷加有限仍为无穷）
float("inf") + float("inf")  # inf
float("inf") - float("inf")  # nan（不确定结果）

📌 记忆要点

1. float("inf") 表示正无穷，float("-inf") 表示负无穷
2. 可用于初始化最大值/最小值
3. 无穷的运算需注意：inf - inf 结果为 nan

---

第 9 题 ❌ 错

题目： str.isdigit() 和 str.isnumeric() 的功能完全相同。

答案

✘ 错

解析：

• isdigit() 只认 0-9 和全角数字
• isnumeric() 认 0-9、全角数字、中文数字、罗马数字等
• isnumeric() 的范围比 isdigit() 更广

# 数字字符
"123".isdigit()      # True
"123".isnumeric()    # True

# 中文数字
"一二三".isdigit()    # False
"一二三".isnumeric()  # True

# 罗马数字
"Ⅳ".isdigit()        # False
"Ⅳ".isnumeric()      # True

# 分数
"½".isdigit()         # False
"½".isnumeric()       # True

🔑 知识点：字符串数字判断方法对比

方法	0-9	全角数字	中文数字	罗马数字	分数
isdigit()	True	True	False	False	False
isnumeric()	True	True	True	True	True
isdecimal()	True	False	False	False	False

范围：isdecimal() < isdigit() < isnumeric()

📌 记忆要点

1. isdecimal() 最严格（仅 0-9）
2. isdigit() 中等（0-9 + 全角数字）
3. isnumeric() 最宽松（0-9 + 全角 + 中文 + 罗马数字等）

---

第 10 题 ✅ 对

题目： 使用 with 语句打开文件时，即使发生异常，文件也会被正确关闭。

答案

✔ 对

解析：

• with 语句会在代码块执行完毕后自动调用 __exit__ 方法
• 即使发生异常，文件也会被关闭
• 这是上下文管理器（Context Manager）的特性

# with 语句自动关闭文件
with open("data.txt", "r") as f:
    content = f.read()
    # 无论是否发生异常，f 都会被关闭

# 等价于
f = open("data.txt", "r")
try:
    content = f.read()
finally:
    f.close()  # 确保关闭

📌 记忆要点

1. with 语句自动关闭文件，即使发生异常
2. 推荐使用 with open() as f: 而非手动 open/close
3. with 语句是上下文管理器的语法糖

---

第 11 题 ✅ 对

题目： Python中，a = b = [] 会让 a 和 b 指向同一个列表对象。

答案

✔ 对

解析：

• 链式赋值 a = b = [] 中，[] 只创建一次
• a 和 b 指向同一个空列表对象
• 修改其中一个，另一个也会变化

a = b = []
a.append(1)
print(b)     # [1]  ← b 也变了
print(a is b)  # True（同一对象）

# 独立创建
a = []
b = []
a.append(1)
print(b)     # []  ← b 不受影响
print(a is b)  # False（不同对象）

📌 记忆要点

1. 链式赋值 a = b = [] 指向同一对象
2. 对可变对象修改会影响所有引用
3. 需要独立副本应分别创建或使用 .copy()

---

第 12 题 ❌ 错

题目： sorted() 函数只能对列表进行排序，不能对字符串和元组排序。

答案

✘ 错

解析：

• sorted() 可以对任何可迭代对象排序
• 包括列表、字符串、元组、字典等
• 返回值始终是列表

sorted([3, 1, 2])          # [1, 2, 3]（列表）
sorted("hello")            # ['e', 'h', 'l', 'l', 'o']（字符串）
sorted((3, 1, 2))          # [1, 2, 3]（元组）
sorted({'c': 3, 'a': 1})   # ['a', 'c']（字典，按键排序）

# 注意：sorted() 始终返回列表
type(sorted("abc"))  # <class 'list'>

📌 记忆要点

1. sorted() 可用于任何可迭代对象
2. 返回值始终是列表
3. sort() 只能用于列表（原地排序）

---

第 13 题 ✅ 对

题目： Python中，字典的 values() 方法返回的是视图对象，会随字典的变化实时更新。

答案

✔ 对

解析：

• Python 3 中 values() 返回字典视图（dict_values），不是列表
• 视图是动态的，字典变化时视图自动更新

d = {'a': 1, 'b': 2, 'c': 3}
v = d.values()
print(list(v))    # [1, 2, 3]

d['d'] = 4        # 修改字典
print(list(v))    # [1, 2, 3, 4]  ← 视图自动更新！

# 同理，keys() 和 items() 也是视图
k = d.keys()
print(list(k))    # ['a', 'b', 'c', 'd']（也更新了）

📌 记忆要点

1. Python 3 中 keys()、values()、items() 返回视图对象
2. 视图随字典实时更新
3. 需要快照用 list(d.values())

---

第 14 题 ❌ 错

题目： 字符串的 split() 和 join() 完全互为逆操作。

答案

✘ 错

解析：

• split() 和 join() 不是完全互逆的
• split() 不传参时按任意空白分割，丢失原始空白信息
• 即使指定分隔符，也可能无法恢复原始字符串

# 看似互逆
",".join("a,b,c".split(","))    # "a,b,c" ✅

# 不完全互逆的情况
" ".join("  hello   world  ".split())   # "hello world"（空白丢失！）
# 原始: "  hello   world  "
# 结果: "hello world"

# 多个连续分隔符
",".join("a,,b".split(","))     # "a,,b" → split → ['a', '', 'b'] → join → "a,,b"
# 这个例子可以还原，但如果 split() 不传参则不行

# split() 不传参的特殊行为
"  a  b  c  ".split()    # ['a', 'b', 'c']（去除所有空白）
"  a  b  c  ".split(" ") # ['', '', 'a', '', 'b', '', 'c', '', '']（保留空串）

📌 记忆要点

1. split() 不传参时按任意空白分割，丢失原始空白
2. split() 和 join() 在指定相同分隔符时基本可逆
3. 不指定分隔符时，join() 无法恢复原始空白

✏️ 三、程序填空题

---

第 1 题：提取字符串中的数字并求和

题目： 提取字符串中所有数字字符并求和。

s = "a1b2c3d4e5"
total = 0
for ch in s:
    #**********begin1**********
    _______
    #**********end1**********
        #**********begin2**********
        total += _______
        #**********end2**********
print("数字之和:", total)

✅ 填空答案

• begin1： if ch.isdigit():
• begin2： int(ch)

完整正确代码

s = "a1b2c3d4e5"
total = 0
for ch in s:
    if ch.isdigit():              # 【填空1】判断是否为数字字符
        total += int(ch)           # 【填空2】转为整数后累加
print("数字之和:", total)           # 输出: 数字之和: 15

运行结果： 数字之和: 15

🔑 知识点：字符串判断方法与类型转换

• ch.isdigit() 判断字符是否为数字
• int(ch) 将数字字符转为整数
• 字符串中每个字符都可以单独判断

📖 拓展

# 方法2：列表推导式
s = "a1b2c3d4e5"
total = sum(int(ch) for ch in s if ch.isdigit())
print("数字之和:", total)

# 方法3：使用 filter
total = sum(map(int, filter(str.isdigit, s)))
print("数字之和:", total)

📌 记忆要点

1. isdigit() 判断字符是否为数字（0-9）
2. 字符数字必须用 int() 转换才能参与算术运算
3. "5" 是字符串，5 是整数，"5" + "3" = "53"，5 + 3 = 8

---

第 2 题：二维列表展平

题目： 使用列表推导式将二维列表展平为一维列表。

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
#**********begin1**********
flat = _______
#**********end1**********
print(flat)

✅ 填空答案

• begin1： [num for row in matrix for num in row]

完整正确代码

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat = [num for row in matrix for num in row]  # 【填空】嵌套列表推导式
print(flat)  # 输出: [1, 2, 3, 4, 5, 6, 7, 8, 9]

运行结果： [1, 2, 3, 4, 5, 6, 7, 8, 9]

🔑 知识点：嵌套列表推导式

嵌套列表推导式的阅读顺序：从左到右，等同于嵌套 for 循环的顺序

# 列表推导式
[num for row in matrix for num in row]

# 等价的 for 循环
result = []
for row in matrix:
    for num in row:
        result.append(num)

可以加条件过滤：

# 只取偶数
[num for row in matrix for num in row if num % 2 == 0]
# [2, 4, 6, 8]

📌 记忆要点

1. 嵌套列表推导式：[expr for x in seq1 for y in seq2]
2. for 子句从左到右对应外层到内层循环
3. 可以在最后加 if 条件过滤

---

第 3 题：选择排序

题目： 使用选择排序对列表进行升序排列。

def selection_sort(lst):
    n = len(lst)
    for i in range(n - 1):
        #**********begin1**********
        min_idx = _______
        #**********end1**********
        for j in range(i + 1, n):
            if lst[j] < lst[min_idx]:
                min_idx = j
        #**********begin2**********
        _______
        #**********end2**********
    return lst

nums = [64, 25, 12, 22, 11]
print(selection_sort(nums))

✅ 填空答案

• begin1： i
• begin2： lst[i], lst[min_idx] = lst[min_idx], lst[i]

完整正确代码

def selection_sort(lst):
    n = len(lst)
    for i in range(n - 1):
        min_idx = i                               # 【填空1】假设当前位置最小
        for j in range(i + 1, n):                 # 在剩余元素中找最小值
            if lst[j] < lst[min_idx]:
                min_idx = j
        lst[i], lst[min_idx] = lst[min_idx], lst[i]  # 【填空2】交换
    return lst

nums = [64, 25, 12, 22, 11]
print(selection_sort(nums))  # 输出: [11, 12, 22, 25, 64]

运行结果： [11, 12, 22, 25, 64]

🔑 知识点：选择排序算法

选择排序的思路： 1. 每轮从未排序部分找到最小元素的索引 2. 将最小元素与未排序部分的第一个元素交换 3. 重复 n-1 轮

轮次	列表状态	找到的最小值
第1轮	[64, 25, 12, 22, 11]	11（与64交换）
第2轮	[11, 25, 12, 22, 64]	12（与25交换）
第3轮	[11, 12, 22, 25, 64]	22（已在位置）
第4轮	[11, 12, 22, 25, 64]	25（已在位置）

📌 记忆要点

1. 选择排序每轮找最小值，与当前位置交换
2. min_idx = i 假设当前位置最小
3. lst[i], lst[min_idx] = lst[min_idx], lst[i] Python 交换语法
4. 时间复杂度 O(n²)

🔧 四、程序改错题

---

第 1 题：字符串数字求和

题目： 将以逗号分隔的数字字符串求和。

s = "1,2,3,4,5"
parts = s.split(",")
total = 0
#**********begin1**********
for num in parts:
    total += num
#**********end1**********
#**********begin2**********
print("总和为:" + total)
#**********end2**********

✅ 错误修正

错误位置	原代码	修正后	错误原因
begin1	total += num	total += int(num)	split() 返回字符串，不能直接与整数相加
begin2	"总和为:" + total	"总和为:" + str(total) 或 "总和为:", total	字符串与整数不能直接用 + 拼接

完整正确代码

s = "1,2,3,4,5"
parts = s.split(",")
total = 0
for num in parts:
    total += int(num)                    # ✅ 修正1：转为整数
print("总和为:", total)                   # ✅ 修正2：用逗号分隔，或用 str() 转换

运行结果： 总和为: 15

🔑 知识点：类型转换与字符串拼接

• split() 返回字符串列表
• 字符串不能直接与整数做加法运算
• 字符串与数字拼接需要类型转换

# 字符串转整数
int("123")   # 123
int("3.14")  # ❌ ValueError（需要 float 中转）

# 数字转字符串
str(123)     # "123"

# 字符串与数字拼接
"值:" + str(123)  # "值:123"
"值:", 123         # print 时可以
f"值:{123}"        # f-string 推荐

📌 记忆要点

1. split() 返回字符串列表，需 int() 转换才能运算
2. 字符串 + 整数 会报 TypeError
3. 拼接方式：str()、逗号、f-string

---

第 2 题：递归求和

题目： 使用递归计算1到n的和。

def sum_n(n):
    #**********begin1**********
    if n == 0:
        return
    #**********end1**********
    #**********begin2**********
    return n + sum_n(n)
    #**********end2**********

n = int(input("请输入正整数:"))
print("1到{}的和为:".format(n), sum_n(n))

✅ 错误修正

错误位置	原代码	修正后	错误原因
begin1	return	return 0	递归终止条件必须返回值，不能只写 return（返回 None）
begin2	return n + sum_n(n)	return n + sum_n(n - 1)	递归调用参数未递减，导致无限递归

完整正确代码

def sum_n(n):
    if n == 0:
        return 0                           # ✅ 修正1：返回0，不是return None
    return n + sum_n(n - 1)               # ✅ 修正2：参数递减 n-1

n = int(input("请输入正整数:"))
print("1到{}的和为:".format(n), sum_n(n))

运行示例： 输入 5 → 1到5的和为: 15

🔑 知识点：递归函数三要素

1. 终止条件：何时停止递归（base case）
2. 终止返回值：终止时返回什么
3. 递归调用：问题规模缩小，向终止条件靠近

# 递归求和的正确模式
def sum_n(n):
    if n == 1:            # 终止条件
        return 1          # 终止返回值
    return n + sum_n(n-1) # 递归调用（规模缩小）

# 常见错误
# 1. 忘记终止条件 → 无限递归 → RecursionError
# 2. 终止条件 return 而非 return 值 → TypeError（None + int）
# 3. 参数不递减 → 无限递归 → RecursionError

📌 记忆要点

1. 递归必须有终止条件，且终止条件必须返回具体值
2. return 不带值返回 None，不是 0
3. 递归调用时参数必须向终止条件靠近（如 n → n-1）
4. 1到n的和 = n + 1到(n-1)的和

---

第 3 题：字典遍历删除

题目： 删除字典中成绩不及格（低于60分）的学生。

scores = {"张三": 45, "李四": 78, "王五": 92, "赵六": 55}
#**********begin1**********
for name in scores:
    if scores[name] < 60:
        del scores[name]
#**********end1**********
print(scores)

✅ 错误修正

错误位置	原代码	修正后	错误原因
begin1	for name in scores:	for name in list(scores):	遍历字典时删除元素会导致 RuntimeError

完整正确代码

scores = {"张三": 45, "李四": 78, "王五": 92, "赵六": 55}
for name in list(scores):                    # ✅ 修正：用 list() 创建键的副本
    if scores[name] < 60:
        del scores[name]
print(scores)  # 输出: {'李四': 78, '王五': 92}

运行结果： {'李四': 78, '王五': 92}

📖 拓展：其他实现方式

# 方法2：字典推导式（推荐）
scores = {"张三": 45, "李四": 78, "王五": 92, "赵六": 55}
scores = {name: score for name, score in scores.items() if score >= 60}
print(scores)

# 方法3：收集要删除的键
scores = {"张三": 45, "李四": 78, "王五": 92, "赵六": 55}
to_delete = [name for name, score in scores.items() if score < 60]
for name in to_delete:
    del scores[name]
print(scores)

🔑 知识点：遍历时删除元素

• Python 不允许在遍历字典时修改字典大小（增删键）
• 解决方案：先复制键列表，再遍历删除

方式	说明
list(d)	复制键列表，安全删除
list(d.keys())	同上
字典推导式	创建新字典，更 Pythonic

📌 记忆要点

1. 遍历字典时不能直接删除元素
2. 用 list(scores) 先获取键的副本再遍历
3. 推荐用字典推导式：{k:v for k,v in d.items() if condition}

---

第 4 题：读取文件统计行数

题目： 读取文件内容并统计文件行数。

#**********begin1**********
f = open("data.txt", "w")
#**********end1**********
#**********begin2**********
lines = f.readline()
#**********end2**********
count = len(lines)
#**********begin3**********
f.close
#**********end3**********
print("文件共有", count, "行")

✅ 错误修正

错误位置	原代码	修正后	错误原因
begin1	open("data.txt", "w")	open("data.txt", "r")	"w" 是写入模式，读取文件应用 "r"
begin2	f.readline()	f.readlines()	readline() 只读一行，readlines() 读所有行
begin3	f.close	f.close()	close 是方法，必须加括号调用

完整正确代码

f = open("data.txt", "r")              # ✅ 修正1：读取模式 "r"
lines = f.readlines()                  # ✅ 修正2：读取所有行
count = len(lines)                     # 行数 = 列表长度
f.close()                              # ✅ 修正3：方法调用加括号
print("文件共有", count, "行")

更推荐的写法：

```python
# 推荐：with 语句自动关闭文件
with open("data.txt", "r") as f:
    count = len(f.readlines())
print("文件共有", count, "行")

# 或者更高效（不一次性读取全部内容）
with open("data.txt", "r") as f:
    count = sum(1 for _ in f)
print("文件共有", count, "行")
```

🔑 知识点：文件读取方法

方法	功能	返回类型
f.read()	读取全部内容	字符串
f.readline()	读取一行	字符串
f.readlines()	读取所有行	列表（每行一个元素）

模式	含义
"r"	只读（文件必须存在）
"w"	写入（覆盖或创建）
"a"	追加

📌 记忆要点

1. 读文件用 "r" 模式，写文件用 "w" 模式
2. readline() 读一行，readlines() 读所有行
3. 方法调用必须加括号：close() 不是 close
4. 推荐使用 with 语句自动关闭文件

💻 五、程序设计题

---

第 1 题：凯撒密码

题目： 编写程序实现凯撒密码加密。

凯撒密码的原理：将每个字母在字母表中向后移动固定位数（偏移量），非字母字符不变，大小写分别处理。

要求： 1. 输入一个字符串和偏移量（正整数） 2. 输出加密后的密文 3. 字母循环移位（Z后移1位变为A） 4. 非字母字符保持不变

示例：

输入字符串: Hello World!
输入偏移量: 3
加密结果: Khoor Zruog!

方法1：ASCII 码转换（推荐）

def caesar_encrypt(text, shift):
    result = ""
    for ch in text:
        if ch.isupper():
            # 大写字母：A-Z 的 ASCII 码 65-90
            result += chr((ord(ch) - ord('A') + shift) % 26 + ord('A'))
        elif ch.islower():
            # 小写字母：a-z 的 ASCII 码 97-122
            result += chr((ord(ch) - ord('a') + shift) % 26 + ord('a'))
        else:
            # 非字母字符不变
            result += ch
    return result

text = input("输入字符串: ")
shift = int(input("输入偏移量: "))
encrypted = caesar_encrypt(text, shift)
print("加密结果:", encrypted)

方法2：字符串查找

def caesar_encrypt(text, shift):
    upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    lower = "abcdefghijklmnopqrstuvwxyz"
    result = ""
    for ch in text:
        if ch in upper:
            idx = upper.index(ch)
            result += upper[(idx + shift) % 26]
        elif ch in lower:
            idx = lower.index(ch)
            result += lower[(idx + shift) % 26]
        else:
            result += ch
    return result

text = input("输入字符串: ")
shift = int(input("输入偏移量: "))
print("加密结果:", caesar_encrypt(text, shift))

方法3：带解密功能

def caesar(text, shift):
    result = ""
    for ch in text:
        if ch.isupper():
            result += chr((ord(ch) - 65 + shift) % 26 + 65)
        elif ch.islower():
            result += chr((ord(ch) - 97 + shift) % 26 + 97)
        else:
            result += ch
    return result

text = input("输入字符串: ")
shift = int(input("输入偏移量(正数加密,负数解密): "))
print("结果:", caesar(text, shift))

# 解密就是加密的逆操作，偏移量取反
# 加密: shift = 3
# 解密: shift = -3 或 shift = 26 - 3 = 23

运行结果：

输入字符串: Hello World!
输入偏移量: 3
加密结果: Khoor Zruog!

🔑 知识点：凯撒密码原理

• 核心公式：(ord(ch) - base + shift) % 26 + base
• base 是 'A'(65) 或 'a'(97)
• % 26 实现循环移位（Z → A）
• 非字母字符不处理

字母	偏移3	计算过程
H	K	(72-65+3)%26+65 = 75 → K
e	h	(101-97+3)%26+97 = 104 → h
l	o	(108-97+3)%26+97 = 111 → o
Z	C	(90-65+3)%26+65 = 67 → C

📌 记忆要点

1. ord() 字符转 ASCII 码，chr() ASCII 码转字符
2. % 26 实现字母循环（Z 后移变 A）
3. 大写和小写分开处理，非字母不变
4. 解密 = 加密偏移量取反（或用 26 - shift）

---

第 2 题：简易计算器

题目： 编写程序实现简易四则运算计算器。

要求： 1. 用户输入两个数字和一个运算符（+、-、*、/） 2. 根据运算符执行对应的运算并输出结果 3. 除数为0时给出提示"除数不能为零" 4. 输入不支持的运算符时给出提示"不支持的运算符" 5. 支持多次计算，输入 q 退出程序

示例交互：

请输入第一个数字(输入q退出): 10
请输入运算符(+,-,*,/): /
请输入第二个数字: 0
除数不能为零

请输入第一个数字(输入q退出): 20
请输入运算符(+,-,*,/): *
请输入第二个数字: 3
计算结果: 60.0

请输入第一个数字(输入q退出): q
程序已退出

方法1：if-elif-else（推荐，最直观）

def calculator():
    while True:
        num1 = input("请输入第一个数字(输入q退出): ")
        if num1.lower() == 'q':
            print("程序已退出")
            break
        op = input("请输入运算符(+,-,*,/): ")
        num2 = input("请输入第二个数字: ")

        try:
            a = float(num1)
            b = float(num2)
        except ValueError:
            print("输入无效，请输入数字")
            continue

        if op == '+':
            result = a + b
        elif op == '-':
            result = a - b
        elif op == '*':
            result = a * b
        elif op == '/':
            if b == 0:
                print("除数不能为零")
                continue
            result = a / b
        else:
            print("不支持的运算符")
            continue

        print(f"计算结果: {result}")

calculator()

方法2：使用字典映射

def add(a, b): return a + b
def sub(a, b): return a - b
def mul(a, b): return a * b
def div(a, b):
    if b == 0:
        raise ZeroDivisionError("除数不能为零")
    return a / b

ops = {'+': add, '-': sub, '*': mul, '/': div}

def calculator():
    while True:
        num1 = input("请输入第一个数字(输入q退出): ")
        if num1.lower() == 'q':
            print("程序已退出")
            break
        op = input("请输入运算符(+,-,*,/): ")
        num2 = input("请输入第二个数字: ")

        try:
            a = float(num1)
            b = float(num2)
        except ValueError:
            print("输入无效，请输入数字")
            continue

        if op not in ops:
            print("不支持的运算符")
            continue

        try:
            result = ops[op](a, b)
            print(f"计算结果: {result}")
        except ZeroDivisionError as e:
            print(e)

calculator()

方法3：使用 eval（不推荐用于实际项目）

def calculator():
    while True:
        num1 = input("请输入第一个数字(输入q退出): ")
        if num1.lower() == 'q':
            print("程序已退出")
            break
        op = input("请输入运算符(+,-,*,/): ")
        num2 = input("请输入第二个数字: ")

        if op not in '+-*/':
            print("不支持的运算符")
            continue
        if op == '/' and float(num2) == 0:
            print("除数不能为零")
            continue

        try:
            a = float(num1)
            b = float(num2)
            result = eval(f"{a}{op}{b}")
            print(f"计算结果: {result}")
        except:
            print("计算出错")

calculator()

🔑 知识点：循环、条件判断、异常处理

知识点	本题应用
while True	实现持续运算循环
if-elif-else	根据运算符选择运算
try-except	处理无效输入
break	退出循环
continue	跳过本次，继续下一次循环

📌 记忆要点

1. while True + break 实现交互循环
2. 除法需判断除数是否为 0
3. try-except 处理用户输入非数字的情况
4. float() 转换支持小数输入
5. continue 跳过当前循环，重新开始