Python 模拟考试 6 — 解析

📝 一、单选题（每题2分，共48分）¶

第 1 题¶

表达式 int(3.9) 的结果是（）。

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

答案

B

📖 解析：

int() 将浮点数转换为整数时，直接截断小数部分（向零取整），不是四舍五入
int(3.9) → 截断小数部分 → 3

Python
int(3.9)    # 3（截断，非四舍五入）
int(3.1)    # 3
int(-3.9)   # -3（向零取整）
int(-3.1)   # -3

# 四舍五入用 round()
round(3.9)  # 4
round(3.1)  # 3

🔑 知识点：int() 类型转换

用法	结果	说明
`int(3.9)`	3	截断小数
`int(-3.9)`	-3	向零取整
`int("42")`	42	字符串转整数
`int("3.9")`	报错	不支持非整数字符串

📌 记忆要点

int(3.9) = 3，截断不是四舍五入
int(-3.9) = -3，向零取整
四舍五入用 round()

第 2 题¶

下列关于Python赋值的说法，正确的是（）。

选项	内容
A	`a = b = 5` 是非法的
B	`a, b = 1, 2` 执行后 a=1, b=2 ✅
C	`a, b = 1` 是合法的
D	Python不支持链式赋值

答案

B

📖 解析：

A 错误：a = b = 5 是链式赋值，完全合法，a 和 b 都为 5
B 正确：a, b = 1, 2 是多元赋值（解包赋值），a=1, b=2
C 错误：a, b = 1 会报 ValueError，左侧2个变量，右侧只有1个值
D 错误：Python 支持链式赋值

Python
# 链式赋值
a = b = 5      # a=5, b=5 ✅

# 多元赋值（解包）
a, b = 1, 2    # a=1, b=2 ✅
a, b = b, a    # 交换变量 ✅

# 错误：左右数量不匹配
a, b = 1       # ❌ ValueError: not enough values to unpack

🔑 知识点：Python 赋值方式

方式	示例	说明
简单赋值	`a = 1`	最基本形式
链式赋值	`a = b = 5`	多个变量同一值
多元赋值	`a, b = 1, 2`	同时赋不同值
交换变量	`a, b = b, a`	无需临时变量

📌 记忆要点

a, b = 1, 2 是解包赋值，左右数量必须一致
a = b = 5 链式赋值合法
Python 交换变量：a, b = b, a

第 3 题¶

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

Python
lst = [10, 20, 30, 40, 50]
print(lst[1:4:2])

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

答案

B

📖 解析：

切片语法：lst[start:stop:step]，左闭右开
lst[1:4:2]：起始索引1，终止索引4（不含），步长2
索引1=20，索引1+2=3=40，索引3+2=5超出stop(4)停止
结果：[20, 40]

Text Only
1 2 3 4	`索引: 0 1 2 3 4 值: 10 20 30 40 50 ↑ ↑ 索引1 索引3`

Python
lst = [10, 20, 30, 40, 50]
lst[1:4:2]   # [20, 40]（索引1, 3）
lst[0:5:2]   # [10, 30, 50]（索引0, 2, 4）
lst[::2]     # [10, 30, 50]（从头到尾，步长2）
lst[::-1]    # [50, 40, 30, 20, 10]（反转）

🔑 知识点：列表切片

表达式	结果	说明
`lst[1:4]`	[20, 30, 40]	索引1到3
`lst[1:4:2]`	[20, 40]	索引1到3，步长2
`lst[::2]`	[10, 30, 50]	步长2
`lst[::-1]`	[50, 40, 30, 20, 10]	反转

📌 记忆要点

切片 [start:stop:step] 左闭右开
步长为2时，每隔一个取一个
负步长可反转序列

第 4 题¶

下列哪个表达式的结果为 True？（）

选项	内容
A	`"abc" == "ABC"`
B	`"abc" > "abd"`
C	`"9" < "123"`
D	`"hello" in "helloworld"` ✅

答案

D

📖 解析：

A："abc" == "ABC" → False，字符串比较区分大小写
B："abc" > "abd" → False，逐字符比较，'c'(99) < 'd'(100)
C："9" < "123" → False，字符串按字典序比较，首字符 '9'(57) > '1'(49)
D："hello" in "helloworld" → True，"hello" 是 "helloworld" 的子串

Python
"abc" == "ABC"          # False（区分大小写）
"abc" > "abd"           # False（c < d）
"9" < "123"             # False（'9' > '1'，字符串比较非数值比较）
"hello" in "helloworld" # True（子串包含）

🔑 知识点：字符串比较

字符串比较按字典序（逐字符比较 Unicode 值）
区分大小写：'a' > 'A' → True
in 运算符判断子串关系
字符串比较不是数值比较："9" > "10" → True

📌 记忆要点

字符串比较按字典序，区分大小写
"9" < "123" 是 False（字符 '9' > '1'），不要混淆为数值
in 判断子串包含关系

第 5 题¶

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

Python
s = "Python"
print(s[-3:])

选项	内容
A	"tho"
B	"hon" ✅
C	"Pyt"
D	"on"

答案

B

📖 解析：

Text Only
1 2 3	`P y t h o n 0 1 2 3 4 5 -6 -5 -4 -3 -2 -1`

s[-3:]：从倒数第3个位置取到末尾
索引 -3 = 'h'，取到末尾 = "hon"

Python
s = "Python"
s[-3:]   # "hon"（从倒数第3个到末尾）
s[-2:]   # "on"（从倒数第2个到末尾）
s[-1]    # "n"（最后一个字符）
s[:-3]   # "Pyt"（从开头到倒数第3个之前）

🔑 知识点：负索引与切片

表达式	结果	说明
`s[-3:]`	`"hon"`	倒数第3个到末尾
`s[:-3]`	`"Pyt"`	开头到倒数第4个
`s[-3:-1]`	`"ho"`	倒数第3到倒数第2
`s[-1]`	`"n"`	最后一个字符

📌 记忆要点

负索引从 -1 开始，-1 表示最后一个字符
s[-3:] 取最后3个字符
s[-3:-1] 左闭右开，不包含 -1 位置的字符

第 6 题¶

关于Python字典，下列说法错误的是（）。

选项	内容
A	字典的键必须是唯一的
B	字典的值可以是任意类型
C	对同一个键多次赋值，会保留所有值 ✅
D	字典是可变数据类型

答案

C

📖 解析：

A 正确：字典的键必须唯一，重复赋值会覆盖
B 正确：字典的值可以是任意类型
C 错误：对同一个键多次赋值，后赋的值覆盖前值，只保留最后一个
D 正确：字典是可变类型

Python
d = {}
d['a'] = 1
d['a'] = 2    # 覆盖，不是保留两个
print(d)      # {'a': 2}

# 字面量中重复键也只保留最后一个
d = {'a': 1, 'a': 2}  # {'a': 2}

🔑 知识点：字典基本特性

特性	说明
键唯一	重复键会覆盖
值任意	可以是任何类型
可变	可以增删改
键不可变	键必须是不可变类型

📌 记忆要点

同一键多次赋值，后值覆盖前值
字典键必须唯一且不可变
字典是可变类型

第 7 题¶

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

Python
a = [1, 2, 3]
b = a.copy()
b[0] = 100
print(a[0])

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

答案

B

📖 解析：

a.copy() 创建列表的浅拷贝，b 是 a 的独立副本
修改 b 不会影响 a（对于单层列表）
b[0] = 100 只修改了 b，a 不变
print(a[0]) 输出 1

Python
# 浅拷贝：修改副本不影响原列表
a = [1, 2, 3]
b = a.copy()      # 浅拷贝
b[0] = 100
print(a)           # [1, 2, 3]（a 不受影响）
print(b)           # [100, 2, 3]

# 引用赋值：修改副本会影响原列表
c = a              # 引用赋值
c[0] = 200
print(a)           # [200, 2, 3]（a 被修改！）

🔑 知识点：列表拷贝方式

方式	是否独立	说明
`b = a`	否	引用赋值，指向同一对象
`b = a.copy()`	是（浅拷贝）	单层独立，嵌套层共享
`b = a[:]`	是（浅拷贝）	切片方式
`b = list(a)`	是（浅拷贝）	构造函数方式
`copy.deepcopy(a)`	是（深拷贝）	完全独立

📌 记忆要点

a.copy() 是浅拷贝，创建新列表
a = b 是引用赋值，两个变量指向同一对象
浅拷贝对单层列表足够，嵌套列表需深拷贝

第 8 题¶

表达式 sum(range(1, 6)) 的结果是（）。

选项	内容
A	10
B	15 ✅
C	5
D	6

答案

B

📖 解析：

range(1, 6) 生成序列：1, 2, 3, 4, 5（左闭右开，不包含6）
sum(1, 2, 3, 4, 5) = 1+2+3+4+5 = 15

Python
range(1, 6)         # 1, 2, 3, 4, 5
sum(range(1, 6))    # 15
sum(range(1, 101))  # 5050（1到100的和）
sum(range(6))       # 15（0+1+2+3+4+5）

🔑 知识点：range() 与 sum()

用法	结果	说明
`range(1, 6)`	1,2,3,4,5	左闭右开
`sum(range(1, n+1))`	1到n的和	求和公式 n*(n+1)/2
`sum(range(n))`	0到n-1的和	从0开始

📌 记忆要点

range(1, 6) = 1, 2, 3, 4, 5（不含6）
sum() 可直接对 range 对象求和
1到n的和 = n*(n+1)/2

第 9 题¶

下列程序的输出结果是（）。

Python
def greet(name="World"):
    print("Hello, " + name)
greet()
greet("Python")

选项	内容
A	Hello, World 和 Hello, Python ✅
B	Hello, Python 和 Hello, World
C	报错
D	Hello, 和 Hello, Python

答案

A

📖 解析：

greet() 不传参数，使用默认值 name="World" → 输出 Hello, World
greet("Python") 传入参数 name="Python" → 输出 Hello, Python

Python
def greet(name="World"):   # name 的默认值是 "World"
    print("Hello, " + name)

greet()          # Hello, World（使用默认值）
greet("Python")  # Hello, Python（使用传入值）
greet(name="Hi") # Hello, Hi（关键字参数）

🔑 知识点：默认参数

调用方式	效果
`greet()`	使用默认值
`greet("Python")`	使用传入值
`greet(name="Hi")`	关键字参数

注意：默认参数必须放在非默认参数之后。

📌 记忆要点

不传参时使用默认值
传参时覆盖默认值
默认参数放在参数列表末尾

第 10 题¶

以下关于 enumerate() 函数的说法，正确的是（）。

选项	内容
A	`enumerate()` 只能用于列表
B	`enumerate()` 返回索引和值组成的元组 ✅
C	`enumerate()` 会修改原序列
D	`enumerate()` 的索引从1开始

答案

B

📖 解析：

A 错误：enumerate() 可用于任何可迭代对象
B 正确：enumerate() 返回 (index, value) 元组的迭代器
C 错误：enumerate() 不修改原序列
D 错误：默认从 0 开始，可通过 start 参数指定起始值

Python
lst = ['a', 'b', 'c']
for i, v in enumerate(lst):
    print(i, v)
# 0 a
# 1 b
# 2 c

# 指定起始索引
for i, v in enumerate(lst, start=1):
    print(i, v)
# 1 a
# 2 b
# 3 c

🔑 知识点：enumerate() 函数

用法	说明
`enumerate(seq)`	返回 (0, val0), (1, val1), ...
`enumerate(seq, start=n)`	从 n 开始编号
`list(enumerate(seq))`	转为列表查看

📌 记忆要点

enumerate() 返回 (索引, 值) 元组
默认索引从 0 开始
可用于任何可迭代对象，不修改原序列

第 11 题¶

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

Python
x = [i * 2 for i in range(5)]
print(x)

选项	内容
A	[0, 2, 4, 6, 8] ✅
B	[1, 2, 3, 4, 5]
C	[2, 4, 6, 8, 10]
D	[0, 1, 2, 3, 4]

答案

A

📖 解析：

range(5) 生成 0, 1, 2, 3, 4
i * 2 对每个元素乘以 2
结果：[0, 2, 4, 6, 8]

Python
[i * 2 for i in range(5)]        # [0, 2, 4, 6, 8]
[i ** 2 for i in range(5)]       # [0, 1, 4, 9, 16]
[i for i in range(10) if i % 2 == 0]  # [0, 2, 4, 6, 8]（带条件）

# 等价的 for 循环
x = []
for i in range(5):
    x.append(i * 2)
# x = [0, 2, 4, 6, 8]

🔑 知识点：列表推导式

语法	说明
`[expr for var in seq]`	基本形式
`[expr for var in seq if cond]`	带条件过滤
`[expr for v1 in s1 for v2 in s2]`	嵌套循环

📌 记忆要点

列表推导式：[表达式 for 变量 in 序列]
range(5) 从 0 开始
可加 if 条件过滤

第 12 题¶

关于Python异常处理，下列说法正确的是（）。

选项	内容
A	`try` 语句块可以没有 `except` ✅
B	一个 `try` 只能有一个 `except`
C	`finally` 块只在发生异常时执行
D	`else` 块在发生异常时执行

答案

A

📖 解析：

A 正确：try 可以和 finally 搭配，不需要 except（如资源释放场景）
B 错误：一个 try 可以有多个 except，处理不同类型的异常
C 错误：finally 块无论是否发生异常都会执行
D 错误：else 块在没有发生异常时执行

Python
# try + finally（不需要 except）
try:
    f = open("data.txt")
    # 操作文件
finally:
    f.close()  # 无论是否异常都关闭

# try + except + else + finally
try:
    result = 10 / 2
except ZeroDivisionError:
    print("除零错误")
else:
    print("没有异常时执行")   # ✅ 会执行
finally:
    print("总是执行")          # ✅ 会执行

🔑 知识点：异常处理结构

子句	执行时机
`try`	尝试执行的代码
`except`	发生异常时执行
`else`	没有异常时执行
`finally`	无论是否异常都执行

📌 记忆要点

try 可以没有 except，但必须有 except 或 finally
else 在没有异常时执行
finally 总是执行

第 13 题¶

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

Python
t = (1,)
print(type(t))

选项	内容
A	\<class 'int'>
B	\<class 'tuple'> ✅
C	\<class 'list'>
D	\<class 'str'>

答案

B

📖 解析：

(1,) 是单元素元组，逗号不能省略
如果写成 (1)，则 type((1)) → <class 'int'>，因为 (1) 只是整数 1 加了括号
逗号是区分元组和普通括号的关键

Python
t = (1,)     # <class 'tuple'> ✅ 单元素元组
x = (1)      # <class 'int'> ❌ 只是整数1加括号
y = (1, 2)   # <class 'tuple'> ✅ 多元素元组
z = ()       # <class 'tuple'> ✅ 空元组

# 创建元组的其他方式
tuple([1])   # (1,) <class 'tuple'>
1,           # (1,) <class 'tuple'>

🔑 知识点：元组创建

写法	类型	说明
`(1,)`	tuple	单元素元组，逗号必须
`(1)`	int	只是整数1加括号
`(1, 2)`	tuple	多元素元组
`()`	tuple	空元组
`1, 2, 3`	tuple	省略括号也可

📌 记忆要点

单元素元组 (1,) 的逗号不能省略
(1) 是整数，(1,) 是元组
空元组 () 不需要逗号

第 14 题¶

表达式 "Hello Python".split() 的结果是（）。

选项	内容
A	["Hello", "Python"] ✅
B	"Hello", "Python"
C	["Hello Python"]
D	报错

答案

A

📖 解析：

split() 不传参数时，按任意空白字符分割
"Hello Python" 以空格分隔，分割为 ["Hello", "Python"]
结果是列表类型

Python
"Hello Python".split()       # ["Hello", "Python"]
"a,b,c".split(",")          # ["a", "b", "c"]
"a  b  c".split()           # ["a", "b", "c"]（多个空格视为一个）
"a  b  c".split(" ")        # ["a", "", "b", "", "c"]（严格按一个空格）

🔑 知识点：split() 方法

用法	结果	说明
`s.split()`	按空白分割	连续空白视为一个分隔符
`s.split(" ")`	按单个空格分割	严格按一个空格
`s.split(",")`	按逗号分割	指定分隔符
`s.split(",", 1)`	最多分割1次	限制分割次数

📌 记忆要点

split() 无参数时按任意空白分割
返回值是列表
split() 与 split(" ") 处理连续空格的结果不同

第 15 题¶

下列关于 global 关键字的说法，正确的是（）。

选项	内容
A	在函数外也必须使用 `global` 声明变量
B	`global` 用于在函数内声明要修改的全局变量 ✅
C	使用 `global` 后局部变量和全局变量互不影响
D	`global` 可以创建新的局部变量

答案

B

📖 解析：

A 错误：全局变量在函数外定义即可，不需要 global 声明
B 正确：global 的作用是在函数内声明要修改的全局变量
C 错误：使用 global 后，函数内操作的就是全局变量本身
D 错误：global 声明的是全局变量，不是局部变量

Python
count = 0  # 全局变量

def increment():
    global count    # 声明使用全局变量
    count += 1      # 修改全局变量

increment()
print(count)  # 1

# 不用 global：创建同名局部变量
def wrong():
    count = 10      # 局部变量，不影响全局
    print(count)

wrong()         # 10
print(count)    # 1（全局变量不变）

🔑 知识点：global 关键字

场景	是否需要 global	说明
读取全局变量	不需要	直接读取
修改全局变量	需要	必须 global 声明
创建局部变量	不需要	直接赋值即为局部变量

📌 记忆要点

global 用于函数内修改全局变量
只读取全局变量不需要 global
不用 global 直接赋值会创建同名局部变量

第 16 题¶

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

Python
s = "abcabc"
print(s.replace("a", "x", 1))

选项	内容
A	"xbcxbc"
B	"xbcabc" ✅
C	"abcabc"
D	"xXxXbc"

答案

B

📖 解析：

replace(old, new, count) 第三个参数指定替换次数
s.replace("a", "x", 1) 只替换第1个 "a" 为 "x"
结果："xbcabc"

Python
s = "abcabc"
s.replace("a", "x")      # "xbcxbc"（替换所有）
s.replace("a", "x", 1)   # "xbcabc"（只替换第1个）
s.replace("a", "x", 2)   # "xbcxbc"（替换前2个）
s.replace("abc", "X")    # "XX"（替换所有 "abc"）

🔑 知识点：字符串 replace() 方法

用法	说明
`s.replace(old, new)`	替换所有匹配
`s.replace(old, new, n)`	只替换前 n 个匹配
返回值	新字符串，原字符串不变

📌 记忆要点

replace() 第三个参数限制替换次数
不指定次数则替换所有匹配
字符串不可变，replace() 返回新字符串

第 17 题¶

以下哪个方法可以获取字典中所有的值？（）

选项	内容
A	`dict.items()`
B	`dict.keys()`
C	`dict.values()` ✅
D	`dict.all()`

答案

C

📖 解析：

A：items() 返回所有键值对 (key, value) 元组
B：keys() 返回所有键
C：values() 返回所有值
D：字典没有 all() 方法

Python
d = {'a': 1, 'b': 2, 'c': 3}

d.keys()    # dict_keys(['a', 'b', 'c'])
d.values()  # dict_values([1, 2, 3])
d.items()   # dict_items([('a', 1), ('b', 2), ('c', 3)])

# 可以转为列表使用
list(d.values())  # [1, 2, 3]

🔑 知识点：字典常用方法

方法	返回内容	返回类型
`keys()`	所有键	dict_keys
`values()`	所有值	dict_values
`items()`	所有键值对	dict_items
`get(key)`	指定键的值	值或None
`pop(key)`	删除并返回值	被删除的值

📌 记忆要点

keys() → 键，values() → 值，items() → 键值对
返回的是视图对象，可用 list() 转为列表
字典没有 all() 方法

第 18 题¶

下列程序的输出结果是（）。

Python
result = []
for i in range(10):
    if i % 3 == 0:
        result.append(i)
print(result)

选项	内容
A	[0, 3, 6, 9] ✅
B	[3, 6, 9]
C	[1, 2, 4, 5, 7, 8]
D	[0, 1, 2, 3]

答案

A

📖 解析：

range(10) 生成 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
i % 3 == 0 判断 i 是否为 3 的倍数
满足条件的 i：0, 3, 6, 9
注意：0 % 3 == 0，所以 0 也被包含

Python
# 逐个判断
% 3 == 0  # True → 添加 0
% 3 == 0  # False
% 3 == 0  # False
% 3 == 0  # True → 添加 3
% 3 == 0  # False
% 3 == 0  # False
% 3 == 0  # True → 添加 6
% 3 == 0  # False
% 3 == 0  # False
% 3 == 0  # True → 添加 9

# 列表推导式等价写法
result = [i for i in range(10) if i % 3 == 0]  # [0, 3, 6, 9]

🔑 知识点：取余运算判断倍数

i % n == 0 判断 i 是否为 n 的倍数
0 是任何非零整数的倍数（0 % 3 == 0）
range(10) 从 0 开始

📌 记忆要点

0 % 任何非零数 == 0
i % 3 == 0 找出3的倍数：0, 3, 6, 9
range(10) 从0开始到9

第 19 题¶

关于 while 循环，下列说法错误的是（）。

选项	内容
A	`while` 循环可能一次都不执行
B	`while True` 是无限循环
C	`while` 循环条件为假时自动退出
D	`while` 循环必须使用计数器控制 ✅

答案

D

📖 解析：

A 正确：如果初始条件就为假，循环体一次都不执行
B 正确：while True 条件永远为真，形成无限循环
C 正确：条件为假时循环自动退出
D 错误：while 循环不必须使用计数器，可以用任意条件控制

Python
# 不需要计数器的 while 循环
while True:
    cmd = input("输入命令(q退出): ")
    if cmd == 'q':
        break

# 条件为假时一次都不执行
x = 10
while x < 5:     # 条件为假，循环体不执行
    print(x)
    x += 1

# 用标志变量控制
running = True
while running:
    running = False  # 修改标志变量退出

🔑 知识点：while 循环

控制方式	示例	场景
计数器	`while i < n`	已知循环次数
标志变量	`while running`	需要灵活控制
用户输入	`while cmd != 'q'`	交互式程序
无限循环	`while True` + `break`	不确定循环次数

📌 记忆要点

while 循环不必须用计数器
条件为假时可能一次都不执行
while True 需配合 break 退出

第 20 题¶

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

Python
def func(a, *args):
    print(a, args)
func(1, 2, 3, 4)

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

答案

A

📖 解析：

*args 是可变位置参数，收集多余的参数为元组
func(1, 2, 3, 4) 中，a=1，args=(2, 3, 4)
args 的类型是元组 tuple，不是列表

Python
def func(a, *args):
    print(a, args)

func(1, 2, 3, 4)     # 1 (2, 3, 4)
func(1)               # 1 ()
func(1, 2)            # 1 (2,)

# **kwargs 收集关键字参数为字典
def func2(a, **kwargs):
    print(a, kwargs)

func2(1, x=10, y=20)  # 1 {'x': 10, 'y': 20}

🔑 知识点：可变参数

参数	收集为	说明
`*args`	元组	收集多余的位置参数
`**kwargs`	字典	收集多余的关键字参数

参数顺序：普通参数 → *args → 默认参数 → **kwargs

📌 记忆要点

*args 收集多余参数为元组
**kwargs 收集关键字参数为字典
args 和 kwargs 是约定名称，可自定义

第 21 题¶

下列程序的输出结果是（）。

Python
x = 5
def outer():
    x = 10
    def inner():
        nonlocal x
        x = 20
    inner()
    print(x, end=" ")
outer()
print(x)

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

答案

A

📖 解析：

nonlocal x 声明 x 引用外层（outer）函数的变量
inner() 中 x = 20 修改的是 outer 中的 x，不是全局 x
inner() 执行后，outer 中的 x 变为 20
全局 x 不受影响，仍为 5

Python
x = 5              # 全局变量
def outer():
    x = 10          # outer 的局部变量
    def inner():
        nonlocal x  # 声明使用 outer 的 x
        x = 20      # 修改 outer 的 x
    inner()
    print(x, end=" ")  # 20（outer 的 x 被修改）
outer()
print(x)           # 5（全局 x 不受影响）

🔑 知识点：nonlocal vs global

关键字	作用范围	说明
`global`	全局变量	在最外层（模块）作用域
`nonlocal`	外层函数变量	在嵌套函数中使用

📌 记忆要点

nonlocal 修改外层函数的变量
global 修改全局变量
两者都不影响各自范围以外的变量

第 22 题¶

表达式 bool("") 的结果是（）。

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

答案

B

📖 解析：

"" 是空字符串，在布尔上下文中为 False
bool("") → False
任何空容器的布尔值都为 False

Python
bool("")      # False（空字符串）
bool(" ")     # True（含空格，非空字符串）
bool("0")     # True（非空字符串）
bool([])      # False（空列表）
bool([0])     # True（非空列表）
bool(0)       # False（零值）
bool(0.0)     # False（零值）
bool(None)    # False（空值）

🔑 知识点：Python Falsy 值

以下值 bool() 为 False：

值	说明
`0`, `0.0`	零值
`""`	空字符串
`[]`, `()`, `{}`, `set()`	空容器
`None`	空值
`False`	布尔假

📌 记忆要点

空字符串 "" 的布尔值为 False
非空字符串（包括 "0", " "）布尔值为 True
所有空容器都是 Falsy

第 23 题¶

以下关于 with 语句的说法，正确的是（）。

选项	内容
A	`with` 语句只能用于文件操作
B	`with` 语句可以确保资源被正确释放 ✅
C	`with` 语句打开的文件需要手动关闭
D	`with` 语句不能处理异常

答案

B

📖 解析：

A 错误：with 可用于任何支持上下文管理协议的对象
B 正确：with 语句的核心功能是确保资源正确释放（即使发生异常）
C 错误：with 语句自动关闭文件，不需要手动 close()
D 错误：with 语句本身不处理异常，但即使异常也能保证资源释放

Python
# 文件操作（最常见用法）
with open("data.txt", "r") as f:
    content = f.read()
# 文件自动关闭，即使发生异常

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

🔑 知识点：with 语句（上下文管理器）

特性	说明
自动释放资源	即使异常也会执行清理
不限于文件	任何实现 `__enter__`/`__exit__` 的对象
替代 try-finally	更简洁的资源管理
不处理异常	异常仍会传播，但资源已释放

📌 记忆要点

with 确保资源正确释放（自动 close）
不限于文件，可用于锁、数据库连接等
推荐使用 with open() 代替手动 open()/close()

第 24 题¶

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

Python
lst = [3, 1, 4, 1, 5, 9, 2, 6]
print(lst[3:8:2])

选项	内容
A	[4, 5, 2]
B	[1, 5, 9]
C	[1, 9, 6] ✅
D	[3, 4, 5, 2]

答案

C

📖 解析：

Text Only
1 2	`索引: 0 1 2 3 4 5 6 7 值: 3 1 4 1 5 9 2 6`

lst[3:8:2]：起始索引3，终止索引8（不含），步长2
索引3=1，索引3+2=5=9，索引5+2=7=6，索引7+2=9超出范围
结果：[1, 9, 6]

Python
lst = [3, 1, 4, 1, 5, 9, 2, 6]
lst[3:8:2]   # [1, 9, 6]（索引3, 5, 7）
lst[::2]     # [3, 4, 5, 2]（索引0, 2, 4, 6）
lst[1::3]    # [1, 5, 6]（索引1, 4, 7）
lst[::-1]    # [6, 2, 9, 5, 1, 4, 1, 3]（反转）

🔑 知识点：列表切片详解

表达式	结果	说明
`lst[3:8:2]`	[1, 9, 6]	索引3,5,7
`lst[::2]`	[3, 4, 5, 2]	步长2，从头到尾
`lst[1::3]`	[1, 5, 6]	索引1,4,7
`lst[::-1]`	[6, 2, 9, 5, 1, 4, 1, 3]	反转

📌 记忆要点

切片 [start:stop:step] 左闭右开
步长为2时，每隔一个取一个
确定起止索引后按步长跳跃

✅ 二、判断题（每题1分，共14分）¶

第1题 ✅ 对¶

题目： Python中，0 和 0.0 的布尔值相同，都是 False。

答案

✔ 对

解析：

bool(0) → False，bool(0.0) → False
0 和 0.0 都是零值，布尔值相同

Python
bool(0)     # False
bool(0.0)   # False
bool(0 + 0j)  # False（复数零也是False）

知识点范围： Falsy 值

记忆要点： 所有零值（0, 0.0, 0+0j）的布尔值都是 False

第2题 ❌ 错¶

题目： 字符串方法 upper() 会将原字符串修改为大写形式。

答案

✘ 错

解析：

字符串是不可变类型，upper() 返回新字符串，不修改原字符串

Python
s = "hello"
s.upper()    # 返回 "HELLO"
print(s)     # "hello"（原字符串不变）

# 需要接收返回值
s = s.upper()
print(s)     # "HELLO"

知识点范围： 字符串不可变性

记忆要点： 字符串不可变，所有字符串方法返回新字符串，原串不变

第3题 ✅ 对¶

题目： list.pop() 不带参数时，默认删除并返回列表的最后一个元素。

答案

✔ 对

解析：

pop() 不带参数时，默认删除并返回最后一个元素（索引 -1）
pop(index) 带参数时，删除并返回指定索引的元素

Python
lst = [1, 2, 3, 4, 5]
lst.pop()       # 5（删除并返回最后一个）
print(lst)      # [1, 2, 3, 4]

lst.pop(0)      # 1（删除并返回第一个）
print(lst)      # [2, 3, 4]

知识点范围： 列表 pop() 方法

记忆要点： pop() 默认弹出最后一个元素，pop(i) 弹出指定索引

第4题 ✅ 对¶

题目： Python中，元组内的列表元素是可以修改的。

答案

✔ 对

解析：

元组本身不可变，但如果元组内包含可变对象（如列表），该可变对象的内容可以修改
这不违反元组的不可变性——元组存储的是列表的引用，引用不变

Python
t = (1, [2, 3], 4)
t[1].append(5)     # ✅ 修改列表内容
print(t)            # (1, [2, 3, 5], 4)

t[0] = 10           # ❌ TypeError: 不能修改元组元素
t[1] = [7, 8]       # ❌ TypeError: 不能替换元组元素

知识点范围： 元组的不可变性

📖 拓展

元组的不可变性是指元素引用不可变，而非元素内容不可变。这称为"浅不可变"。

记忆要点： 元组不可变是引用不可变，内部可变对象的内容仍可修改

第5题 ❌ 错¶

题目： dict.setdefault(key, default) 方法在键已存在时会修改该键的值。

答案

✘ 错

解析：

setdefault(key, default)：如果键存在，返回该键的值，不修改
如果键不存在，设置键值为 default 并返回

Python
d = {'a': 1, 'b': 2}

# 键已存在：返回值，不修改
d.setdefault('a', 100)  # 返回 1，d 不变
print(d)                  # {'a': 1, 'b': 2}

# 键不存在：设置值并返回
d.setdefault('c', 3)     # 返回 3，d 变为 {'a': 1, 'b': 2, 'c': 3}
print(d)                  # {'a': 1, 'b': 2, 'c': 3}

知识点范围： 字典 setdefault() 方法

记忆要点： setdefault() 键存在时不修改，键不存在时才添加

第6题 ✅ 对¶

题目： 在Python中，and 运算符的优先级高于 or 运算符。

答案

✔ 对

解析：

逻辑运算符优先级：not > and > or
True or False and False 等价于 True or (False and False) → True

Python
True or False and False   # True（等价于 True or (False and False)）
(True or False) and False # False（括号改变了优先级）

# 优先级：not > and > or
not True or True and False   # False
# 等价于：(not True) or (True and False)
# = False or False
# = False

知识点范围： 逻辑运算符优先级

记忆要点： 优先级顺序：not > and > or

第7题 ✅ 对¶

题目： str.zfill(width) 方法可以在字符串左侧填充0使字符串达到指定宽度。

答案

✔ 对

解析：

zfill(width) 在字符串左侧填充 '0'，使字符串达到指定宽度
常用于数字字符串的对齐

Python
"42".zfill(5)      # "00042"
"-42".zfill(5)     # "-0042"（负号在0前面）
"hello".zfill(8)   # "000hello"
"abc".zfill(3)     # "abc"（已达到宽度，不填充）

知识点范围： 字符串对齐方法

📖 拓展

其他对齐方法：ljust(width), rjust(width), center(width)

记忆要点： zfill(width) 左侧补0，负号在0前面

第8题 ✅ 对¶

题目： Python中，float("inf") 表示正无穷大。

答案

✔ 对

解析：

float("inf") 表示正无穷大
float("-inf") 表示负无穷大
常用于初始化最大值或最小值

Python
float("inf")    # inf（正无穷大）
float("-inf")   # -inf（负无穷大）

# 常见用途：初始化最小值
min_val = float("inf")   # 任何数都小于正无穷
max_val = float("-inf")  # 任何数都大于负无穷

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

知识点范围： 浮点数特殊值

记忆要点： float("inf") 正无穷，float("-inf") 负无穷，常用于初始化极值

第9题 ❌ 错¶

题目： list.sort() 和 sorted(list) 的功能完全相同，都会修改原列表。

答案

✘ 错

解析：

list.sort() 是列表方法，原地排序，修改原列表，返回 None
sorted(list) 是内置函数，返回新列表，不修改原列表

Python
lst = [3, 1, 2]

# sort() 原地排序
lst.sort()        # 返回 None，lst 变为 [1, 2, 3]
print(lst)        # [1, 2, 3]（原列表被修改）

lst = [3, 1, 2]
# sorted() 返回新列表
new_lst = sorted(lst)  # 返回 [1, 2, 3]
print(lst)             # [3, 1, 2]（原列表不变）
print(new_lst)         # [1, 2, 3]

知识点范围： sort() vs sorted()

方法	是否修改原列表	返回值	适用范围
`lst.sort()`	是	None	仅列表
`sorted(lst)`	否	新列表	所有可迭代对象

记忆要点： sort() 原地排序返回 None，sorted() 返回新列表不修改原列表

第10题 ✅ 对¶

题目： 函数中如果没有 return 语句，函数将返回 None。

答案

✔ 对

解析：

函数没有 return 语句，或 return 后没有值，都返回 None

Python
def greet(name):
    print("Hello, " + name)
    # 没有 return

result = greet("Tom")  # 输出: Hello, Tom
print(result)          # None

def add(a, b):
    return              # return 无值，也返回 None

print(add(1, 2))       # None

知识点范围： 函数返回值

记忆要点： 无 return 或 return 无值，函数返回 None

第11题 ✅ 对¶

题目： zip() 函数可以将多个可迭代对象的元素按位置打包成元组。

答案

✔ 对

解析：

zip() 将多个可迭代对象按位置打包，返回由元组组成的迭代器
最短的可迭代对象决定打包长度

Python
names = ["Alice", "Bob", "Charlie"]
scores = [90, 85, 92]

list(zip(names, scores))
# [("Alice", 90), ("Bob", 85), ("Charlie", 92)]

# 长度不一致时，以最短的为准
a = [1, 2, 3]
b = ['x', 'y']
list(zip(a, b))   # [(1, 'x'), (2, 'y')]

# 常见用途：同时遍历多个列表
for name, score in zip(names, scores):
    print(f"{name}: {score}")

知识点范围： zip() 函数

记忆要点： zip() 按位置打包，以最短长度为准

第12题 ✅ 对¶

题目： Python中，一个 .py 文件就是一个模块。

答案

✔ 对

解析：

每个 .py 文件都是一个 Python 模块
模块可以被其他文件通过 import 导入
包是包含 __init__.py 的目录

Python
# mymodule.py
def hello():
    print("Hello!")

# 另一个文件中导入
import mymodule
mymodule.hello()   # Hello!

# 也可以
from mymodule import hello
hello()             # Hello!

知识点范围： Python 模块

记忆要点： 一个 .py 文件 = 一个模块

第13题 ✅ 对¶

题目： 字典推导式 {k: v for k, v in items} 是Python支持的语法。

答案

✔ 对

解析：

Python 支持字典推导式，语法为 {key_expr: value_expr for item in iterable}

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

# 从两个列表创建字典
keys = ['a', 'b', 'c']
values = [1, 2, 3]
d = {k: v for k, v in zip(keys, values)}
# {'a': 1, 'b': 2, 'c': 3}

# 带条件
d = {x: x**2 for x in range(10) if x % 2 == 0}
# {0: 0, 2: 4, 4: 16, 6: 36, 8: 64}

知识点范围： 字典推导式

记忆要点： 字典推导式语法：{k: v for ... in ...}

第14题 ❌ 错¶

题目： math.floor(-2.3) 的结果是 -2。

答案

✘ 错

解析：

math.floor() 是向下取整（向负无穷方向取整）
math.floor(-2.3) → -3（不是 -2）
math.floor() 对负数向下取整，结果比原数更小

Python
import math

math.floor(2.3)    # 2（向下取整）
math.floor(2.7)    # 2
math.floor(-2.3)   # -3（向下取整，-3 < -2.3）
math.floor(-2.7)   # -3

# 对比 int() 和 math.trunc()
int(-2.3)          # -2（向零取整）
math.trunc(-2.3)   # -2（截断小数部分）
math.floor(-2.3)   # -3（向下取整）

知识点范围： math.floor() 与取整函数

函数	对正数	对负数	说明
`math.floor()`	向下取整	向下取整	结果 ≤ 原数
`math.ceil()`	向上取整	向上取整	结果 ≥ 原数
`int()`	向零取整	向零取整	截断小数
`math.trunc()`	向零取整	向零取整	同 int()

记忆要点： floor() 向下取整，floor(-2.3) = -3，不是 -2

✏️ 三、程序填空题（每题10分，共30分）¶

第1题：统计正负数个数¶

题目： 从键盘输入若干整数（输入0结束），统计正数和负数的个数。

Python
positive = 0
negative = 0
while True:
    num = int(input("请输入一个整数(0结束):"))
    #**********begin1**********
    _______
    #**********end1**********
        break
    #**********begin2**********
    _______
    #**********end2**********
        positive += 1
    else:
        negative += 1
print("正数:", positive, "个")
print("负数:", negative, "个")

✅ 填空答案

begin1： if num == 0:
begin2： if num > 0:

完整正确代码

Python
# 统计正负数个数
positive = 0
negative = 0
while True:
    num = int(input("请输入一个整数(0结束):"))
    if num == 0:               # 【填空1】输入0时退出循环
        break
    if num > 0:                # 【填空2】判断是否为正数
        positive += 1
    else:
        negative += 1
print("正数:", positive, "个")
print("负数:", negative, "个")

运行示例：

Text Only

请输入一个整数(0结束): 5
请输入一个整数(0结束): -3
请输入一个整数(0结束): 8
请输入一个整数(0结束): -1
请输入一个整数(0结束): 0
正数: 2 个
负数: 2 个

🔑 知识点：while循环、break、条件判断

while True 配合 break 实现不确定次数的循环
break 立即退出循环
0 既不是正数也不是负数，作为退出标志

📌 记忆要点

while True + break 是常见的循环控制模式
先判断退出条件，再处理数据
0 是正负数的分界点，适合做退出标志

第2题：冒泡排序优化¶

题目： 对列表使用冒泡排序进行升序排列（如果某轮没有交换则提前结束）。

Python
lst = [64, 34, 25, 12, 22, 11, 90]
n = len(lst)
for i in range(n - 1):
    #**********begin1**********
    _______
    #**********end1**********
    for j in range(0, n - i - 1):
        if lst[j] > lst[j + 1]:
            lst[j], lst[j + 1] = lst[j + 1], lst[j]
            #**********begin2**********
            _______
            #**********end2**********
    #**********begin3**********
    _______
    #**********end3**********
print("排序后:", lst)

✅ 填空答案

begin1： swapped = False
begin2： swapped = True
begin3： if not swapped: break

完整正确代码

Python
# 冒泡排序优化版
lst = [64, 34, 25, 12, 22, 11, 90]
n = len(lst)
for i in range(n - 1):
    swapped = False              # 【填空1】每轮开始前标记为未交换
    for j in range(0, n - i - 1):
        if lst[j] > lst[j + 1]:
            lst[j], lst[j + 1] = lst[j + 1], lst[j]
            swapped = True       # 【填空2】发生交换，标记为True
    if not swapped:              # 【填空3】本轮无交换，提前结束
        break
print("排序后:", lst)

运行结果： 排序后: [11, 12, 22, 25, 34, 64, 90]

🔑 知识点：冒泡排序优化

冒泡排序：相邻元素比较，大的往后冒泡
优化：如果某一轮没有发生交换，说明已经有序，提前结束
swapped 标志位记录本轮是否有交换

📌 记忆要点

每轮开始前设 swapped = False
发生交换时设 swapped = True
每轮结束后检查，无交换则 break
优化后最好情况 O(n)，最坏情况 O(n²)

第3题：字符串加密¶

题目： 将字符串中的每个字母替换为字母表中其后一个字母（z替换为a，Z替换为A），非字母字符不变。

Python
s = input("请输入字符串:")
result = ""
for ch in s:
    if 'a' <= ch <= 'z':
        #**********begin1**********
        _______
        #**********end1**********
    elif 'A' <= ch <= 'Z':
        #**********begin2**********
        _______
        #**********end2**********
    else:
        result += ch
print("加密后:", result)

✅ 填空答案

begin1： result += chr((ord(ch) - ord('a') + 1) % 26 + ord('a'))
begin2： result += chr((ord(ch) - ord('A') + 1) % 26 + ord('A'))

完整正确代码

Python
# 字符串加密（凯撒密码，偏移量为1）
s = input("请输入字符串:")
result = ""
for ch in s:
    if 'a' <= ch <= 'z':
        # 【填空1】小写字母后移1位，z变a
        result += chr((ord(ch) - ord('a') + 1) % 26 + ord('a'))
    elif 'A' <= ch <= 'Z':
        # 【填空2】大写字母后移1位，Z变A
        result += chr((ord(ch) - ord('A') + 1) % 26 + ord('A'))
    else:
        result += ch
print("加密后:", result)

运行示例：

Text Only
1 2	`请输入字符串: Hello World! Zz 加密后: Ifmmp Xpsme! Aa`

🔑 知识点：字符编码、ord()、chr()

函数	功能	示例
`ord(ch)`	字符→ASCII码	`ord('a')` → 97
`chr(n)`	ASCII码→字符	`chr(97)` → 'a'
`% 26`	循环26个字母	z后移→a

Python
# 'z' 后移1位的处理
ord('z') - ord('a') + 1 = 25 + 1 = 26
26 % 26 = 0
0 + ord('a') = 97
chr(97) = 'a'  # z → a ✅

📌 记忆要点

ord() 字符转编码，chr() 编码转字符
% 26 实现字母循环（z→a，Z→A）
非字母字符直接保留

🔧 四、程序改错题（每题10分，共40分）¶

第1题：求最大公约数¶

题目： 使用辗转相除法求两个正整数的最大公约数。

Python
a = int(input("请输入第一个正整数:"))
b = int(input("请输入第二个正整数:"))
#**********begin1**********
while a / b != 0:
#**********end1**********
    #**********begin2**********
    a = b
    b = a % b
    #**********end2**********
#**********begin3**********
print("最大公约数:", a)
#**********end3**********

✅ 错误修正

错误位置	原代码	修正后	错误原因
begin1	`while a / b != 0:`	`while b != 0:`	`/` 是浮点除法且判断条件应为 `b != 0`
begin2	`a = b` 然后 `b = a % b`	`a, b = b, a % b`	先赋值a会导致计算b时a已改变
begin3	`print("最大公约数:", a)`	`print("最大公约数:", a)`	此行正确，但需确保前面修正后a存结果

完整正确代码

Python
# 辗转相除法求最大公约数
a = int(input("请输入第一个正整数:"))
b = int(input("请输入第二个正整数:"))
while b != 0:                     # ✅ 修正1：条件应为 b != 0
    a, b = b, a % b               # ✅ 修正2：同时交换，避免a被覆盖
print("最大公约数:", a)

运行示例：

Text Only
1 2 3	`请输入第一个正整数: 48 请输入第二个正整数: 18 最大公约数: 6`

辗转相除法过程（48 和 18）：

Text Only
1 2 3 4	`48 ÷ 18 = 2 余 12 → a=18, b=12 18 ÷ 12 = 1 余 6 → a=12, b=6 12 ÷ 6 = 2 余 0 → a=6, b=0 → 结束最大公约数: 6`

🔑 知识点：辗转相除法、while循环、赋值顺序

辗转相除法：gcd(a, b) = gcd(b, a % b)，当 b == 0 时，a 即为最大公约数
同时赋值 a, b = b, a % b 避免中间变量
条件 b != 0 而非 a / b != 0

📌 记忆要点

辗转相除法：while b != 0: a, b = b, a % b
循环条件是 b != 0，不是 a / b != 0
Python 支持同时赋值：a, b = b, a % b

第2题：列表去重保持顺序¶

题目： 删除列表中的重复元素，同时保持原始顺序。

Python
lst = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3]
#**********begin1**********
result = {}
#**********end1**********
for item in lst:
    #**********begin2**********
    if item not in lst:
    #**********end2**********
        result.append(item)
#**********begin3**********
print("去重后:", result)
#**********end3**********

✅ 错误修正

错误位置	原代码	修正后	错误原因
begin1	`result = {}`	`result = []`	`{}` 创建字典，应用 `[]` 创建列表
begin2	`if item not in lst:`	`if item not in result:`	应在 result 中检查，不是在原列表
begin3	`print("去重后:", result)`	`print("去重后:", result)`	此行正确（修正前两处后即可）

完整正确代码

Python
# 列表去重保持顺序
lst = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3]
result = []                          # ✅ 修正1：用列表，不是字典
for item in lst:
    if item not in result:           # ✅ 修正2：在result中检查，不是lst
        result.append(item)
print("去重后:", result)

运行结果： 去重后: [3, 1, 4, 5, 9, 2, 6]

🔑 知识点：列表去重、列表与字典的区别

Python
# 方法1：遍历判断（本题方法）
result = []
for item in lst:
    if item not in result:
        result.append(item)

# 方法2：利用字典键唯一（Python 3.7+ 有序）
result = list(dict.fromkeys(lst))

# 方法3：利用集合去重（不保持顺序）
result = list(set(lst))

📌 记忆要点

{} 创建字典，[] 创建列表
去重时应在新列表中检查，不是原列表
set() 去重不保持顺序，手动遍历可保持顺序

第3题：统计元音字母¶

题目： 统计字符串中元音字母（a, e, i, o, u）的个数，不区分大小写。

Python
s = input("请输入字符串:")
count = 0
#**********begin1**********
for i in range(1, len(s)):
#**********end1**********
    #**********begin2**********
    if s[i].lower in "aeiou":
    #**********end2**********
        count += 1
#**********begin3**********
print("元音字母个数:" + count)
#**********end3**********

✅ 错误修正

错误位置	原代码	修正后	错误原因
begin1	`range(1, len(s))`	`range(len(s))` 或 `range(0, len(s))`	索引从1开始会跳过第一个字符
begin2	`s[i].lower`	`s[i].lower()`	`lower` 是方法，调用需要加括号
begin3	`"元音字母个数:" + count`	`"元音字母个数:" + str(count)` 或 `print("元音字母个数:", count)`	字符串和整数不能直接用 `+` 拼接

完整正确代码

Python
# 统计元音字母个数
s = input("请输入字符串:")
count = 0
for i in range(len(s)):              # ✅ 修正1：从0开始遍历
    if s[i].lower() in "aeiou":      # ✅ 修正2：lower() 加括号
        count += 1
print("元音字母个数:", count)          # ✅ 修正3：用逗号分隔或str()转换

运行示例：

Text Only
1 2	`请输入字符串: Hello World 元音字母个数: 3`

错误分析：

Python
# 错误1：range(1, len(s)) 跳过了索引0
# "Hello" → 索引1开始，跳过'H'，可能漏掉元音
s = "Apple"
# range(1, 5) → i=1,2,3,4 → 跳过了索引0的'A'（元音！）

# 错误2：s[i].lower 少了括号
# lower 是方法，不是属性
"Hello".lower    # <built-in method lower>（方法对象）
"Hello".lower()  # "hello"（调用方法返回结果）

# 错误3：字符串 + 整数
"个数:" + 3      # ❌ TypeError: can only concatenate str to str
"个数:" + str(3) # ✅ "个数:3"
"个数:", 3       # ✅ print 中用逗号

🔑 知识点：range起始索引、方法调用、字符串拼接

错误类型	示例	修正
索引从1开始	`range(1, len(s))`	`range(len(s))`
方法缺少括号	`s.lower`	`s.lower()`
字符串拼接整数	`"x" + n`	`"x" + str(n)` 或 `"x", n`

📌 记忆要点

range(len(s)) 从0开始，range(1, len(s)) 从1开始会漏掉首字符
方法调用必须加括号：lower() 不是 lower
字符串和数字拼接用 str() 转换或 print() 逗号分隔

第4题：斐波那契数列¶

题目： 输出斐波那契数列的前n项。

Python
n = int(input("请输入项数:"))
#**********begin1**********
a, b = 0, 1
for i in range(n):
#**********end1**********
    print(a, end=" ")
    #**********begin2**********
    a = b
    b = a + b
    #**********end2**********

✅ 错误修正

错误位置	原代码	修正后	错误原因
begin2	`a = b` 然后 `b = a + b`	`a, b = b, a + b`	顺序赋值导致 `b = a + b` 中 a 已经是新的 b

完整正确代码

Python
# 斐波那契数列
n = int(input("请输入项数:"))
a, b = 0, 1
for i in range(n):
    print(a, end=" ")
    a, b = b, a + b           # ✅ 修正：同时赋值，避免a被覆盖

运行示例：

Text Only
1 2	`请输入项数: 10 0 1 1 2 3 5 8 13 21 34`

错误分析：

Python
# ❌ 错误写法
a = b        # 此时 a 被覆盖为 b 的值
b = a + b    # 这里 a 已经是新的 b，所以 b = b + b = 2b（错误！）

# 例如：a=3, b=5
# 错误：a=5, b=5+5=10（实际应为 a=5, b=8）

# ✅ 正确写法：同时赋值
a, b = b, a + b
# 先计算右边的值，再同时赋给左边
# a=3, b=5 → a=5, b=3+5=8 ✅

🔑 知识点：斐波那契数列、同时赋值

斐波那契数列：0, 1, 1, 2, 3, 5, 8, 13, 21, ...
规则：F(n) = F(n-1) + F(n-2)
Python 同时赋值 a, b = b, a + b 先计算右边再赋值

📌 记忆要点

a, b = b, a + b 是同时赋值，先算右边再赋值
分两行赋值 a = b; b = a + b 会出错，因为 a 已被覆盖
斐波那契数列：0, 1, 1, 2, 3, 5, 8, ...

💻 五、程序设计题（每题13分，共26分）¶

第1题：统计单词频率¶

题目： 编写程序，输入一段英文，统计每个单词出现的次数，并按次数从高到低输出。

要求： 1. 不区分大小写（"The" 和 "the" 算同一个单词） 2. 忽略标点符号（只保留字母和空格） 3. 按出现次数从高到低排序输出

示例输入： the cat sat on the mat the cat

示例输出：

Text Only
1 2 3 4 5	`the: 3 cat: 2 sat: 1 on: 1 mat: 1`

方法1：字典统计 + sorted排序（推荐）

Python
def main():
    text = input("请输入一段英文:")

    # 1. 转小写
    text = text.lower()

    # 2. 去除标点，只保留字母和空格
    clean_text = ""
    for ch in text:
        if ch.isalpha() or ch == " ":
            clean_text += ch

    # 3. 分割为单词列表
    words = clean_text.split()

    # 4. 统计每个单词出现次数
    word_count = {}
    for word in words:
        if word in word_count:
            word_count[word] += 1
        else:
            word_count[word] = 1

    # 5. 按次数从高到低排序
    sorted_words = sorted(word_count.items(), key=lambda x: x[1], reverse=True)

    # 6. 输出结果
    for word, count in sorted_words:
        print(f"{word}: {count}")

main()

方法2：使用 collections.Counter

Python
from collections import Counter

def main():
    text = input("请输入一段英文:")
    text = text.lower()

    # 去除标点
    clean_text = ""
    for ch in text:
        if ch.isalpha() or ch == " ":
            clean_text += ch

    words = clean_text.split()
    word_count = Counter(words)

    for word, count in word_count.most_common():
        print(f"{word}: {count}")

main()

方法3：使用 setdefault 简化统计

Python
def main():
    text = input("请输入一段英文:")
    text = text.lower()

    clean_text = ""
    for ch in text:
        if ch.isalpha() or ch == " ":
            clean_text += ch

    words = clean_text.split()

    # 使用 setdefault 简化
    word_count = {}
    for word in words:
        word_count[word] = word_count.get(word, 0) + 1

    # 排序输出
    for word, count in sorted(word_count.items(), key=lambda x: x[1], reverse=True):
        print(f"{word}: {count}")

main()

🔑 知识点：字符串处理、字典统计、排序

步骤	方法	说明
转小写	`text.lower()`	统一大小写
去标点	`isalpha()` 判断	只保留字母和空格
分词	`split()`	按空格分割
统计	字典 `get()` 方法	计数
排序	`sorted(items, key=..., reverse=True)`	按值排序

📌 记忆要点

字符串处理三步：转小写 → 去标点 → 分词
dict.get(key, 0) + 1 简化计数
sorted(d.items(), key=lambda x: x[1], reverse=True) 按值降序排序
Counter.most_common() 直接获取排序结果

第2题：学生成绩管理¶

题目： 编写程序实现学生成绩管理，功能如下：

添加学生（姓名和3科成绩）
按姓名查询学生成绩
显示所有学生信息及平均分
按平均分从高到低排序显示
输入0退出

要求：使用字典存储学生信息，字典的键为姓名，值为3科成绩的列表。

示例交互：

Text Only

1.添加 2.查询 3.显示全部 4.按平均分排序 0.退出: 1
输入姓名: 张三
输入3科成绩(空格分隔): 85 90 78
添加成功！
1.添加 2.查询 3.显示全部 4.按平均分排序 0.退出: 3
张三: [85, 90, 78] 平均分: 84.33

方法1：基础实现（推荐）

Python
def main():
    students = {}  # {姓名: [成绩1, 成绩2, 成绩3]}

    while True:
        print("\n1.添加 2.查询 3.显示全部 4.按平均分排序 0.退出")
        choice = input("请选择:")

        if choice == "0":
            print("程序结束！")
            break

        elif choice == "1":  # 添加学生
            name = input("输入姓名:")
            if name in students:
                print("该学生已存在！")
                continue
            scores = input("输入3科成绩(空格分隔):")
            score_list = [float(s) for s in scores.split()]
            if len(score_list) != 3:
                print("请输入3科成绩！")
                continue
            students[name] = score_list
            print("添加成功！")

        elif choice == "2":  # 查询学生
            name = input("输入姓名:")
            if name in students:
                scores = students[name]
                avg = sum(scores) / len(scores)
                print(f"{name}: {scores} 平均分: {avg:.2f}")
            else:
                print("未找到该学生！")

        elif choice == "3":  # 显示全部
            if not students:
                print("暂无学生信息！")
                continue
            for name, scores in students.items():
                avg = sum(scores) / len(scores)
                print(f"{name}: {scores} 平均分: {avg:.2f}")

        elif choice == "4":  # 按平均分排序
            if not students:
                print("暂无学生信息！")
                continue
            sorted_students = sorted(
                students.items(),
                key=lambda x: sum(x[1]) / len(x[1]),
                reverse=True
            )
            for name, scores in sorted_students:
                avg = sum(scores) / len(scores)
                print(f"{name}: {scores} 平均分: {avg:.2f}")

        else:
            print("无效选择！")

main()

方法2：使用函数封装

Python
def add_student(students):
    """添加学生"""
    name = input("输入姓名:")
    if name in students:
        print("该学生已存在！")
        return
    scores = input("输入3科成绩(空格分隔):")
    score_list = [float(s) for s in scores.split()]
    if len(score_list) != 3:
        print("请输入3科成绩！")
        return
    students[name] = score_list
    print("添加成功！")

def query_student(students):
    """查询学生"""
    name = input("输入姓名:")
    if name in students:
        scores = students[name]
        avg = sum(scores) / len(scores)
        print(f"{name}: {scores} 平均分: {avg:.2f}")
    else:
        print("未找到该学生！")

def show_all(students):
    """显示全部学生"""
    if not students:
        print("暂无学生信息！")
        return
    for name, scores in students.items():
        avg = sum(scores) / len(scores)
        print(f"{name}: {scores} 平均分: {avg:.2f}")

def sort_by_avg(students):
    """按平均分排序"""
    if not students:
        print("暂无学生信息！")
        return
    sorted_students = sorted(
        students.items(),
        key=lambda x: sum(x[1]) / len(x[1]),
        reverse=True
    )
    for name, scores in sorted_students:
        avg = sum(scores) / len(scores)
        print(f"{name}: {scores} 平均分: {avg:.2f}")

def main():
    students = {}
    while True:
        print("\n1.添加 2.查询 3.显示全部 4.按平均分排序 0.退出")
        choice = input("请选择:")
        if choice == "0":
            print("程序结束！")
            break
        elif choice == "1":
            add_student(students)
        elif choice == "2":
            query_student(students)
        elif choice == "3":
            show_all(students)
        elif choice == "4":
            sort_by_avg(students)
        else:
            print("无效选择！")

main()

🔑 知识点：字典操作、菜单循环、排序

操作	方法	说明
添加	`d[key] = value`	键值对添加
查询	`key in d` / `d.get(key)`	判断或获取
遍历	`d.items()`	键值对遍历
排序	`sorted(d.items(), key=..., reverse=True)`	按值排序
格式化	`f"{avg:.2f}"`	保留2位小数

📌 记忆要点

用字典 {姓名: [成绩列表]} 存储学生信息
while True + 菜单实现交互循环
sorted(dict.items(), key=lambda x: ..., reverse=True) 按值排序
f"{value:.2f}" 保留2位小数
函数封装使代码结构更清晰