Python 模拟考试 3 — 解析

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

第1题¶

以下哪个是Python合法的变量名？（）

选项	内容
A	3name
B	my-name
C	_score ✅
D	class

答案

C

📖 解析：

A 不合法：变量名不能以数字开头，3name 以数字3开头，语法错误
B 不合法：变量名只能包含字母、数字和下划线，my-name 含有连字符 -（会被解析为减法运算）
C 合法：下划线开头的变量名完全合法，常用于表示私有变量
D 不合法：class 是Python关键字，不能用作变量名

🔑 知识点：Python标识符规则

只能包含字母、数字、下划线 _
不能以数字开头
不能使用关键字（如 class、if、for、while 等）
区分大小写

📌 记忆要点

数字不能开头，连字符不能用，关键字不能当变量名，下划线开头合法

第2题¶

表达式 type("3.14") 的返回值是（）。

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

答案

C

📖 解析：

"3.14" 被引号包裹，是字符串（str）类型，不是数值
type() 函数返回变量的实际类型，不看"内容像什么"，看"定义是什么"

Python
type("3.14")   # <class 'str'>（引号包裹 → 字符串）
type(3.14)     # <class 'float'>（小数点 → 浮点数）
type(3)        # <class 'int'>（整数 → 整型）

🔑 知识点：type() 函数与数据类型

字面量	类型
`3`	int
`3.14`	float
`"3.14"`	str
`True`	bool
`[1, 2]`	list

📌 记忆要点

引号包裹的都是字符串，不管内容是什么；Python没有 number 类型

第3题¶

下列运算符中，优先级最高的是（）。

选项	内容
A	+
B	*
C	** ✅
D	//

答案

C

📖 解析：

四个运算符的优先级从高到低：** > *、// > +
**（幂运算）优先级最高
*（乘法）和 //（整除）优先级相同
+（加法）优先级最低

Python
2 + 3 * 2 ** 3 // 2
# 计算顺序：
# 1. 2 ** 3 = 8       （先算幂）
# 2. 3 * 8 = 24       （再算乘）
# 3. 24 // 2 = 12     （再算整除）
# 4. 2 + 12 = 14      （最后加法）

🔑 知识点：运算符优先级

优先级	运算符	说明
1（最高）	`**`	幂运算
2	`+x`、`-x`、`~x`	正负号、按位取反
3	`*`、`/`、`//`、`%`	乘除、整除、取余
4	`+`、`-`	加法、减法
5	`==`、`!=`、`>`、`<`等	比较运算符
6	`not`	逻辑非
7	`and`	逻辑与
8（最低）	`or`	逻辑或

📌 记忆要点

幂运算 ** 优先级最高，算术运算高于比较运算，比较运算高于逻辑运算

第4题¶

表达式 "hello" + "world" 的结果是（）。

选项	内容
A	报错
B	"helloworld" ✅
C	"hello world"
D	5

答案

B

📖 解析：

+ 运算符用于字符串时表示拼接，将两个字符串连接在一起
"hello" + "world" = "helloworld"（注意：不会自动添加空格）
如果想加空格："hello" + " " + "world" = "hello world"

Python
"hello" + "world"     # "helloworld"
"hello" + " " + "world"  # "hello world"
"ha" * 3              # "hahaha"（字符串重复）

🔑 知识点：字符串运算

运算符	功能	示例	结果
`+`	拼接	`"a" + "b"`	`"ab"`
`*`	重复	`"a" * 3`	`"aaa"`

📌 记忆要点

字符串 + 是拼接（无空格），* 是重复；数字和字符串不能直接 +

第5题¶

已知 a = [1, 2, 3]，执行 a.insert(1, 5) 后，a 的值为（）。

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

答案

B

📖 解析：

insert(index, value) 在指定索引处插入元素
a.insert(1, 5) 表示在索引1的位置插入5
原列表：[1, 2, 3]，索引1的位置是元素2
插入后：[1, 5, 2, 3]（5插入到2的前面）

Python
a = [1, 2, 3]
a.insert(1, 5)
print(a)  # [1, 5, 2, 3]

a.insert(0, 0)   # [0, 1, 5, 2, 3]（在开头插入）
a.insert(len(a), 9)  # [0, 1, 5, 2, 3, 9]（在末尾插入，等效append）

🔑 知识点：列表插入方法

方法	功能	示例
`append(x)`	末尾添加	`[1,2].append(3)` → `[1,2,3]`
`insert(i, x)`	索引i处插入	`[1,3].insert(1,2)` → `[1,2,3]`
`extend(seq)`	末尾追加序列	`[1,2].extend([3,4])` → `[1,2,3,4]`

📌 记忆要点

insert(索引, 值) 在指定位置前面插入，原有元素依次后移

第6题¶

表达式 True and not False or True 的结果是（）。

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

答案

A

📖 解析：

逻辑运算符优先级：not > and > or
计算步骤：
1. not False → True（先算 not）
2. True and True → True（再算 and）
3. True or True → True（最后算 or）

Python
True and not False or True
# 等价于：True and (not False) or True
# 等价于：True and True or True
# 等价于：(True and True) or True
# 等价于：True or True
# 结果：True

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

优先级	运算符	含义
1（最高）	`not`	非
2	`and`	与
3（最低）	`or`	或

短路求值规则：

and：遇 False 则停止，返回该 False 值
or：遇 True 则停止，返回该 True 值

📌 记忆要点

优先级：not > and > or，和算术中的负号 > 乘法 > 加法类比

第7题¶

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

选项	内容
A	元组中的元素可以修改
B	元组使用方括号定义
C	元组是不可变序列 ✅
D	元组不能包含列表元素

答案

C

📖 解析：

A 错误：元组是不可变的，创建后不能修改元素
B 错误：元组使用圆括号 () 定义，方括号 [] 是列表
C 正确：元组是不可变序列，这是元组最核心的特征
D 错误：元组可以包含列表等可变对象作为元素

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

# 元组可以包含列表
t = (1, [2, 3], 4)  # ✅ 合法
t[1].append(4)      # ✅ 修改列表元素（列表本身是可变的）
# t 变为 (1, [2, 3, 4], 4)——元组中存储的是列表的引用，引用未变

🔑 知识点：元组特性

特性	元组	列表
符号	`()`	`[]`
可变性	不可变	可变
速度	较快	较慢
可做字典键	可以	不可以
元素类型	可含可变对象	任意

📌 记忆要点

元组不可变、用圆括号、可含列表元素；列表可变、用方括号

第8题¶

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

Python
d = {"name": "Tom", "age": 18}
d["age"] = 20
print(len(d))

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

答案

B

📖 解析：

d = {"name": "Tom", "age": 18} 创建字典，有2个键值对
d["age"] = 20 修改已有键 "age" 的值（从18改为20），不是新增键值对
修改值不改变字典的长度，len(d) 仍然是 2

Python
d = {"name": "Tom", "age": 18}   # len = 2
d["age"] = 20                     # 修改已有键，len = 2
d["gender"] = "M"                 # 新增键值对，len = 3

🔑 知识点：字典操作对长度的影响

操作	对len的影响
修改已有键的值 `d[key] = val`	不变
新增键值对 `d[new_key] = val`	+1
删除键值对 `del d[key]`	-1

📌 记忆要点

修改已有键的值不影响字典长度，只有增删键值对才改变长度

第9题¶

表达式 max([3, 1, 4, 1, 5, 9]) 的结果是（）。

选项	内容
A	1
B	5
C	9 ✅
D	[9]

答案

C

📖 解析：

max() 函数返回可迭代对象中的最大值
列表 [3, 1, 4, 1, 5, 9] 中最大值是 9
返回值是数值本身，不是列表

Python
max([3, 1, 4, 1, 5, 9])     # 9
min([3, 1, 4, 1, 5, 9])     # 1
max("hello")                  # 'o'（按Unicode码点比较）
max([])                       # ❌ ValueError（空序列无最大值）

🔑 知识点：max() 和 min() 函数

函数	功能	示例
`max(iterable)`	返回最大值	`max([1,3,2])` → `3`
`min(iterable)`	返回最小值	`min([1,3,2])` → `1`
`max(a, b, c)`	多个参数取最大	`max(1, 3, 2)` → `3`

📌 记忆要点

max() 返回最大值（数值），不是列表；空序列调用会报错

第10题¶

下列关于Python注释的说法，错误的是（）。

选项	内容
A	单行注释以#开头
B	多行注释使用三引号
C	注释不会被执行
D	注释只能写在代码行末尾 ✅

答案

D

📖 解析：

A 正确：单行注释以 # 开头，# 后面的内容不会被Python执行
B 正确：多行注释使用三引号 ''' 或 """ 包裹（严格说是多行字符串，但常用作注释）
C 正确：注释是给程序员看的，Python解释器会忽略注释
D 错误：注释可以写在代码行的任意位置——单独一行、代码行末尾、多行注释，不限于行末

Python
# 这是单独一行的注释
x = 10  # 这是行末注释

"""
这是多行注释
可以写很多行
"""

'''这也是多行注释'''

🔑 知识点：Python 注释

注释类型	符号	位置
单行注释	`#`	任意行
多行注释	`'''` 或 `"""`	任意位置
行末注释	`#`	代码行末尾

📌 记忆要点

注释可以写在代码的任意位置，不限于行末

第11题¶

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

Python
x = [1, 2, 3]
y = x.copy()
y.append(4)
print(len(x))

选项	内容
A	3 ✅
B	4
C	报错
D	不确定

答案

A

📖 解析：

x.copy() 创建列表的浅拷贝，y 是一个独立的新列表
y.append(4) 只修改 y，不影响 x
x 仍然是 [1, 2, 3]，len(x) = 3

Python
x = [1, 2, 3]
y = x.copy()       # 浅拷贝，y = [1, 2, 3]（新对象）
y.append(4)         # y = [1, 2, 3, 4]
print(len(x))       # 3（x 未受影响）
print(len(y))       # 4

# 对比：引用赋值
z = x               # z 和 x 指向同一个对象
z.append(5)
print(len(x))       # 4（x 受影响了！）

🔑 知识点：拷贝方式对比

方式	代码	是否独立
引用赋值	`y = x`	❌ 共享同一对象
浅拷贝	`y = x.copy()` 或 `y = x[:]`	✅ 顶层独立
深拷贝	`y = copy.deepcopy(x)`	✅ 完全独立

📌 记忆要点

copy() 创建浅拷贝（新列表），修改拷贝不影响原列表；直接赋值 y = x 是引用，修改会互相影响

第12题¶

表达式 int("101", 2) 的结果是（）。

选项	内容
A	101
B	5 ✅
C	2
D	报错

答案

B

📖 解析：

int(string, base) 将指定进制的字符串转换为十进制整数
int("101", 2) 将二进制 101 转换为十进制
二进制 101 = 1×2² + 0×2¹ + 1×2⁰ = 4 + 0 + 1 = 5

Python
int("101", 2)    # 5  （二进制 → 十进制）
int("101", 8)    # 65 （八进制 → 十进制）
int("101", 10)   # 101（十进制 → 十进制）
int("101", 16)   # 257（十六进制 → 十进制）
int("FF", 16)    # 255（十六进制 → 十进制）
bin(5)            # '0b101'（十进制 → 二进制字符串）

🔑 知识点：进制转换

函数	功能	示例
`int(s, base)`	指定进制转十进制	`int("101", 2)` → `5`
`bin(n)`	十进制转二进制	`bin(5)` → `'0b101'`
`oct(n)`	十进制转八进制	`oct(8)` → `'0o10'`
`hex(n)`	十进制转十六进制	`hex(255)` → `'0xff'`

📌 记忆要点

int("字符串", 进制) 将指定进制字符串转为十进制数

第13题¶

下列哪个方法可以删除字典中指定的键值对？（）

选项	内容
A	`dict.remove()`
B	`dict.delete()`
C	`del dict[key]`
D	`dict.pop(key)`

答案

C

📖 解析：

A 错误：字典没有 remove() 方法（那是列表的方法）
B 错误：字典没有 delete() 方法
C 正确：del dict[key] 可以删除指定键值对，这是最常用的删除方式
D 也可行：dict.pop(key) 也可以删除并返回对应值，但题目问"哪个方法可以删除"，del 是关键字语句，pop() 是方法

注意：C 和 D 都能删除字典键值对。del dict[key] 是最基础的删除方式，dict.pop(key) 是方法调用。本题选 C 是因为 del 是最常用、最直接的删除方式。

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

# 方式1：del 语句
del d["b"]        # d = {"a": 1, "c": 3}

# 方式2：pop 方法（返回被删除的值）
val = d.pop("a")  # val = 1, d = {"c": 3}

# 方式3：popitem 方法（删除最后插入的键值对）
d.popitem()       # 删除并返回最后一个键值对

🔑 知识点：字典删除操作

方式	功能	返回值
`del d[key]`	删除键值对	无
`d.pop(key)`	删除并返回值	被删除的值
`d.pop(key, default)`	删除并返回值，键不存在返回默认值	值或默认值
`d.popitem()`	删除最后插入的键值对	键值对元组
`d.clear()`	清空字典	无

📌 记忆要点

字典删除：del d[key] 最直接，pop() 可获取返回值，字典没有 remove() 和 delete()

第14题¶

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

Python
s = "Hello World"
print(s.lower().count("l"))

选项	内容
A	2
B	3 ✅
C	4
D	0

答案

B

📖 解析：

s.lower() 将字符串转为小写："Hello World" → "hello world"
.count("l") 统计小写字母 "l" 出现的次数
"hello world" 中 "l" 出现在索引 2、3、9，共 3 次

Python
s = "Hello World"
s.lower()           # "hello world"
s.lower().count("l")  # 3（h-e-l-l-o- -w-o-r-l-d）
# 位置：      ↑  ↑        ↑
#            索引2 索引3   索引9

s.count("l")        # 0（原字符串中只有大写 L，没有小写 l）
s.lower().count("L")  # 0（lower() 后没有大写字母）

🔑 知识点：字符串方法链式调用

方法链：s.lower().count("l") 先调用 lower() 返回新字符串，再对结果调用 count()
lower() 不修改原字符串（字符串不可变），返回新字符串
count() 区分大小写

📌 记忆要点

字符串方法可以链式调用，lower() 后再 count() 统计小写字母

第15题¶

Python中，用于捕获异常的关键字是（）。

选项	内容
A	catch
B	except ✅
C	handle
D	error

答案

B

📖 解析：

A 错误：catch 是 Java/JavaScript 等语言的异常捕获关键字，Python 中不使用
B 正确：Python 使用 except 关键字捕获异常
C 错误：handle 不是 Python 关键字
D 错误：error 不是 Python 异常捕获关键字

Python
try:
    x = int("abc")
except ValueError:          # Python 用 except 捕获异常
    print("输入不是数字")
except Exception as e:      # 捕获所有异常
    print(f"发生错误: {e}")
else:
    print("没有异常")
finally:
    print("总会执行")

🔑 知识点：Python 异常处理结构

关键字	作用
`try`	尝试执行的代码块
`except`	捕获异常
`else`	无异常时执行
`finally`	无论是否异常都执行
`raise`	手动抛出异常

📌 记忆要点

Python 用 except 捕获异常，不是 catch（Java/JS 用 catch）

第16题¶

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

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

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

答案

C

📖 解析：

*args 收集所有位置参数为元组
func(1, 2, 3, 4) → args = (1, 2, 3, 4)
sum((1, 2, 3, 4)) = 1 + 2 + 3 + 4 = 10

Python
def func(*args):
    print(type(args))  # <class 'tuple'>
    print(args)         # (1, 2, 3, 4)
    return sum(args)

func(1, 2, 3, 4)  # 10
func(1, 2)        # 3
func()            # 0（空元组，sum(()) = 0）

🔑 知识点：可变参数 args 和 *kwargs

语法	功能	收集类型
`*args`	收集多余位置参数	元组
`**kwargs`	收集多余关键字参数	字典

Python
def f(*args, **kwargs):
    print(args)    # 位置参数元组
    print(kwargs)  # 关键字参数字典

f(1, 2, a=3, b=4)
# args = (1, 2)
# kwargs = {'a': 3, 'b': 4}

📌 记忆要点

*args 收集位置参数为元组，**kwargs 收集关键字参数为字典

第17题¶

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

选项	内容
A	`"Hello %s" % "World"` 使用%格式化
B	`"Hello {}".format("World")` 使用format方法
C	f字符串只能在Python 3.6及以上使用
D	三种格式化方式中，%格式化功能最强 ✅

答案

D

📖 解析：

A 正确：%s、%d、%f 等是旧式格式化，语法："模板" % 值
B 正确：str.format() 是 Python 2.6+ 引入的格式化方法
C 正确：f-string（f字符串）是 Python 3.6 引入的特性
D 错误：三种格式化方式中，f-string 功能最强、最推荐，% 格式化是最古老、功能最弱的方式

Python
name = "World"

# 方式1：% 格式化（最老，功能最弱）
"Hello %s" % name

# 方式2：format 方法（较新，功能较强）
"Hello {}".format(name)

# 方式3：f-string（最新，功能最强，最推荐）
f"Hello {name}"
f"Hello {name.upper()}"      # 可调用方法
f"2 + 3 = {2 + 3}"           # 可执行表达式
f"{3.14159:.2f}"              # 可格式化：3.14

🔑 知识点：字符串格式化方式对比

方式	版本	推荐度	示例
`%` 格式化	所有版本	⭐	`"%s %d" % ("hi", 3)`
`format()`	2.6+	⭐⭐	`"{} {}".format("hi", 3)`
f-string	3.6+	⭐⭐⭐	`f"{name} {age}"`

📌 记忆要点

f-string 功能最强最推荐，% 格式化最老最弱；f-string 需要 Python 3.6+

第18题¶

下列关于列表推导式的说法，正确的是（）。

选项	内容
A	列表推导式只能生成列表
B	列表推导式不能包含条件判断
C	`[x2 for x in range(5)]` 生成 [0, 1, 4, 9, 16]** ✅
D	列表推导式执行效率比for循环低

答案

C

📖 解析：

A 错误：推导式不仅可以生成列表，还有字典推导式 {k:v for ...} 和集合推导式 {x for ...}
B 错误：列表推导式可以包含 if 条件，如 [x for x in range(10) if x % 2 == 0]
C 正确：range(5) 生成 0,1,2,3,4，各自平方得 0,1,4,9,16
D 错误：列表推导式通常比等价的 for 循环更快（底层用 C 实现）

Python
[x**2 for x in range(5)]
# range(5) → 0, 1, 2, 3, 4
# x**2    → 0, 1, 4, 9, 16
# 结果：[0, 1, 4, 9, 16]

# 带条件的推导式
[x for x in range(10) if x % 2 == 0]   # [0, 2, 4, 6, 8]

# 字典推导式
{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}

🔑 知识点：推导式

类型	语法	示例
列表推导式	`[expr for x in iter]`	`[x**2 for x in range(5)]`
带条件	`[expr for x in iter if cond]`	`[x for x in range(10) if x%2==0]`
字典推导式	`{k:v for x in iter}`	`{x:x**2 for x in range(5)}`
集合推导式	`{expr for x in iter}`	`{x%3 for x in range(10)}`

📌 记忆要点

推导式可生成列表/字典/集合，可含条件判断，通常比 for 循环更高效

第19题¶

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

Python
a = {1, 2, 3}
b = {3, 4, 5}
print(a | b)

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

答案

C

📖 解析：

| 是集合的并集运算符
a | b = {1, 2, 3} | {3, 4, 5} = {1, 2, 3, 4, 5}
重复元素 3 只出现一次（集合自动去重）

Python
a = {1, 2, 3}
b = {3, 4, 5}

a | b       # {1, 2, 3, 4, 5}  并集
a & b       # {3}               交集
a - b       # {1, 2}            差集（a中有b中没有）
a ^ b       # {1, 2, 4, 5}      对称差集

# 等价方法
a.union(b)           # {1, 2, 3, 4, 5}
a.intersection(b)    # {3}
a.difference(b)      # {1, 2}

🔑 知识点：集合运算

运算符	方法	含义	示例
`\|`	`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}`

📌 记忆要点

| 并集、& 交集、- 差集、^ 对称差集

第20题¶

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

选项	内容
A	`__init__` 是构造方法
B	`self` 代表实例对象本身
C	类属性被所有实例共享
D	Python类不支持继承 ✅

答案

D

📖 解析：

A 正确：__init__ 是初始化方法（构造方法），在创建对象时自动调用
B 正确：self 是实例对象的引用，类似于其他语言的 this
C 正确：类属性定义在类中方法外，被所有实例共享
D 错误：Python 完全支持继承，包括单继承和多继承

Python
# Python 支持继承
class Animal:
    def speak(self):
        return "..."

class Dog(Animal):          # 单继承
    def speak(self):
        return "汪汪"

class Cat(Animal):          # 单继承
    def speak(self):
        return "喵喵"

# Python 还支持多继承
class Pet(Dog, Cat):        # 多继承
    pass

dog = Dog()
print(dog.speak())          # 汪汪（继承了 Animal，重写了 speak）

🔑 知识点：Python 类的继承

特性	说明
单继承	`class B(A):`
多继承	`class C(A, B):`
重写方法	子类定义同名方法覆盖父类
`super()`	调用父类方法
`isinstance()`	判断实例关系

📌 记忆要点

Python 支持单继承和多继承，class 子类(父类): 定义继承关系

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

第1题¶

Python中，整数和浮点数相乘，结果一定是浮点数。

答案

✅ 正确

解析： 整数和浮点数运算时，整数会自动提升为浮点数，结果为浮点数。

Python
* 2.0    # 6.0（float）
* 3.14   # 3.14（float）
* 1.5    # 0.0（float，即使是0）

📖 拓展

Python 的隐式类型转换规则：int 与 float 运算 → float；int 与 complex 运算 → complex。

记忆要点： 整数与浮点数运算，结果一定是浮点数

第2题¶

print(1, 2, 3, sep="-") 的输出是 1-2-3。

答案

✅ 正确

解析： sep 参数指定多个输出值之间的分隔符，默认是空格。sep="-" 将分隔符设为 -。

Python
print(1, 2, 3)              # 1 2 3（默认空格分隔）
print(1, 2, 3, sep="-")     # 1-2-3
print(1, 2, 3, sep="")      # 123（无分隔符）
print(1, 2, 3, sep=", ")    # 1, 2, 3

📖 拓展

print() 的 end 参数控制结尾字符，默认是换行符 \n。

记忆要点： sep 控制分隔符，end 控制结尾字符

第3题¶

在Python中，None 等价于 0。

答案

❌ 错误

解析： None 是 Python 中的空值对象，表示"没有值"，与 0 完全不同。

Python
None == 0       # False（None 不等于 0）
None is None    # True（None 只等于自己）
type(None)      # <class 'NoneType'>
type(0)         # <class 'int'>

bool(None)      # False（None 是 falsy）
bool(0)         # False（0 也是 falsy）
# 但 falsy ≠ 相等

None 表示"不存在"或"未赋值"
0 是整数零，是一个有效的数值

📖 拓展

None 常用于函数没有返回值时的默认返回，或表示变量"未设置"的状态。

记忆要点： None 是空值，不是 0；None 只与 None 相等，判断用 is None

第4题¶

字典的键值对是有序的（Python 3.7+）。

答案

✅ 正确

解析： Python 3.7 开始，字典保证插入顺序，即键值对按照插入的顺序排列。Python 3.6 中已实现但未作为语言规范保证。

Python
d = {}
d['a'] = 1
d['b'] = 2
d['c'] = 3
list(d.keys())    # ['a', 'b', 'c']（保持插入顺序）

# Python 3.7 之前不保证顺序

📖 拓展

如果需要有序字典且兼容旧版本，可使用 collections.OrderedDict。

记忆要点： Python 3.7+ 字典有序（插入顺序），3.7 之前不保证

第5题¶

while 循环的条件表达式可以是任意类型。

答案

✅ 正确

解析： while 的条件表达式不限于布尔值，Python 会自动将任意类型的值转换为布尔值进行判断。

Python
while 1:          # 等价于 while True
while 0:          # 等价于 while False
while "hello":    # 等价于 while True（非空字符串为真）
while "":         # 等价于 while False（空字符串为假）
while [1, 2]:     # 等价于 while True（非空列表为真）
while []:         # 等价于 while False（空列表为假）

记忆要点： while 条件可以是任意类型，Python 自动进行布尔转换

第6题¶

使用 pop() 方法删除列表元素时，必须指定索引。

答案

❌ 错误

解析： pop() 不指定索引时，默认删除并返回列表的最后一个元素。

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

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

lst.pop(0)     # 1（删除并返回索引0的元素）
print(lst)     # [2, 3, 4]

lst.pop(1)     # 3（删除并返回索引1的元素）
print(lst)     # [2, 4]

用法	功能
`lst.pop()`	删除并返回最后一个元素
`lst.pop(i)`	删除并返回索引i的元素

记忆要点： pop() 不传参数时默认删除最后一个元素

第7题¶

字符串 s = "" 的布尔值是 False。

答案

✅ 正确

解析： 空字符串 "" 是 Python 中的假值（Falsy），布尔值为 False。

Python
bool("")        # False（空字符串）
bool("hello")   # True（非空字符串）
bool(" ")       # True（含空格的字符串，不是空字符串）
bool("0")       # True（含字符"0"，不是空字符串）

📖 拓展

所有空容器都是 Falsy：""、[]、()、{}、set()、range(0)。所有非空容器都是 Truthy。

记忆要点： 空字符串 "" 是 Falsy，非空字符串（包括 " "、"0"）都是 Truthy

第8题¶

在函数中定义的变量，在函数外部也可以访问。

答案

❌ 错误

解析： 函数内部定义的变量是局部变量，只在函数内部有效，函数外部无法访问。

Python
def my_func():
    x = 10       # 局部变量
    print(x)     # 10

my_func()
print(x)         # ❌ NameError: name 'x' is not defined

# 如果要在函数内使用全局变量并修改，需要 global 声明
y = 20           # 全局变量
def my_func2():
    global y
    y = 30       # 修改全局变量

📖 拓展

LEGB 规则：Python 变量查找顺序为 Local → Enclosing → Global → Built-in。

记忆要点： 函数内定义的变量是局部变量，外部无法访问；修改全局变量需要 global 声明

第9题¶

isinstance(3, int) 的返回值是 True。

答案

✅ 正确

解析： isinstance(obj, class) 检查对象是否是指定类的实例。3 是 int 类型的实例，所以返回 True。

Python
isinstance(3, int)       # True
isinstance(3.14, float)  # True
isinstance("hi", str)    # True
isinstance(3, float)     # False（3 是 int 不是 float）
isinstance(True, int)    # True（bool 是 int 的子类）

# 与 type() 的区别
type(3) == int           # True
type(3) == float         # False

📖 拓展

isinstance() 支持继承检查，type() 不支持。isinstance(True, int) 返回 True，因为 bool 是 int 的子类。

记忆要点： isinstance() 检查实例关系，考虑继承；type() 严格比较类型

第10题¶

sorted() 函数会修改原列表的顺序。

答案

❌ 错误

解析： sorted() 返回一个新的排序列表，不修改原列表。而 list.sort() 是原地排序，会修改原列表。

Python
lst = [3, 1, 2]

# sorted() 不修改原列表
new_lst = sorted(lst)
print(lst)       # [3, 1, 2]（原列表不变）
print(new_lst)   # [1, 2, 3]（新列表已排序）

# sort() 修改原列表
lst.sort()
print(lst)       # [1, 2, 3]（原列表被排序）

方法	是否修改原列表	返回值
`sorted(lst)`	否	新排序列表
`lst.sort()`	是	`None`

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

第11题¶

Python中，pass 语句在语法上必须有语句但逻辑上暂时不需要操作时使用。

答案

✅ 正确

解析： pass 是空操作占位语句，用在语法上需要语句但逻辑上暂不需要操作的地方。

Python
# 空函数体
def my_function():
    pass          # TODO: 以后实现

# 空类定义
class MyClass:
    pass

# 空的 if/for/while 块
for item in items:
    if item == target:
        pass      # 暂不处理
    else:
        process(item)

📖 拓展

pass 与注释的区别：注释会被解释器忽略，而 pass 是一个合法的语句（什么也不做）。在语法要求有语句的地方（如函数体、类体、if体）不能只有注释，但可以用 pass。

记忆要点： pass 是占位符，语法需要语句但暂时无操作时使用

第12题¶

os 模块是Python的第三方库，需要用pip安装。

答案

❌ 错误

解析： os 模块是 Python 的标准库，随 Python 一起安装，无需用 pip 额外安装。直接 import os 即可使用。

Python
import os

os.getcwd()          # 获取当前工作目录
os.listdir('.')      # 列出当前目录文件
os.path.exists('f')  # 检查文件是否存在
os.mkdir('new_dir')  # 创建目录

标准库 vs 第三方库：

类型	示例	安装方式
标准库	`os`、`sys`、`math`、`json`、`random`	随Python安装
第三方库	`numpy`、`pandas`、`requests`	`pip install`

记忆要点： os 是标准库，不需要 pip 安装；第三方库才需要 pip

第13题¶

for i in "Python": 可以遍历字符串中的每个字符。

答案

✅ 正确

解析： 字符串是可迭代对象，for 循环可以逐个遍历字符串中的字符。

Python
for ch in "Python":
    print(ch)
# 输出：
# P
# y
# t
# h
# o
# n

📖 拓展

所有可迭代对象都可以用 for 遍历：字符串、列表、元组、字典、集合、range()、文件对象等。

记忆要点： 字符串是可迭代对象，for 循环逐字符遍历

第14题¶

列表切片操作返回的是原列表的一个副本，修改切片结果不会影响原列表。

答案

✅ 正确

解析： 切片操作创建新列表（浅拷贝），修改切片结果不影响原列表。

Python
lst = [1, 2, 3, 4, 5]
new_lst = lst[1:4]     # [2, 3, 4]（新列表）

new_lst[0] = 99
print(new_lst)          # [99, 3, 4]
print(lst)              # [1, 2, 3, 4, 5]（原列表不变）

# 注意：浅拷贝的局限性
lst2 = [[1, 2], [3, 4]]
new_lst2 = lst2[:]
new_lst2[0][0] = 99    # 修改嵌套列表
print(lst2)             # [[99, 2], [3, 4]]（原列表受影响！浅拷贝不复制嵌套对象）

📖 拓展

切片是浅拷贝，嵌套的可变对象仍然是引用。如需完全独立的副本，使用 copy.deepcopy()。

记忆要点： 切片创建新列表（浅拷贝），修改顶层元素不影响原列表，但嵌套可变对象仍共享引用

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

第1题：求列表最大值¶

题目： 找出列表中的最大值并输出。

Python
lst = [23, 45, 12, 67, 34, 89, 56]
#**********begin1**********
max_val = _______
#**********end1**********
for num in lst:
    if num > max_val:
        #**********begin2**********
        _______
        #**********end2**********
print("最大值为:", max_val)

✅ 填空答案

begin1： lst[0]
begin2： max_val = num

完整正确代码

Python
# 找出列表中的最大值
# 思路：假设第一个元素为最大值，依次与后续元素比较
lst = [23, 45, 12, 67, 34, 89, 56]
max_val = lst[0]              # 【填空1】初始最大值设为第一个元素
for num in lst:
    if num > max_val:         # 发现更大的值
        max_val = num         # 【填空2】更新最大值
print("最大值为:", max_val)     # 输出: 最大值为: 89

运行结果： 最大值为: 89

🔑 知识点：求最大值的遍历算法

初始值设为列表第一个元素（不能用0，因为列表可能全为负数）
遍历每个元素，如果比当前最大值大则更新
时间复杂度 O(n)

📖 拓展

Python
# 方法2：使用内置函数
lst = [23, 45, 12, 67, 34, 89, 56]
print("最大值为:", max(lst))

# 方法3：排序取最后一个
lst.sort()
print("最大值为:", lst[-1])

# 方法4：使用reduce
from functools import reduce
max_val = reduce(lambda a, b: a if a > b else b, lst)
print("最大值为:", max_val)

📌 记忆要点

求最大值：初始值设为第一个元素，遍历比较更新
不能将初始值设为0（列表可能全为负数）

第2题：字符串反转函数¶

题目： 编写函数实现字符串反转，并在主程序中调用。

Python
def reverse_string(s):
    #**********begin1**********
    _______
    #**********end1**********

text = input("请输入字符串:")
#**********begin2**********
result = _______
#**********end2**********
print("反转后:", result)

✅ 填空答案

begin1： return s[::-1]
begin2： reverse_string(text)

完整正确代码

Python
# 字符串反转函数
def reverse_string(s):
    return s[::-1]              # 【填空1】切片反转字符串

text = input("请输入字符串:")
result = reverse_string(text)   # 【填空2】调用函数并接收返回值
print("反转后:", result)

运行示例： 输入 Hello → 输出 反转后: olleH

🔑 知识点：字符串反转与函数调用

s[::-1] 切片反转：步长 -1 表示从后向前取
函数调用：函数名(参数) 获取返回值

📖 拓展

Python
# 方法2：使用reversed
def reverse_string(s):
    return ''.join(reversed(s))

# 方法3：使用循环
def reverse_string(s):
    result = ''
    for ch in s:
        result = ch + result
    return result

# 方法4：递归
def reverse_string(s):
    if len(s) <= 1:
        return s
    return reverse_string(s[1:]) + s[0]

📌 记忆要点

s[::-1] 最简洁的字符串反转方式
函数定义 def，调用 函数名(参数)，返回值用变量接收

第3题：字典统计¶

题目： 统计字符串中每个字符出现的次数，存入字典并输出。

Python
s = "abracadabra"
count_dict = {}
for ch in s:
    #**********begin1**********
    _______
    #**********end1**********
        count_dict[ch] = 1
    else:
        #**********begin2**********
        _______
        #**********end2**********
print(count_dict)

✅ 填空答案

begin1： if ch not in count_dict:
begin2： count_dict[ch] += 1

完整正确代码

Python
# 统计字符出现次数
# 思路：遍历字符串，新字符初始化为1，已有字符计数+1
s = "abracadabra"
count_dict = {}
for ch in s:
    if ch not in count_dict:      # 【填空1】判断字符是否首次出现
        count_dict[ch] = 1        # 首次出现，计数为1
    else:
        count_dict[ch] += 1       # 【填空2】已存在，计数+1
print(count_dict)
# 输出: {'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1}

运行结果： {'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1}

🔑 知识点：字典统计模式

ch not in count_dict 判断键是否不存在
首次出现初始化为1，后续累加
这是经典的"计数器"模式

📖 拓展

Python
# 方法2：使用 get() 方法
count_dict = {}
for ch in s:
    count_dict[ch] = count_dict.get(ch, 0) + 1

# 方法3：使用 defaultdict
from collections import defaultdict
count_dict = defaultdict(int)
for ch in s:
    count_dict[ch] += 1

# 方法4：使用 Counter（最简洁）
from collections import Counter
count_dict = Counter(s)
print(dict(count_dict))

📌 记忆要点

字典统计：not in 判断首次出现，get(key, 0) 更简洁
Counter 是最方便的计数工具

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

第1题：素数判断¶

题目： 判断一个数是否为素数（质数）。

Python
def is_prime(n):
    if n <= 1:
        return False
    #**********begin1**********
    for i in range(2, n):
    #**********end1**********
        #**********begin2**********
        if n / i == 0:
        #**********end2**********
            return False
    return True

num = int(input("请输入一个正整数:"))
#**********begin3**********
if is_prime(num):
    print(num, "是素数")
else
    print(num, "不是素数")
#**********end3**********

✅ 错误修正

错误位置	原代码	修正后	错误原因
begin2	`if n / i == 0:`	`if n % i == 0:`	`/` 是除法，`%` 是取余；判断整除应用取余
begin3	`else`	`else:`	else 后缺少冒号

关于 begin1： range(2, n) 在功能上是正确的（可以正确判断素数），但效率不高。可优化为 range(2, int(n**0.5) + 1)，只需检查到 √n 即可。此优化不影响正确性，仅提升性能。

完整正确代码

Python
# 素数判断
# 思路：大于1的自然数，不能被2到n-1之间的任何数整除
def is_prime(n):
    if n <= 1:
        return False
    for i in range(2, n):           # 功能正确，可优化为 range(2, int(n**0.5)+1)
        if n % i == 0:              # ✅ 修正1：/ 改为 %（取余判断整除）
            return False
    return True

num = int(input("请输入一个正整数:"))
if is_prime(num):
    print(num, "是素数")
else:                               # ✅ 修正2：添加冒号
    print(num, "不是素数")

运行示例：

Python
输入: 7
7 是素数

输入: 10
10 不是素数

🔑 知识点：取余运算、分支语法

/ 是除法（返回浮点数），% 是取余（判断整除）
n % i == 0 表示 n 能被 i 整除
else: 冒号不能忘

📖 拓展

Python
# 优化版：只需检查到 √n
def is_prime(n):
    if n <= 1:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

# 原版对 n=97 需要检查 95 个数
# 优化版对 n=97 只需检查 9 个数（2~9）

📌 记忆要点

判断整除用 %（取余），不是 /（除法）
if/elif/else/for/while 语句末尾必须加冒号 :
素数判断可优化到 √n

第2题：列表元素查找¶

题目： 在列表中查找指定元素，返回其索引，找不到返回-1。

Python
def find_element(lst, target):
    #**********begin1**********
    for i in range(len(lst)):
    #**********end1**********
        #**********begin2**********
        if lst[i] == target:
            return i
        else:
            return -1
        #**********end2**********
    return -1

nums = [10, 20, 30, 40, 50]
#**********begin3**********
result = find_element(nums, "30")
#**********end3**********
print("索引为:", result)

✅ 错误修正

错误位置	原代码	修正后	错误原因
begin2	`else: return -1`（在循环体内）	删除 else 分支，将 `return -1` 移至循环后	else 在循环内部导致只检查第一个元素就返回-1
begin3	`find_element(nums, "30")`	`find_element(nums, 30)`	列表元素是整数，`"30"` 是字符串，类型不匹配

关于 begin1： for i in range(len(lst)): 是正确的索引遍历方式，无需修改。

完整正确代码

Python
# 列表元素查找
# 思路：遍历列表，找到目标返回索引，遍历完未找到返回-1
def find_element(lst, target):
    for i in range(len(lst)):
        if lst[i] == target:        # 找到目标
            return i
        # ✅ 修正1：删除 else: return -1
        # 原代码的 else 导致只检查第一个元素
    return -1                        # 循环结束后未找到，返回-1

nums = [10, 20, 30, 40, 50]
result = find_element(nums, 30)      # ✅ 修正2："30" 改为 30（整数）
print("索引为:", result)              # 输出: 索引为: 2

运行结果： 索引为: 2

📖 解析：

错误1（begin2）：原代码中 else: return -1 在 if 内部，导致只要第一个元素不匹配就立即返回-1，无法继续检查后续元素。正确的逻辑是只在循环全部结束后才返回-1。
错误2（begin3）：列表 nums 中的元素是整数 10, 20, 30...，但传入的是字符串 "30"。30 == "30" 为 False，导致永远找不到。

🔑 知识点：线性查找、类型匹配

查找逻辑：找到即返回，未找到在循环结束后返回-1
Python 中 == 比较时类型必须匹配：30 != "30"
for-else 结构：else 在循环未被 break 时执行

📖 拓展

Python
# 方法2：使用 for-else
def find_element(lst, target):
    for i in range(len(lst)):
        if lst[i] == target:
            return i
    else:
        return -1  # 循环正常结束（未被return中断）

# 方法3：使用列表的 index 方法
def find_element(lst, target):
    try:
        return lst.index(target)
    except ValueError:
        return -1

# 方法4：直接遍历元素（不需要索引时）
def find_element(lst, target):
    if target in lst:
        return lst.index(target)
    return -1

📌 记忆要点

查找函数中，"未找到"的返回应在循环之后，不是在循环内部的 else 中
注意整数和字符串的类型匹配，30 != "30"

第3题：矩阵转置¶

题目： 将3×3矩阵转置（行变列，列变行）。

Python
matrix = [[1, 2, 3],
          [4, 5, 6],
          [7, 8, 9]]
result = []
#**********begin1**********
for i in range(4):
#**********end1**********
    row = []
    for j in range(3):
        #**********begin2**********
        row.append(matrix[j][i])
        #**********end2**********
    result.append(row)

#**********begin3**********
for r in result:
    print(r)
#**********end3**********

✅ 错误修正

错误位置	原代码	修正后	错误原因
begin1	`range(4)`	`range(3)`	3×3矩阵只有3列，外层循环应为3次，4会导致索引越界

关于 begin2： matrix[j][i] 是正确的转置操作——取第j行第i列的元素放到新矩阵的第i行第j列。

关于 begin3： 遍历打印结果矩阵的方式正确，无需修改。

完整正确代码

Python
# 矩阵转置
# 思路：遍历列索引，对每列创建新行，将原矩阵的第j行第i列放入新矩阵的第i行
matrix = [[1, 2, 3],
          [4, 5, 6],
          [7, 8, 9]]
result = []
for i in range(3):                  # ✅ 修正1：range(4) 改为 range(3)
    row = []
    for j in range(3):
        row.append(matrix[j][i])    # 取第j行第i列
    result.append(row)

for r in result:
    print(r)

运行结果：

Python
[1, 4, 7]
[2, 5, 8]
[3, 6, 9]

📖 解析：

错误（begin1）：range(4) 会遍历 i = 0,1,2,3，当 i=3 时，matrix[j][3] 索引越界（每行只有3个元素，索引0~2），应改为 range(3)
转置原理：原矩阵 matrix[j][i]（第j行第i列）→ 新矩阵的第i行第j列
原矩阵：行=[1,2,3], [4,5,6], [7,8,9]
转置后：行=[1,4,7], [2,5,8], [3,6,9]

🔑 知识点：矩阵转置

转置：行变列，列变行
matrix[j][i] 取原矩阵第j行第i列，放入新矩阵第i行
循环范围应与矩阵维度匹配

📖 拓展

Python
# 方法2：列表推导式（最简洁）
result = [[matrix[j][i] for j in range(3)] for i in range(3)]

# 方法3：zip 解包
result = [list(row) for row in zip(*matrix)]

# 方法4：NumPy
import numpy as np
result = np.array(matrix).T.tolist()

📌 记忆要点

矩阵转置：交换行列索引 matrix[j][i]
循环范围必须与矩阵维度匹配，3×3矩阵用 range(3)

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

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

Python
def count_lines(filename):
    #**********begin1**********
    f = open(filename, "w")
    #**********end1**********
    lines = f.readlines()
    count = len(lines)
    #**********begin2**********
    return count
    #**********end2**********

#**********begin3**********
total = count_lines("data.txt")
print("行数:" + total)
#**********end3**********

✅ 错误修正

错误位置	原代码	修正后	错误原因
begin1	`open(filename, "w")`	`open(filename, "r")`	`"w"` 是写入模式（会清空文件），读取文件应用 `"r"`
begin2	`return count`（缺少关闭文件）	`f.close()` + `return count`	文件使用后应关闭，否则资源泄露
begin3	`"行数:" + total`	`"行数:" + str(total)` 或 `print("行数:", total)`	`total` 是整数，不能直接用 `+` 拼接字符串

完整正确代码

Python
# 读取文件统计行数
def count_lines(filename):
    f = open(filename, "r")         # ✅ 修正1："w" 改为 "r"（读取模式）
    lines = f.readlines()
    count = len(lines)
    f.close()                       # ✅ 修正2：添加文件关闭
    return count

total = count_lines("data.txt")
print("行数:" + str(total))          # ✅ 修正3：str(total) 转换为字符串

📖 解析：

错误1（begin1）："w" 模式会清空文件内容再打开，读取文件应使用 "r" 模式
错误2（begin2）：打开文件后应调用 f.close() 关闭文件，否则可能导致资源泄露
错误3（begin3）：total 是 int 类型，不能与字符串用 + 拼接，需用 str() 转换

🔑 知识点：文件操作、类型转换

模式	含义	文件存在时	文件不存在时
`"r"`	只读	读取	❌报错
`"w"`	写入	清空	创建
`"a"`	追加	末尾追加	创建

文件操作后应调用 close() 关闭文件
字符串与数字拼接需用 str() 转换，或用逗号分隔，或用 f-string

📖 拓展

Python
# 推荐写法：with 语句自动关闭文件
def count_lines(filename):
    with open(filename, "r") as f:
        return len(f.readlines())

# 更高效的写法（不加载全部内容到内存）
def count_lines(filename):
    with open(filename, "r") as f:
        return sum(1 for _ in f)

# 输出用 f-string
total = count_lines("data.txt")
print(f"行数:{total}")

📌 记忆要点

读文件用 "r"，写文件用 "w"（会清空），追加用 "a"
文件操作后必须关闭，推荐用 with 语句自动管理
整数与字符串拼接需 str() 转换

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

第1题：打印菱形星号¶

题目： 编写程序，打印如下菱形星号图案（n=5）：

Text Only
1 2 3 4 5	`* * * * *`

要求：程序能根据输入的奇数n打印对应大小的菱形。

方法1：上下分开打印（推荐，最直观）

Python
def print_diamond(n):
    # 上半部分（包含中间行）
    for i in range(n // 2 + 1):
        spaces = n // 2 - i         # 空格数递减
        stars = 2 * i + 1            # 星号数递增
        print(" " * spaces + "*" * stars)

    # 下半部分
    for i in range(n // 2 - 1, -1, -1):
        spaces = n // 2 - i
        stars = 2 * i + 1
        print(" " * spaces + "*" * stars)

n = int(input("请输入奇数n:"))
print_diamond(n)

方法2：利用对称性（一行循环）

Python
def print_diamond(n):
    half = n // 2
    for i in range(-half, half + 1):
        spaces = abs(i)              # 空格数 = |i|
        stars = n - 2 * abs(i)       # 星号数 = n - 2*|i|
        print(" " * spaces + "*" * stars)

n = int(input("请输入奇数n:"))
print_diamond(n)

方法3：用字符串格式化

Python
def print_diamond(n):
    half = n // 2
    for i in range(half + 1):
        line = ("*" * (2 * i + 1)).center(n)
        print(line)
    for i in range(half - 1, -1, -1):
        line = ("*" * (2 * i + 1)).center(n)
        print(line)

n = int(input("请输入奇数n:"))
print_diamond(n)

运行示例（n=5）：

Text Only
1 2 3 4 5	`* * * * *`

📖 解析：

菱形由上半部分（递增）和下半部分（递减）组成
第 i 行（从0开始）：空格数 = half - i，星号数 = 2*i + 1
n // 2 是菱形的半高度
利用 " " * n 和 "*" * n 重复字符串简化输出

🔑 知识点

字符串乘法：" " * n 生成 n 个空格
str.center(width) 居中对齐
abs() 取绝对值，利用对称性简化循环

📖 拓展

Python
# 打印空心菱形
def print_hollow_diamond(n):
    half = n // 2
    for i in range(-half, half + 1):
        spaces = abs(i)
        inner_spaces = n - 2 * abs(i) - 2
        if inner_spaces < 0:
            print(" " * spaces + "*")
        else:
            print(" " * spaces + "*" + " " * inner_spaces + "*")

print_hollow_diamond(5)
# 输出：
#   *
#  * *
# *   *
#  * *
#   *

📌 记忆要点

菱形图案：上三角递增 + 下三角递减
空格数 = half - i，星号数 = 2*i + 1
字符串乘法 "*" * n 简化重复输出

第2题：通讯录管理¶

题目： 编写程序实现简单的通讯录管理，功能如下：

添加联系人（姓名和电话）
删除联系人（按姓名）
查询联系人（按姓名，显示电话）
显示所有联系人
输入0退出程序

示例交互：

Text Only

1.添加 2.删除 3.查询 4.显示所有 0.退出: 1
输入姓名: 张三
输入电话: 13800138000
添加成功！
1.添加 2.删除 3.查询 4.显示所有 0.退出: 4
张三: 13800138000

参考答案

Python
def main():
    contacts = {}  # 使用字典存储通讯录：{姓名: 电话}

    while True:
        print("\n1.添加 2.删除 3.查询 4.显示所有 0.退出", end=": ")
        choice = input()

        if choice == "0":
            print("再见！")
            break

        elif choice == "1":
            name = input("输入姓名: ")
            phone = input("输入电话: ")
            contacts[name] = phone
            print("添加成功！")

        elif choice == "2":
            name = input("输入姓名: ")
            if name in contacts:
                del contacts[name]
                print("删除成功！")
            else:
                print("联系人不存在！")

        elif choice == "3":
            name = input("输入姓名: ")
            if name in contacts:
                print(f"{name}: {contacts[name]}")
            else:
                print("联系人不存在！")

        elif choice == "4":
            if contacts:
                for name, phone in contacts.items():
                    print(f"{name}: {phone}")
            else:
                print("通讯录为空！")

        else:
            print("无效选项，请重新输入！")

main()

📖 解析：

使用字典 contacts = {} 存储姓名-电话对，姓名为键（唯一），电话为值
while True + break 实现菜单循环
每个功能用 if-elif 分支处理
添加：contacts[name] = phone（键存在则更新，不存在则新增）
删除：del contacts[name]（先检查键是否存在）
查询：contacts[name] 或 contacts.get(name)
显示：contacts.items() 遍历所有键值对

🔑 知识点

操作	代码	说明
添加/更新	`d[key] = value`	键存在则更新，不存在则新增
删除	`del d[key]` 或 `d.pop(key)`	删除前应检查键是否存在
查询	`d[key]` 或 `d.get(key)`	`get()` 键不存在时不报错
遍历	`for k, v in d.items()`	同时获取键和值
判断存在	`key in d`	检查键是否在字典中

📖 拓展

Python
# 改进版：使用函数封装每个功能
def add_contact(contacts):
    name = input("输入姓名: ")
    phone = input("输入电话: ")
    if name in contacts:
        print(f"{name} 已存在，是否覆盖？(y/n): ", end="")
        if input().lower() != 'y':
            return
    contacts[name] = phone
    print("添加成功！")

def delete_contact(contacts):
    name = input("输入姓名: ")
    if name in contacts:
        phone = contacts.pop(name)
        print(f"已删除 {name}: {phone}")
    else:
        print("联系人不存在！")

def search_contact(contacts):
    name = input("输入姓名: ")
    phone = contacts.get(name)
    if phone:
        print(f"{name}: {phone}")
    else:
        print("联系人不存在！")

def show_all(contacts):
    if not contacts:
        print("通讯录为空！")
        return
    for name, phone in sorted(contacts.items()):
        print(f"{name}: {phone}")

def main():
    contacts = {}
    menu = "\n1.添加 2.删除 3.查询 4.显示所有 0.退出: "
    while True:
        choice = input(menu)
        if choice == "0":
            print("再见！")
            break
        elif choice == "1":
            add_contact(contacts)
        elif choice == "2":
            delete_contact(contacts)
        elif choice == "3":
            search_contact(contacts)
        elif choice == "4":
            show_all(contacts)
        else:
            print("无效选项！")

main()

📌 记忆要点

字典是通讯录的理想数据结构（键唯一，查找快）
while True + break 实现交互循环
操作前先检查键是否存在，避免 KeyError
功能拆分为函数使代码更清晰

知识点覆盖总结

题型	知识点
单选1-5	变量命名规则、type()函数、运算符优先级、字符串拼接、insert()方法
单选6-10	逻辑运算优先级、元组特性、字典操作、max()函数、注释规则
单选11-15	浅拷贝、进制转换、字典删除、字符串方法链、异常处理
单选16-20	可变参数*args、字符串格式化、列表推导式、集合运算、类继承
判断1-7	int*float结果、sep参数、None与0、字典有序、while条件、pop()默认、空字符串布尔值
判断8-14	局部变量作用域、isinstance()、sorted()、pass语句、os模块、字符串遍历、切片拷贝
填空1-3	求最大值算法、字符串反转、字典统计计数
改错1-4	取余vs除法、else语法、查找逻辑、文件操作模式、类型拼接
编程1-2	菱形图案打印、通讯录字典管理