Python 模拟考试 7 — 解析

📝 一、单选题¶

第1题¶

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

选项	内容
A	'A'
B	65 ✅
C	97
D	报错

答案

B

📖 解析：

ord() 函数返回字符对应的ASCII码（整数）
'A' 的ASCII码是 65
'a' 的ASCII码是 97
ord() 的逆函数是 chr()，chr(65) → 'A'

Python
ord('A')   # 65
ord('a')   # 97
ord('0')   # 48
chr(65)    # 'A'
chr(97)    # 'a'

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

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

常用ASCII码：'A'=65, 'Z'=90, 'a'=97, 'z'=122, '0'=48, '9'=57

📌 记忆要点

ord() 字符转数字，chr() 数字转字符
大写字母 A=65，小写字母 a=97，数字 0=48
大写转小写：chr(ord('A') + 32) → 'a'

第2题¶

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

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

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

答案

B

📖 解析：

a, b = 10, 20：多重赋值，a=10, b=20
a, b = b, a：Python 的变量交换语法
右侧先求值：(b, a) = (20, 10)
然后同时赋值给左侧：a=20, b=10

Python
# Python 交换变量（一步完成）
a, b = b, a    # ✅ 推荐

# 等价于传统方法
temp = a
a = b
b = temp

🔑 知识点：多重赋值与变量交换

Python 支持多重赋值：a, b, c = 1, 2, 3
右侧表达式先全部求值，再统一赋值给左侧
这是 Python 最优雅的变量交换方式

📌 记忆要点

a, b = b, a 是 Python 交换变量的标准写法
右侧先求值，再同时赋值给左侧
不需要临时变量

第3题¶

下列关于Python元组的说法，正确的是（）。

选项	内容
A	元组只有一个元素时，写法为 `(1)`
B	元组可以通过索引修改元素
C	元组是不可变序列，创建后不能修改元素 ✅
D	元组不支持 `len()` 函数

答案

C

📖 解析：

A 错误：(1) 是整数 1，不是元组。单元素元组必须加逗号：(1,)
B 错误：元组不可变，不能通过索引修改，t[0] = 10 会报 TypeError
C 正确：元组是不可变（immutable）序列，创建后不能增删改
D 错误：元组支持 len()，如 len((1, 2, 3)) → 3

Python
# 单元素元组
t1 = (1,)     # 元组，type → <class 'tuple'>
t2 = (1)      # 整数，type → <class 'int'>

# 元组不可变
t = (1, 2, 3)
t[0] = 10     # ❌ TypeError: 'tuple' object does not support item assignment

# 元组支持 len()
len((1, 2, 3))  # 3

🔑 知识点：元组的特性

特性	说明
不可变	创建后不能增删改
单元素写法	`(1,)` 必须加逗号
支持索引	`t[0]`、`t[-1]`
支持切片	`t[1:3]`
支持len	`len(t)`
可做字典键	因为不可变（hashable）

📌 记忆要点

元组不可变，创建后不能修改
单元素元组必须加逗号：(1,) 不是 (1)
元组支持索引、切片、len()等操作

第4题¶

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

Python
lst = [1, 2, 3]
lst.append([4, 5])
lst.extend([6, 7])
print(len(lst))

选项	内容
A	7
B	5
C	6 ✅
D	8

答案

C

📖 解析：

逐步分析：

lst = [1, 2, 3] → 列表长度3
lst.append([4, 5]) → 将 [4, 5] 作为一个整体追加 → [1, 2, 3, [4, 5]]，长度4
lst.extend([6, 7]) → 将 [6, 7] 逐个追加 → [1, 2, 3, [4, 5], 6, 7]，长度6

Python
lst = [1, 2, 3]
lst.append([4, 5])   # [1, 2, 3, [4, 5]]     ← 整体追加
lst.extend([6, 7])   # [1, 2, 3, [4, 5], 6, 7] ← 逐个追加
len(lst)              # 6

🔑 知识点：append() 与 extend() 的区别

方法	行为	示例	结果
`append(x)`	将x作为一个整体追加	`[1,2].append([3,4])`	`[1,2,[3,4]]`
`extend(x)`	将x中元素逐个追加	`[1,2].extend([3,4])`	`[1,2,3,4]`
`+=`	等价于extend	`[1,2]+=[3,4]`	`[1,2,3,4]`

📌 记忆要点

append() 整体追加，extend() 逐个追加
append([4,5]) 加1个元素，extend([4,5]) 加2个元素
lst += [6, 7] 等价于 lst.extend([6, 7])

第5题¶

表达式 3 > 2 > 1 的结果是（）。

选项	内容
A	True ✅
B	False
C	报错
D	不确定

答案

A

📖 解析：

Python 支持链式比较（chained comparison）
3 > 2 > 1 等价于 (3 > 2) and (2 > 1)
3 > 2 → True，2 > 1 → True
True and True → True

Python
> 2 > 1       # True  等价于 (3>2) and (2>1)
> 2 > 2       # False 等价于 (3>2) and (2>2)
< 2 < 3 < 4   # True  支持多个链式
< 2 > 0       # True  (1<2) and (2>0)

🔑 知识点：链式比较

表达式	等价于	结果
`3 > 2 > 1`	`(3>2) and (2>1)`	True
`3 > 2 > 2`	`(3>2) and (2>2)`	False
`1 < 2 < 3`	`(1<2) and (2<3)`	True

Python 的链式比较比数学表达式更直观，其他语言（如C/Java）不支持。

📌 记忆要点

Python 支持链式比较：a < b < c 等价于 (a<b) and (b<c)
每个比较独立计算，再用 and 连接
不是先算 a < b 得 True 再与 c 比较

第6题¶

下列关于 dict.get() 方法的说法，正确的是（）。

选项	内容
A	`dict.get(key)` 在key不存在时会报KeyError
B	`dict.get(key, default)` 在key不存在时返回default ✅
C	`dict.get(key)` 与 `dict[key]` 功能完全相同
D	`dict.get()` 只能获取值，不能设置默认返回值

答案

B

📖 解析：

A 错误：get() 在key不存在时返回 None，不会报错
B 正确：get(key, default) 在key不存在时返回 default 值
C 错误：dict[key] 在key不存在时报 KeyError，get() 不会
D 错误：get() 支持第二个参数设置默认值

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

# dict[key] 方式
d['a']         # 1
d['c']         # ❌ KeyError: 'c'

# dict.get() 方式
d.get('a')          # 1
d.get('c')          # None（key不存在，默认返回None）
d.get('c', 0)       # 0（key不存在，返回指定的默认值）
d.get('c', '未找到') # '未找到'

🔑 知识点：字典访问方式对比

方式	key不存在时	示例	结果
`d[key]`	抛出KeyError	`d['c']`	KeyError
`d.get(key)`	返回None	`d.get('c')`	None
`d.get(key, default)`	返回default	`d.get('c', 0)`	0

📌 记忆要点

d[key] 访问不存在的键 → KeyError
d.get(key) 访问不存在的键 → None，不报错
d.get(key, default) 可以指定默认返回值

第7题¶

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

Python
x = [1, 2, 3, 2, 1]
print(x.index(2))

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

答案

A

📖 解析：

list.index(value) 返回列表中第一个值为value的元素的索引
列表 x = [1, 2, 3, 2, 1]，值2出现在索引1和索引3
x.index(2) 只返回第一个匹配的索引，即1
如果值不存在，会抛出 ValueError

Python
x = [1, 2, 3, 2, 1]
x.index(2)     # 1（第一个2的索引）
x.index(1)     # 0（第一个1的索引）
x.index(9)     # ❌ ValueError: 9 is not in list

# 查找所有2的索引
[i for i, v in enumerate(x) if v == 2]  # [1, 3]

🔑 知识点：列表查找方法

方法	功能	key不存在时
`lst.index(val)`	返回第一个val的索引	ValueError
`lst.count(val)`	返回val出现的次数	返回0
`val in lst`	判断val是否在列表中	False

📌 记忆要点

index() 只返回第一个匹配的索引
值不存在时抛出 ValueError，不是返回 -1
查找所有位置需用列表推导式

第8题¶

表达式 "Hello".center(11, "*") 的结果是（）。

选项	内容
A	"Hello" ✅
B	"*Hello"
C	"Hello*"
D	"*Hello"

答案

A

📖 解析：

str.center(width, fillchar) 将字符串居中，用fillchar填充两侧
"Hello" 长度为5，目标宽度为11，两侧各填充 (11-5)/2 = 3 个字符
结果为 "***Hello***"

Python
"Hello".center(11, "*")   # '***Hello***'
"Hello".center(10, "*")   # '***Hello**'  (奇数多出1个填右边)
"Hello".center(5, "*")    # 'Hello'       (无需填充)
"Hello".center(20, "-")   # '-------Hello--------'

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

方法	功能	示例
`center(w, c)`	居中对齐	`"Hi".center(6,"-")` → `--Hi--`
`ljust(w, c)`	左对齐	`"Hi".ljust(6,"-")` → `Hi----`
`rjust(w, c)`	右对齐	`"Hi".rjust(6,"-")` → `----Hi`
`zfill(w)`	左侧填0	`"42".zfill(5)` → `00042`

📌 记忆要点

center() 居中，ljust() 左对齐，rjust() 右对齐
总宽度不足时返回原字符串
奇数多余字符填充在右侧

第9题¶

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

Python
s1 = {1, 2, 3}
s2 = {2, 3, 4}
print(s1 - s2)

选项	内容
A	{1} ✅
B	{4}
C	{1, 4}
D	报错

答案

A

📖 解析：

集合的 - 运算是差集操作
s1 - s2：在s1中但不在s2中的元素
s1 = {1, 2, 3}，s2 = {2, 3, 4}
在s1中但不在s2中：{1}

Python
s1 = {1, 2, 3}
s2 = {2, 3, 4}

s1 - s2       # {1}    差集：s1有但s2没有
s2 - s1       # {4}    差集：s2有但s1没有
s1 & s2       # {2, 3} 交集：两者都有
s1 | s2       # {1,2,3,4} 并集：所有元素
s1 ^ s2       # {1, 4} 对称差集：只在其中一个

🔑 知识点：集合运算

运算符	方法	含义	示例
`\\|`	`union()`	并集	`{1,2}\\|{2,3}` → `{1,2,3}`
`&`	`intersection()`	交集	`{1,2}&{2,3}` → `{2}`
`-`	`difference()`	差集	`{1,2}-{2,3}` → `{1}`
`^`	`symmetric_difference()`	对称差集	`{1,2}^{2,3}` → `{1,3}`

📌 记忆要点

- 差集：左边有但右边没有
& 交集：两边都有
| 并集：所有元素
^ 对称差集：只在一边有

第10题¶

以下关于Python函数参数的说法，错误的是（）。

选项	内容
A	`*args` 用于接收任意数量的位置参数
B	`**kwargs` 用于接收任意数量的关键字参数
C	函数调用时关键字参数必须在位置参数之后
D	默认参数可以放在非默认参数之前 ✅

答案

D

📖 解析：

A 正确：*args 将多余的位置参数收集为元组
B 正确：**kwargs 将多余的关键字参数收集为字典
C 正确：调用函数时，位置参数在前，关键字参数在后
D 错误：默认参数必须放在非默认参数之后，否则会报语法错误

Python
# ✅ 正确：默认参数在后
def func(a, b=2):
    pass

# ❌ 错误：默认参数在前
def func(a=1, b):  # SyntaxError: non-default argument follows default argument
    pass

# *args 示例
def f1(*args):
    print(args)
f1(1, 2, 3)  # (1, 2, 3)

# **kwargs 示例
def f2(**kwargs):
    print(kwargs)
f2(x=1, y=2)  # {'x': 1, 'y': 2}

🔑 知识点：函数参数顺序

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

Python
def func(a, b, c=3, *args, **kwargs):
    pass

📌 记忆要点

默认参数必须在非默认参数之后
*args 收集多余位置参数为元组
**kwargs 收集多余关键字参数为字典
调用时位置参数在前，关键字参数在后

第11题¶

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

Python
result = "Python" if 3 > 5 else "Java"
print(result)

选项	内容
A	Python
B	Java ✅
C	报错
D	None

答案

B

📖 解析：

这是Python的三元条件表达式（条件表达式）
语法：值1 if 条件 else 值2
条件为True返回值1，条件为False返回值2
3 > 5 → False，所以返回 "Java"

Python
# 三元条件表达式
x = 10
"偶数" if x % 2 == 0 else "奇数"   # "偶数"

# 等价于
if x % 2 == 0:
    result = "偶数"
else:
    result = "奇数"

🔑 知识点：三元条件表达式

语法	说明
`值1 if 条件 else 值2`	条件为True返回值1，否则返回值2

注意：Python的三元表达式顺序与C/Java不同！ - Python: A if cond else B - C/Java: cond ? A : B

📌 记忆要点

语法：值1 if 条件 else 值2
条件为True取值1，False取值2
必须有 else 部分，不能省略

第12题¶

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

Python
for i in range(5):
    if i == 3:
        break
else:
    print("完成")
print(i)

选项	内容
A	完成 3
B	完成 4
C	3 ✅
D	4

答案

C

📖 解析：

for...else 结构中，else 块只在循环正常结束（未被break中断）时执行
当 i == 3 时，break 跳出循环，else 块不会执行
循环结束时 i = 3，打印 3

Python
# break 跳出 → else 不执行
for i in range(5):
    if i == 3:
        break
else:
    print("完成")   # 不执行
print(i)            # 3

# 正常结束 → else 执行
for i in range(5):
    pass
else:
    print("完成")   # 执行，输出 "完成"
print(i)            # 4

🔑 知识点：for...else 结构

情况	else是否执行
循环正常结束	✅ 执行
循环被break中断	❌ 不执行
循环被return中断	❌ 不执行
空循环（range(0)）	✅ 执行

while...else 同理。

📌 记忆要点

for...else 的 else 在循环未被break中断时执行
break 跳出 → else 不执行
正常遍历完成 → else 执行

第13题¶

表达式 chr(97) 的结果是（）。

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

答案

B

📖 解析：

chr() 函数将整数（ASCII码/Unicode码位）转换为对应的字符
chr(97) → 'a'（小写字母a的ASCII码是97）
chr(65) → 'A'（大写字母A的ASCII码是65）

Python
chr(97)    # 'a'
chr(65)    # 'A'
chr(48)    # '0'
chr(20013) # '中'（Unicode）

🔑 知识点：chr() 函数

函数	功能	示例
`chr(n)`	整数→字符	`chr(97)` → `'a'`
`ord(c)`	字符→整数	`ord('a')` → 97

两者互为逆函数：chr(ord('a')) → 'a'

📌 记忆要点

chr() 数字转字符，ord() 字符转数字
chr(97) = 'a'，chr(65) = 'A'
支持Unicode：chr(20013) = '中'

第14题¶

下列关于 list.sort() 和 sorted() 的说法，正确的是（）。

选项	内容
A	`sort()` 返回排序后的新列表
B	`sorted()` 会修改原列表
C	`sort()` 是列表方法，会修改原列表 ✅
D	`sorted()` 只能排序列表，不能排序字符串

答案

C

📖 解析：

A 错误：sort() 是原地排序，返回 None，不返回新列表
B 错误：sorted() 返回新列表，不修改原列表
C 正确：sort() 是列表的内置方法，直接修改原列表
D 错误：sorted() 可以排序任何可迭代对象（字符串、元组等）

Python
# sort()：原地排序，返回None
lst = [3, 1, 2]
result = lst.sort()
print(lst)      # [1, 2, 3]  ← 原列表被修改
print(result)   # None       ← 返回None

# sorted()：返回新列表，不修改原列表
lst = [3, 1, 2]
result = sorted(lst)
print(lst)      # [3, 1, 2]  ← 原列表不变
print(result)   # [1, 2, 3]  ← 新列表

# sorted() 可以排序字符串
sorted("hello")  # ['e', 'h', 'l', 'l', 'o']

🔑 知识点：sort() 与 sorted() 对比

特性	`lst.sort()`	`sorted(iterable)`
适用对象	仅列表	任何可迭代对象
返回值	None	新列表
是否修改原列表	是	否
参数	`reverse`, `key`	`reverse`, `key`

📌 记忆要点

sort() 原地排序，返回None，修改原列表
sorted() 返回新列表，不修改原列表
sorted() 可排序字符串、元组等可迭代对象

第15题¶

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

Python
print(":".join("2024"))

选项	内容
A	"2024"
B	"2:0:2:4" ✅
C	报错
D	"2:0:24"

答案

B

📖 解析：

str.join(iterable) 将可迭代对象中的元素用指定字符串连接
"2024" 是字符串，可迭代，遍历得到 '2', '0', '2', '4'
用 ":" 连接："2" + ":" + "0" + ":" + "2" + ":" + "4" → "2:0:2:4"

Python
":".join("2024")     # '2:0:2:4'
"-".join("abc")      # 'a-b-c'
",".join(["a","b"])  # 'a,b'
"".join(["H","i"])   # 'Hi'

🔑 知识点：join() 方法

调用者是分隔符，参数是可迭代对象
元素必须是字符串，否则报错

Python
# 元素不是字符串时报错
",".join([1, 2, 3])  # ❌ TypeError
",".join(map(str, [1, 2, 3]))  # ✅ '1,2,3'

📌 记忆要点

join() 的调用者是分隔符，参数是要连接的序列
字符串是可迭代对象，每个字符是元素
元素必须是字符串类型

第16题¶

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

Python
x = [i * 2 for i in range(5) if i % 2 != 0]
print(x)

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

答案

B

📖 解析：

逐步分析列表推导式 [i * 2 for i in range(5) if i % 2 != 0]：

range(5) → 0, 1, 2, 3, 4
if i % 2 != 0 筛选奇数 → 1, 3
i * 2 对筛选结果乘以2 → 2, 6
结果：[2, 6]

Python
# 等价于
x = []
for i in range(5):       # 0, 1, 2, 3, 4
    if i % 2 != 0:       # 筛选奇数: 1, 3
        x.append(i * 2)  # 2, 6
# x = [2, 6]

🔑 知识点：列表推导式

语法：[表达式 for 变量 in 可迭代对象 if 条件]

部分	说明	本题
表达式	对每个元素的计算	`i * 2`
for	遍历	`for i in range(5)`
if	筛选条件（可选）	`if i % 2 != 0`

📌 记忆要点

列表推导式 = for循环 + 条件筛选 + 表达式
执行顺序：遍历 → 筛选 → 表达式
if条件可选，不加则不过滤

第17题¶

以下关于Python字符串格式化的说法，错误的是（）。

选项	内容
A	`f"值是{val}"` 是f-string格式化
B	`"值是{}".format(val)` 是format方法
C	`"值是%d" % val` 是%格式化
D	三种格式化方式中，%格式化是Python 3.6新增的 ✅

答案

D

📖 解析：

A 正确：f-string 以 f 开头，用 {} 嵌入变量
B 正确：format() 方法用 {} 占位符
C 正确：% 格式化是老式格式化方式
D 错误：% 格式化是最早的格式化方式，f-string 才是 Python 3.6 新增的

Python
name = "Python"
year = 2024

# % 格式化（最早）
"欢迎%s %d" % (name, year)        # '欢迎Python 2024'

# format() 方法（Python 2.6+）
"欢迎{} {}".format(name, year)     # '欢迎Python 2024'

# f-string（Python 3.6+）
f"欢迎{name} {year}"               # '欢迎Python 2024'

🔑 知识点：字符串格式化三种方式

方式	版本	示例
`%` 格式化	最早	`"Hello %s" % "World"`
`str.format()`	Python 2.6	`"Hello {}".format("World")`
f-string	Python 3.6	`f"Hello {name}"`

推荐使用 f-string，更简洁直观。

📌 记忆要点

% 格式化是最早的方式，不是3.6新增
format() 是 Python 2.6 引入
f-string 是 Python 3.6 新增，推荐使用

第18题¶

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

Python
d = {"a": 1, "b": 2, "c": 3}
print(list(d.keys()))

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

答案

A

📖 解析：

d.keys() 返回字典所有键的视图对象
list() 将视图对象转换为列表
结果为 ["a", "b", "c"]

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.keys())   # ['a', 'b', 'c']
list(d.values()) # [1, 2, 3]
list(d.items())  # [('a', 1), ('b', 2), ('c', 3)]

🔑 知识点：字典的 keys/values/items 方法

方法	返回类型	内容
`d.keys()`	dict_keys	所有键
`d.values()`	dict_values	所有值
`d.items()`	dict_items	所有键值对（元组）

注意：Python 3 中返回的是视图对象，不是列表。需要列表时用 list() 转换。

📌 记忆要点

keys() 返回键的视图，values() 返回值的视图，items() 返回键值对视图
Python 3 返回视图对象，需要列表时用 list() 转换
视图对象会随字典变化而动态更新

第19题¶

表达式 0.1 + 0.2 == 0.3 的结果是（）。

选项	内容
A	True
B	False ✅
C	报错
D	不确定

答案

B

📖 解析：

浮点数在计算机中使用二进制存储，存在精度问题
0.1 + 0.2 的实际结果是 0.30000000000000004
所以 0.1 + 0.2 == 0.3 为 False

Python
0.1 + 0.2           # 0.30000000000000004
0.1 + 0.2 == 0.3    # False

# 正确的比较方式
abs(0.1 + 0.2 - 0.3) < 1e-9   # True

# 或使用 math.isclose
import math
math.isclose(0.1 + 0.2, 0.3)  # True

🔑 知识点：浮点数精度问题

浮点数采用IEEE 754标准，某些十进制小数无法精确表示为二进制
不要直接用 == 比较浮点数
推荐使用 math.isclose() 或判断差值是否足够小

Python
# 不推荐
if a == b:

# 推荐
if abs(a - b) < 1e-9:
# 或
if math.isclose(a, b):

📌 记忆要点

0.1 + 0.2 != 0.3，这是浮点数精度问题
不要用 == 直接比较浮点数
使用 math.isclose() 或差值比较

第20题¶

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

Python
def func(a, b, *, c):
    return a + b + c
print(func(1, 2, c=3))

选项	内容
A	6 ✅
B	报错
C	None
D	123

答案

A

📖 解析：

函数定义中 * 后面的参数是仅限关键字参数（keyword-only）
a 和 b 是位置参数，c 是仅限关键字参数
调用时 c 必须用关键字方式传递
func(1, 2, c=3) → a=1, b=2, c=3 → 1+2+3=6

Python
def func(a, b, *, c):
    return a + b + c

func(1, 2, c=3)   # ✅ 6
func(1, 2, 3)      # ❌ TypeError: func() takes 2 positional arguments but 3 were given
func(1, b=2, c=3)  # ✅ 6

🔑 知识点：仅限关键字参数

参数类型	定义方式	调用方式
位置参数	`def f(a, b)`	`f(1, 2)`
默认参数	`def f(a, b=2)`	`f(1)` 或 `f(1, 3)`
仅限关键字参数	`def f(a, *, b)`	`f(1, b=2)`，b必须用关键字
可变位置参数	`def f(*args)`	`f(1, 2, 3)`
可变关键字参数	`def f(**kwargs)`	`f(x=1, y=2)`

📌 记忆要点

* 后面的参数是仅限关键字参数
仅限关键字参数必须用 参数名=值 的方式传递
不能通过位置传递仅限关键字参数

第21题¶

下列关于 list.remove() 和 list.pop() 的说法，正确的是（）。

选项	内容
A	`remove()` 按索引删除，`pop()` 按值删除
B	`remove()` 按值删除第一个匹配项，`pop()` 按索引删除并返回该元素 ✅
C	`remove()` 和 `pop()` 功能完全相同
D	`pop()` 不指定索引时删除第一个元素

答案

B

📖 解析：

A 错误：说反了，remove() 按值，pop() 按索引
B 正确：remove(value) 按值删除第一个匹配项，pop(index) 按索引删除并返回
C 错误：两者功能不同
D 错误：pop() 不指定索引时删除并返回最后一个元素

Python
lst = [1, 2, 3, 2, 4]

# remove(value)：按值删除第一个匹配项
lst.remove(2)
print(lst)   # [1, 3, 2, 4]  删除了第一个2

# pop(index)：按索引删除并返回
val = lst.pop(1)
print(val)   # 3  返回被删除的元素
print(lst)   # [1, 2, 4]

# pop()：不指定索引，删除最后一个
last = lst.pop()
print(last)  # 4
print(lst)   # [1, 2]

🔑 知识点：列表删除方法对比

方法	按什么删	返回值	元素不存在时
`remove(val)`	值	None	ValueError
`pop(idx)`	索引	被删除的元素	IndexError
`pop()`	最后一个	被删除的元素	IndexError（空列表）
`del lst[idx]`	索引	无	IndexError

📌 记忆要点

remove(值) → 按值删除第一个匹配项，无返回值
pop(索引) → 按索引删除，返回被删元素
pop() 不指定索引 → 删除并返回最后一个元素

第22题¶

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

Python
s = "hello world"
print(s.title())

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

答案

A

📖 解析：

str.title() 将字符串中每个单词的首字母大写，其余字母小写
"hello world" → "Hello World"

Python
"hello world".title()       # 'Hello World'
"HELLO WORLD".title()       # 'Hello World'
"hElLo WoRlD".title()       # 'Hello World'
"hello".capitalize()        # 'Hello'  （只大写第一个字符）

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

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

📌 记忆要点

title() 每个单词首字母大写
capitalize() 只大写字符串的第一个字符
upper() 全大写，lower() 全小写

第23题¶

以下关于Python中 is 运算符的说法，正确的是（）。

选项	内容
A	`is` 比较的是两个对象的值是否相等
B	`is` 比较的是两个对象的内存地址是否相同 ✅
C	`is` 和 `==` 功能完全相同
D	`[1,2] is [1,2]` 的结果为True

答案

B

📖 解析：

A 错误：is 比较的是身份（内存地址），不是值
B 正确：is 判断两个变量是否指向同一个对象（内存地址相同）
C 错误：== 比较值，is 比较身份
D 错误：两个独立的列表对象即使值相同，内存地址也不同

Python
a = [1, 2]
b = [1, 2]
a == b       # True  （值相同）
a is b       # False （不同对象，内存地址不同）

c = a
a is c       # True  （同一对象，内存地址相同）

# 小整数缓存（-5 到 256）
x = 100
y = 100
x is y       # True  （小整数被缓存，指向同一对象）

# 字符串驻留
s1 = "hello"
s2 = "hello"
s1 is s2     # True  （短字符串被驻留）

🔑 知识点：is 与 == 的区别

运算符	比较内容	示例
`==`	值是否相等	`[1,2] == [1,2]` → True
`is`	是否同一对象（内存地址）	`[1,2] is [1,2]` → False

is 等价于 id(a) == id(b)

📌 记忆要点

== 比较值，is 比较身份（内存地址）
[1,2] is [1,2] 为 False（两个独立对象）
小整数（-5~256）和小字符串有缓存机制，is 可能为 True

第24题¶

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

Python
nums = [3, 1, 4, 1, 5, 9, 2, 6]
result = filter(lambda x: x > 3, nums)
print(list(result))

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

答案

A

📖 解析：

filter(func, iterable) 过滤可迭代对象，保留使函数返回True的元素
lambda x: x > 3 是匿名函数，判断元素是否大于3
遍历列表：3(✗), 1(✗), 4(✓), 1(✗), 5(✓), 9(✓), 2(✗), 6(✓)
大于3的元素：4, 5, 9, 6
filter() 返回迭代器，需要用 list() 转换为列表

Python
# filter + lambda
nums = [3, 1, 4, 1, 5, 9, 2, 6]
list(filter(lambda x: x > 3, nums))  # [4, 5, 9, 6]

# 等价的列表推导式
[x for x in nums if x > 3]            # [4, 5, 9, 6]

# map + lambda：对每个元素应用函数
list(map(lambda x: x * 2, nums))      # [6, 2, 8, 2, 10, 18, 4, 12]

🔑 知识点：filter() 与 map()

函数	功能	示例
`filter(func, iter)`	保留使func为True的元素	`filter(lambda x:x>3, [1,4,2,5])` → `[4,5]`
`map(func, iter)`	对每个元素应用func	`map(lambda x:x*2, [1,2,3])` → `[2,4,6]`

注意：Python 3 中 filter() 和 map() 返回迭代器，需用 list() 转换。

📌 记忆要点

filter() 过滤，保留使函数返回True的元素
map() 映射，对每个元素应用函数
Python 3 中返回迭代器，需 list() 转换
lambda 匿名函数：lambda 参数: 表达式

✅ 二、判断题¶

第1题 ❌ 错¶

题目： Python中，list.sort() 方法会返回排序后的新列表，不会修改原列表。

答案：✘ 错

📖 解析：

list.sort() 是原地排序，直接修改原列表，返回值为 None
sorted() 才是返回新列表，不修改原列表

Python
lst = [3, 1, 2]
result = lst.sort()
print(lst)      # [1, 2, 3]  ← 原列表被修改
print(result)   # None       ← 返回None

lst2 = [3, 1, 2]
result2 = sorted(lst2)
print(lst2)     # [3, 1, 2]  ← 原列表不变
print(result2)  # [1, 2, 3]  ← 返回新列表

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

sort()：原地排序，返回None，只能用于列表
sorted()：返回新列表，不修改原列表，可用于任何可迭代对象

📌 记忆要点

sort() 修改原列表，返回None
sorted() 不修改原列表，返回新列表
题目说"不会修改原列表"是错误的

第2题 ✅ 对¶

题目： Python中，字符串可以通过 + 运算符进行拼接，但拼接后会创建一个新的字符串对象。

答案：✔ 对

📖 解析：

字符串是不可变（immutable）类型
+ 拼接字符串会创建新的字符串对象，原字符串不变
大量拼接时推荐使用 join() 方法，效率更高

Python
s1 = "Hello"
s2 = " World"
s3 = s1 + s2   # 创建新对象 "Hello World"
print(s1)       # "Hello"（原字符串不变）
print(id(s1) != id(s3))  # True，不同对象

📌 记忆要点

字符串不可变，+ 拼接创建新对象
大量拼接用 join() 更高效
字符串的任何"修改"操作都创建新对象

第3题 ✅ 对¶

题目： 在Python中，只包含一个元素的元组必须写成 (1,) 的形式，(1) 会被当作整数1。

答案：✔ 对

📖 解析：

(1) 中的括号是数学运算的括号，不是元组的括号
(1,) 中的逗号才是元组的标志
空元组 () 不需要逗号

Python
type((1))    # <class 'int'>     不是元组！
type((1,))   # <class 'tuple'>   元组
type(())     # <class 'tuple'>   空元组
type((1, 2)) # <class 'tuple'>   多元素元组

# 逗号是关键
t = 1,       # 也是元组！
type(t)      # <class 'tuple'>

📌 记忆要点

(1) 是整数，(1,) 才是元组
元组的标志是逗号，不是括号
空元组 () 不需要逗号

第4题 ✅ 对¶

题目： Python中，字典的键必须是唯一的，如果对已有的键赋值，旧值会被覆盖。

答案：✔ 对

📖 解析：

字典的键具有唯一性
对已有键赋值会覆盖旧值（更新）
对新键赋值会新增键值对

Python
d = {'a': 1, 'b': 2}
d['a'] = 10     # 覆盖旧值
print(d)         # {'a': 10, 'b': 2}

d['c'] = 3      # 新增键值对
print(d)         # {'a': 10, 'b': 2, 'c': 3}

📌 记忆要点

字典键唯一，重复赋值会覆盖
d[key] = value：有则改，无则增

第5题 ❌ 错¶

题目： break 语句可以用于 if 语句中，用来跳出 if 代码块。

答案：✘ 错

📖 解析：

break 只能用于循环语句（for 和 while），不能用于 if
break 的作用是跳出最近的循环，不是跳出 if
if 中可以包含 break，但 break 跳出的是外层循环，不是 if

Python
# ✅ break 在循环内的 if 中使用
for i in range(10):
    if i == 5:
        break    # 跳出 for 循环，不是跳出 if

# ❌ break 不能单独在 if 中使用
if True:
    break        # SyntaxError: 'break' outside loop

📌 记忆要点

break 只能用于循环（for/while）
break 跳出最近的循环，不是跳出 if
break 不能单独在 if 中使用（unless if在循环内）

第6题 ✅ 对¶

题目： Python中，字符串的比较是按照字典序（lexicographic order）进行的。

答案：✔ 对

📖 解析：

字符串比较按照字典序（Unicode码位顺序）逐字符比较
先比较第一个字符，如果相同再比较第二个，以此类推

Python
"abc" < "abd"     # True  （'c' < 'd'）
"abc" < "abcd"    # True  （短的是长的前缀）
"A" < "a"         # True  （'A'=65 < 'a'=97）
"10" < "2"        # True  （'1'=49 < '2'=50，按字符比较）
"2" > "10"        # True  （字符串比较，非数值比较）

📌 记忆要点

字符串按字典序逐字符比较（Unicode码位）
大写字母 < 小写字母（'A'=65 < 'a'=97）
字符串比较不是数值比较，"10" < "2"

第7题 ❌ 错¶

题目： None 和 0 在Python中是等价的，None == 0 的结果为 True。

答案：✘ 错

📖 解析：

None 是Python中的空值对象，表示"没有值"
0 是整数零，是一个具体的数值
None == 0 的结果为 False
None 只与 None 相等：None == None → True

Python
None == 0      # False
None == False  # False
None == ""     # False
None == None   # True

# 布尔上下文
bool(None)  # False
bool(0)     # False
# 虽然都是 False，但不等价

📌 记忆要点

None 不等于 0，None == 0 为 False
None 是空值，0 是数值，类型不同
None 只等于 None

第8题 ✅ 对¶

题目： Python中，一个函数可以返回多个值，实际上返回的是一个元组。

答案：✔ 对

📖 解析：

函数用 return a, b, c 返回多个值时，实际返回的是元组 (a, b, c)
调用方可以用多个变量接收（元组解包）

Python
def get_info():
    name = "Tom"
    age = 18
    return name, age    # 实际返回 ('Tom', 18)

result = get_info()
print(type(result))     # <class 'tuple'>

# 元组解包
name, age = get_info()
print(name)  # Tom
print(age)   # 18

📌 记忆要点

return a, b 实际返回元组 (a, b)
接收时可用元组解包：x, y = func()
函数本质只能返回一个对象，多值返回是元组的语法糖

第9题 ✅ 对¶

题目： def 语句定义函数时，函数体不会被执行，只有调用函数时才会执行。

答案：✔ 对

📖 解析：

def 只定义函数，不执行函数体
只有调用函数时，函数体才会被执行
函数定义时的默认参数值会在定义时计算一次

Python
def greet():
    print("Hello")   # 定义时不执行

greet()  # 调用时才执行，输出 Hello

# 默认参数在定义时计算
def func(lst=[]):
    lst.append(1)
    return lst

print(func())  # [1]
print(func())  # [1, 1]  ← 注意：默认参数共享同一对象

📌 记忆要点

def 定义函数不执行函数体
调用函数时才执行函数体
默认参数在函数定义时计算一次（可变默认参数陷阱）

第10题 ✅ 对¶

题目： Python中，float 类型的运算可能存在精度误差，因此不建议直接用 == 比较两个浮点数。

答案：✔ 对

📖 解析：

浮点数在计算机中采用二进制存储，无法精确表示某些十进制小数
0.1 + 0.2 == 0.3 的结果为 False
推荐用 math.isclose() 或差值比较

Python
0.1 + 0.2 == 0.3            # False
0.1 + 0.2                    # 0.30000000000000004

# 正确做法
import math
math.isclose(0.1 + 0.2, 0.3)  # True

# 或差值比较
abs(0.1 + 0.2 - 0.3) < 1e-9   # True

📌 记忆要点

浮点数存在精度误差
不用 == 比较浮点数
用 math.isclose() 或差值阈值比较

第11题 ❌ 错¶

题目： 字符串的 split() 方法如果不指定分隔符，默认按逗号分割。

答案：✘ 错

📖 解析：

split() 不指定参数时，默认按空白字符分割（空格、制表符、换行等）
不是按逗号分割
连续空白字符视为一个分隔符

Python
"hello   world\tpython".split()     # ['hello', 'world', 'python']
"hello,world,python".split()        # ['hello,world,python'] 不分割逗号
"hello,world,python".split(",")     # ['hello', 'world', 'python'] 指定逗号
"a  b   c".split()                   # ['a', 'b', 'c'] 连续空白合为一个
"a  b   c".split(" ")               # ['a', '', 'b', '', '', 'c'] 按单个空格

📌 记忆要点

split() 无参数时按空白字符分割，不是逗号
连续空白字符视为一个分隔符
split(",") 指定逗号分割

第12题 ✅ 对¶

题目： Python中，and 和 or 运算符具有短路求值特性。

答案：✔ 对

📖 解析：

短路求值（short-circuit evaluation）：从左到右计算，能确定结果时立即停止
and：如果第一个为False，直接返回第一个值，不再计算第二个
or：如果第一个为True，直接返回第一个值，不再计算第二个

Python
# and 短路
0 and print("不会执行")    # 0（第一个为假，直接返回0）
1 and print("会执行")       # 执行print，返回None

# or 短路
1 or print("不会执行")      # 1（第一个为真，直接返回1）
0 or print("会执行")        # 执行print，返回None

# 实际返回值（不是True/False）
3 and 5    # 5（两个都为真，返回最后一个）
0 and 5    # 0（第一个为假，返回第一个）
3 or 5     # 3（第一个为真，返回第一个）
0 or 5     # 5（第一个为假，返回第二个）

📌 记忆要点

and 遇到第一个False就停止，返回该值
or 遇到第一个True就停止，返回该值
返回的是实际值，不一定是True/False

第13题 ✅ 对¶

题目： enumerate() 函数可以同时获取列表元素的索引和值。

答案：✔ 对

📖 解析：

enumerate() 将可迭代对象组合为索引-值对
常用于 for 循环中同时获取索引和元素

Python
fruits = ['apple', 'banana', 'cherry']

# 使用 enumerate
for index, fruit in enumerate(fruits):
    print(index, fruit)
# 0 apple
# 1 banana
# 2 cherry

# 指定起始索引
for index, fruit in enumerate(fruits, start=1):
    print(index, fruit)
# 1 apple
# 2 banana
# 3 cherry

# 不使用 enumerate 的写法（不推荐）
for i in range(len(fruits)):
    print(i, fruits[i])

📌 记忆要点

enumerate(iterable, start=0) 返回 (索引, 值) 对
常用于 for 循环同时获取索引和值
start 参数可指定起始索引

第14题 ✅ 对¶

题目： 在Python中，del 语句既可以删除变量，也可以删除列表中的元素。

答案：✔ 对

📖 解析：

del 可以删除变量，使其不再存在
del 可以删除列表中的元素（按索引）
del 还可以删除字典中的键值对

Python
# 删除变量
x = 10
del x
# print(x)  # NameError: name 'x' is not defined

# 删除列表元素
lst = [1, 2, 3, 4, 5]
del lst[1]     # 删除索引1的元素
print(lst)      # [1, 3, 4, 5]
del lst[1:3]    # 切片删除
print(lst)      # [1, 5]

# 删除字典键值对
d = {'a': 1, 'b': 2, 'c': 3}
del d['b']
print(d)        # {'a': 1, 'c': 3}

📌 记忆要点

del 变量 → 删除变量
del 列表[索引] → 删除列表元素
del 字典[键] → 删除字典键值对

✏️ 三、程序填空题¶

第1题：凯撒密码加密¶

题目： 实现凯撒密码加密，将字符串中每个字母向后移动3位（如A→D，x→a），非字母字符不变。

✅ 填空答案：

begin1： ord('A') if ch.isupper() else ord('a')
begin2： (ord(ch) - base + shift) % 26 + base
begin3： caesar_encrypt(text)

完整正确代码

Python
def caesar_encrypt(text, shift=3):
    result = ""
    for ch in text:
        if ch.isalpha():
            base = ord('A') if ch.isupper() else ord('a')  # 【填空1】确定基准ASCII码
            new_ch = chr((ord(ch) - base + shift) % 26 + base)  # 【填空2】计算偏移后的字符
            result += new_ch
        else:
            result += ch
    return result

text = input("请输入明文:")
print("密文:", caesar_encrypt(text))  # 【填空3】调用函数

📖 解析：

填空1：需要根据字母是大写还是小写确定基准ASCII码。大写字母基准为 ord('A')（65），小写字母基准为 ord('a')（97）
填空2：凯撒密码的核心公式。先求字母在字母表中的位置（0~25），加上偏移量，对26取模保证循环，再加上基准码转回字符
填空3：调用函数，传入用户输入的明文

运行示例：

Text Only
1 2	`请输入明文:Hello World! 密文: Khoor Zruog!`

🔑 知识点：凯撒密码原理

步骤	说明	示例（A→D，shift=3）
1. 确定基准	大写用A(65)，小写用a(97)	`ord('A')` = 65
2. 计算偏移	字母位置 + 偏移量	0 + 3 = 3
3. 取模循环	对26取模	(0+3)%26 = 3
4. 转回字符	偏移 + 基准码→chr	`chr(3+65)` = 'D'

📌 记忆要点

大写小写字母分别处理，基准码不同
% 26 保证字母循环（z→c）
ord() 字符转数字，chr() 数字转字符

第2题：二维列表求每行最大值¶

题目： 给定一个二维列表（矩阵），找出每行的最大值并存入新列表。

✅ 填空答案：

begin1： m = max(row)
begin2： row_max

完整正确代码

Python
matrix = [
    [3, 5, 1, 7],
    [9, 2, 8, 4],
    [6, 1, 3, 5]
]
row_max = []
for row in matrix:
    m = max(row)         # 【填空1】求每行最大值
    row_max.append(m)
print("每行最大值:", row_max)  # 【填空2】输出结果列表

运行结果： 每行最大值: [7, 9, 6]

📖 解析：

填空1：使用 max() 函数求每行的最大值，row 是每行的列表
填空2：输出最终的结果列表 row_max

🔑 知识点：二维列表遍历

Python
# 遍历方式
for row in matrix:       # 按行遍历
    for elem in row:     # 遍历行内元素

# 按索引遍历
for i in range(len(matrix)):
    for j in range(len(matrix[i])):
        print(matrix[i][j])

# 列表推导式求每行最大值
row_max = [max(row) for row in matrix]

📌 记忆要点

二维列表 = 列表的列表
外层循环遍历行，内层循环遍历列
max() 可直接对列表求最大值

第3题：递归求各位数字之和¶

题目： 使用递归函数计算一个正整数各位数字之和。例如：123 → 1+2+3 = 6。

✅ 填空答案：

begin1： n < 10（或 n // 10 == 0）
begin2： n % 10 + digit_sum(n // 10)

完整正确代码

Python
def digit_sum(n):
    if n < 10:                         # 【填空1】递归终止条件：个位数
        return n
    else:
        return n % 10 + digit_sum(n // 10)  # 【填空2】当前末位 + 剩余各位之和

num = int(input("请输入一个正整数:"))
print("各位数字之和:", digit_sum(num))

运行示例：

Text Only
1 2	`请输入一个正整数:123 各位数字之和: 6`

📖 解析：

递归执行过程（以123为例）：

Text Only
1 2 3 4 5 6	`digit_sum(123) = 3 + digit_sum(12) = 2 + digit_sum(1) = 1 ← 终止条件 = 2 + 1 = 3 = 3 + 3 = 6`

填空1：递归终止条件，当n为个位数（n < 10）时，直接返回n
填空2：递归关系，n % 10 取最后一位，n // 10 去掉最后一位，递归求剩余各位之和

🔑 知识点：递归三要素

要素	说明	本题
终止条件	何时停止递归	`n < 10` 时返回n
递归关系	如何分解问题	`n % 10 + digit_sum(n // 10)`
返回值	返回什么	各位数字之和

📌 记忆要点

递归必须有终止条件（基线条件）
n % 10 取个位数，n // 10 去掉个位数
递归 = 当前处理 + 子问题递归

🔧 四、程序改错题¶

第1题：最大公约数¶

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

原始代码（含错误）：

Python
def gcd(a, b):
    while a / b != 0:
        a, b = b, a % b
    return a

num1 = int(input("请输入第一个正整数:"))
num2 = int(input("请输入第二个正整数:"))
print("最大公约数为:", gcd(num1, num2)

✅ 三处错误及修正：

错误位置	原代码	修正后	错误原因
begin1	`while a / b != 0:`	`while b != 0:`	应判断b是否为0，且用整除逻辑
begin2	`return a`	`return a`	返回值正确，但循环条件修复后逻辑才通
begin2	`print("最大公约数为:", gcd(num1, num2)`	`print("最大公约数为:", gcd(num1, num2))`	缺少右括号

完整正确代码

Python
def gcd(a, b):
    while b != 0:                      # ✅ 修正1：判断b是否为0
        a, b = b, a % b
    return a

num1 = int(input("请输入第一个正整数:"))
num2 = int(input("请输入第二个正整数:"))
print("最大公约数为:", gcd(num1, num2))  # ✅ 修正2：补全右括号

运行示例：

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

📖 解析：

错误1：a / b 是浮点除法，可能出现浮点精度问题。辗转相除法的正确条件是判断 b != 0
错误2：print 语句缺少右括号

🔑 知识点：辗转相除法（欧几里得算法）

Python
# 辗转相除法原理：gcd(a, b) = gcd(b, a % b)
# 当 b = 0 时，a 就是最大公约数

# 执行过程：gcd(48, 18)
# a=48, b=18 → a=18, b=48%18=12
# a=18, b=12 → a=12, b=18%12=6
# a=12, b=6  → a=6,  b=12%6=0
# b=0, 返回 a=6

📌 记忆要点

辗转相除法：gcd(a, b) = gcd(b, a % b)
终止条件：b == 0 时，a 即为最大公约数
a, b = b, a % b 是 Python 多重赋值的经典应用

第2题：统计单词频率¶

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

原始代码（含错误）：

Python
text = "the cat sat on the mat the cat ate the rat"
words = text.split()
word_count = []
for word in words:
    if word in word_count:
        word_count[word] += 1
    else:
        word_count[word] = 1
for w in word_count:
    print(w, word_count[w])

✅ 三处错误及修正：

错误位置	原代码	修正后	错误原因
begin1	`word_count = []`	`word_count = {}`	统计频率应使用字典而非列表
begin2	`for w in word_count:`	`for w in sorted(word_count, key=word_count.get, reverse=True):`	需按频率降序输出

完整正确代码

Python
text = "the cat sat on the mat the cat ate the rat"
words = text.split()
word_count = {}                      # ✅ 修正1：使用字典
for word in words:
    if word in word_count:
        word_count[word] += 1
    else:
        word_count[word] = 1
for w in sorted(word_count, key=word_count.get, reverse=True):  # ✅ 修正2：按频率降序
    print(w, word_count[w])

运行结果：

Text Only
1 2 3 4 5 6 7	`the 3 cat 2 sat 1 on 1 mat 1 ate 1 rat 1`

📖 解析：

错误1：用列表存储单词频率无法用字符串作为索引，应使用字典 {}
错误2：原代码只遍历字典键，没有按频率排序。需要用 sorted() 配合 key=word_count.get 按值排序

🔑 知识点：字典按值排序

Python
# 按值降序排序
sorted(d, key=d.get, reverse=True)

# 按值升序排序
sorted(d, key=d.get)

# 按键排序
sorted(d)

# 返回键值对列表
sorted(d.items(), key=lambda x: x[1], reverse=True)

📌 记忆要点

统计频率用字典 {}，不是列表 []
sorted(dict, key=dict.get) 按值排序
reverse=True 降序排列

第3题：冒泡排序优化¶

题目： 对列表进行升序排序，并输出排序后的结果。

原始代码（含错误）：

Python
lst = [64, 34, 25, 12, 22, 11, 90]
n = len(lst)
for i in range(n):
    for j in range(n):
        if lst[j] > lst[j + 1]:
            lst[j], lst[j + 1] = lst[j + 1], lst[j]
print("排序后:" + lst)

✅ 三处错误及修正：

错误位置	原代码	修正后	错误原因
begin1	`for j in range(n):`	`for j in range(0, n - i - 1):`	内层循环范围错误，应逐步缩小
begin1	`if lst[j] > lst[j + 1]:`	索引正确	（这部分逻辑正确，但范围需修正才能避免越界）
begin2	`print("排序后:" + lst)`	`print("排序后:", lst)`	字符串与列表不能直接用+拼接

完整正确代码

Python
lst = [64, 34, 25, 12, 22, 11, 90]
n = len(lst)
for i in range(n):
    for j in range(0, n - i - 1):      # ✅ 修正1：内层循环范围
        if lst[j] > lst[j + 1]:
            lst[j], lst[j + 1] = lst[j + 1], lst[j]
print("排序后:", lst)                     # ✅ 修正2：用逗号分隔输出

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

📖 解析：

错误1：内层循环应为 range(0, n - i - 1)，否则 j + 1 会越界，且未利用冒泡排序的优化（每轮已排好的末尾元素无需再比较）
错误2：字符串和列表不能直接用 + 拼接，应使用逗号分隔或 str(lst) 转换

🔑 知识点：冒泡排序

Python
# 冒泡排序核心思想：
# 相邻元素两两比较，大的往后交换
# 每轮确定一个最大元素到末尾

# 外层循环：控制轮数 n-1 轮
# 内层循环：每轮比较范围逐渐缩小
#   第1轮: range(0, n-1)
#   第2轮: range(0, n-2)
#   第i轮: range(0, n-i-1)

📌 记忆要点

冒泡排序内层循环：range(0, n - i - 1)
每轮将最大值"冒泡"到末尾
字符串与列表不能直接 +，用 , 或 str() 转换

第4题：猜数字函数¶

题目： 编写函数判断猜的数字与目标数字的大小关系。

原始代码（含错误）：

Python
def guess(target, guess_num)
    if guess_num > target:
        return "太大了"
    elseif guess_num < target:
        return "太小了"
    else:
        return "猜对了"

import random
target = random.randint(1, 100)
result = guess target, 50
print(result)

✅ 三处错误及修正：

错误位置	原代码	修正后	错误原因
begin1	`def guess(target, guess_num)`	`def guess(target, guess_num):`	函数定义缺少冒号
begin2	`elseif guess_num < target:`	`elif guess_num < target:`	Python用`elif`，不是`elseif`
begin3	`result = guess target, 50`	`result = guess(target, 50)`	函数调用必须用括号

完整正确代码

Python
def guess(target, guess_num):          # ✅ 修正1：添加冒号
    if guess_num > target:
        return "太大了"
    elif guess_num < target:            # ✅ 修正2：elseif → elif
        return "太小了"
    else:
        return "猜对了"

import random
target = random.randint(1, 100)
result = guess(target, 50)              # ✅ 修正3：函数调用加括号
print(result)

📖 解析：

错误1：函数定义末尾缺少冒号 :，这是Python语法的常见错误
错误2：Python中用 elif 而不是 elseif，这是从其他语言转Python的常见误区
错误3：函数调用必须用括号 ()，不能省略

🔑 知识点：Python语法常见易错点

易错点	错误写法	正确写法
函数定义冒号	`def f()`	`def f():`
else if	`elseif`	`elif`
函数调用	`f a, b`	`f(a, b)`
条件判断	`if x = 1`	`if x == 1`

📌 记忆要点

函数/类定义、if/elif/else、for/while 后都要加冒号
Python 用 elif，不是 else if 或 elseif
函数调用必须使用括号

💻 五、程序设计题¶

第1题：密码强度检测¶

题目： 编写程序检测密码强度。

完整正确代码

Python
def check_password(password):
    checks = {
        "长度不少于8位": len(password) >= 8,
        "包含大写字母": any(ch.isupper() for ch in password),
        "包含小写字母": any(ch.islower() for ch in password),
        "包含数字": any(ch.isdigit() for ch in password),
        "包含特殊字符": any(not ch.isalnum() for ch in password)
    }

    # 输出每项检测结果
    for desc, result in checks.items():
        print(f"{desc}: {'满足' if result else '不满足'}")

    # 计算满足的条件数量
    score = sum(checks.values())

    # 判断强度等级
    if score == 5:
        level = "强"
    elif score == 4:
        level = "较强"
    elif score == 3:
        level = "中等"
    else:
        level = "弱"

    print(f"密码强度: {level}")

password = input("请输入密码:")
check_password(password)

运行示例：

Text Only
1 2 3 4 5 6 7	`请输入密码: Abc123! 长度不少于8位: 不满足包含大写字母: 满足包含小写字母: 满足包含数字: 满足包含特殊字符: 满足密码强度: 较强`

📖 解析：

使用字典存储各项检测结果，便于统一管理和统计
any() 函数判断是否存在满足条件的字符
ch.isupper() 判断是否大写，ch.islower() 判断是否小写
ch.isdigit() 判断是否数字，not ch.isalnum() 判断是否特殊字符
sum(checks.values()) 统计满足条件的数量

🔑 知识点：字符串检测方法

方法	功能	示例
`isupper()`	是否全大写	`'A'.isupper()` → True
`islower()`	是否全小写	`'a'.islower()` → True
`isdigit()`	是否全数字	`'1'.isdigit()` → True
`isalpha()`	是否全字母	`'a'.isalpha()` → True
`isalnum()`	是否字母或数字	`'a1'.isalnum()` → True
`any()`	是否有任一为True	`any([True, False])` → True

📌 记忆要点

any() 判断是否有元素为True
not ch.isalnum() 判断特殊字符
用字典统一管理多项检测结果

第2题：简单计算器¶

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

完整正确代码

Python
def calculate(num1, operator, num2):
    if operator == '+':
        return num1 + num2
    elif operator == '-':
        return num1 - num2
    elif operator == '*':
        return num1 * num2
    elif operator == '/':
        if num2 == 0:
            return "除数不能为0"
        return num1 / num2
    else:
        return "无效运算符"

while True:
    num1_input = input("请输入第一个数字(输入q退出): ")
    if num1_input == 'q':
        print("程序已退出")
        break

    operator = input("请输入运算符(+,-,*,/): ")
    num2_input = input("请输入第二个数字: ")

    num1 = float(num1_input)
    num2 = float(num2_input)
    result = calculate(num1, operator, num2)

    print(f"{num1} {operator} {num2} = {result}")

运行示例：

Text Only

请输入第一个数字(输入q退出): 10
请输入运算符(+,-,*,/): +
请输入第二个数字: 5
10.0 + 5.0 = 15.0
请输入第一个数字(输入q退出): 8
请输入运算符(+,-,*,/): /
请输入第二个数字: 0
8.0 / 0.0 = 除数不能为0
请输入第一个数字(输入q退出): q
程序已退出

📖 解析：

使用 while True 循环实现重复输入
输入 q 时用 break 退出循环
除法运算需要检查除数是否为0
使用 float() 转换输入，支持小数运算
将计算逻辑封装为函数，提高代码可读性

🔑 知识点：循环与异常处理

Python
# 更健壮的版本（加入异常处理）
while True:
    try:
        num1 = float(input("请输入第一个数字: "))
        break
    except ValueError:
        print("输入无效，请输入数字!")

# 计算器核心逻辑用字典映射也可以
import operator
ops = {
    '+': operator.add,
    '-': operator.sub,
    '*': operator.mul,
    '/': operator.truediv
}

📌 记忆要点

while True + break 实现循环输入
除法必须检查除数是否为0
float() 转换输入支持小数
将计算逻辑封装为函数，主循环处理输入输出