Python 模拟考试 1 — 解析

📝 一、单选题¶

第 1 题¶

Python语言中，以下哪个不是合法的变量名？

选项	内容
A	_name
B	my_var
C	2nd_value ✅
D	student_name

答案

C

📖 解析：

A 正确：变量名可以以下划线开头
B 正确：变量名可以包含字母、数字和下划线
C 错误：变量名不能以数字开头，2nd_value 以数字 2 开头，不合法
D 正确：由字母和下划线组成，合法

🔑 知识点：Python 变量命名规则

变量名只能包含字母、数字和下划线 _
变量名不能以数字开头
变量名不能是 Python 关键字（如 if、for、while 等）
变量名区分大小写（Name 和 name 是不同的）

📌 记忆要点

变量名不能以数字开头
变量名不能是关键字
变量名区分大小写

第 2 题¶

下列关于Python语言的说法中，不正确的是（）。

选项	内容
A	Python是一种解释型语言
B	Python使用缩进来表示代码块
C	Python中一行只能写一条语句 ✅
D	Python是一种面向对象的语言

答案

C

📖 解析：

A 正确：Python 是解释型语言，代码逐行执行，无需编译
B 正确：Python 使用缩进而非大括号来标识代码块
C 错误：Python 允许用分号 ; 在同一行写多条语句，如 a=1; b=2
D 正确：Python 支持面向对象编程（类、继承、多态等）

🔑 知识点：Python 语言特性

特性	说明
解释型	逐行执行，无需编译
缩进语法	用缩进表示代码块
多语句行	用 `;` 分隔同一行多条语句
面向对象	支持类、继承、封装、多态

📌 记忆要点

Python 可以用 ; 在一行写多条语句（但不推荐）
Python 是解释型 + 面向对象语言

第 3 题¶

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

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

答案

B

📖 解析：

3.0 带有小数点，是浮点数（float），不是整数
type(3) → \<class 'int'\>
type(3.0) → \<class 'float'\>
type("3") → \<class 'str'\>
Python 中没有 number 类型

🔑 知识点：Python 数据类型

字面量	类型
`3`	int
`3.0`	float
`"3"`	str
`True`	bool
`[3]`	list
`(3,)`	tuple
`{3}`	set
`{'a': 3}`	dict

📌 记忆要点

带小数点的数字是 float，即使小数部分为 0
type() 函数用于查看变量类型

第 4 题¶

以下哪种数据类型是不可变的？（）

选项	内容
A	列表
B	字典
C	集合
D	元组 ✅

答案

D

📖 解析：

A 错误：列表是可变的，可以增删改元素
B 错误：字典是可变的，可以增删改键值对
C 错误：集合是可变的，可以增删元素
D 正确：元组是不可变的，创建后不能修改元素

🔑 知识点：可变与不可变类型

不可变（Immutable）	可变（Mutable）
int	list
float	dict
str	set
tuple	bytearray
bool	—
frozenset	—

Python
# 不可变：元组不能修改
t = (1, 2, 3)
t[0] = 10  # ❌ TypeError

# 可变：列表可以修改
lst = [1, 2, 3]
lst[0] = 10  # ✅ 正常

📌 记忆要点

不可变：int、float、str、tuple、bool
可变：list、dict、set

第 5 题¶

表达式 17 // 3 的结果是（）。

选项	内容
A	5 ✅
B	5.0
C	6
D	5.67

答案

A

📖 解析：

// 是整除（地板除）运算符，向下取整
17 / 3 = 5.666...，向下取整为 5
因为两个操作数都是整数，结果也是整数

Python
17 // 3    # 5（整数）
17 / 3     # 5.666...（浮点数）
17 % 3     # 2（取余）
-17 // 3   # -6（向下取整，不是-5）

🔑 知识点：整除运算

// 整除：结果向下取整
两个整数整除，结果仍为整数
有浮点数参与时，结果为浮点数：17 // 3.0 → 5.0
负数整除注意向下取整：-17 // 3 → -6

📌 记忆要点

// 是整除，向下取整
整数整除得整数，有浮点得浮点

第 6 题¶

下列表达式中，结果为True的是（）。

选项	内容
A	True and False
B	not True
C	False or True ✅
D	not (True or False)

答案

C

📖 解析：

A：True and False → False（and 需要两边都为 True）
B：not True → False（not 取反）
C：False or True → True（or 只要一边为 True 即可）
D：not (True or False) → not True → False

🔑 知识点：逻辑运算符

运算符	含义	规则
`and`	与	两边都为 True 才为 True
`or`	或	一边为 True 即为 True
`not`	非	取反

优先级：not > and > or

Python
# 短路求值
True or print("不会执行")    # or 遇到 True 就不再计算后面
False and print("不会执行")  # and 遇到 False 就不再计算后面

📌 记忆要点

and 全真才真，or 一真即真，not 取反
优先级：not > and > or
短路求值：and 遇 False 停，or 遇 True 停

第 7 题¶

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

选项	内容
A	64
B	512 ✅
C	36
D	81

答案

B

📖 解析：

** 幂运算的结合性是从右往左
2 ** 3 ** 2 = 2 ** (3 ** 2) = 2 ** 9 = 512
如果从左往右：(2 ** 3) ** 2 = 8 ** 2 = 64，这是错误的

Python
2 ** 3 ** 2   # 512（右结合：2^(3^2) = 2^9）
(2 ** 3) ** 2  # 64（左结合：(2^3)^2 = 8^2）

🔑 知识点：幂运算结合性

** 是 Python 中唯一右结合的二元运算符
当有多个 ** 时，从右往左计算

📌 记忆要点

** 是右结合，2**3**2 = 2**9 = 512，不是 8**2 = 64

第 8 题¶

字符串 "Python"[1:4] 的结果是（）。

选项	内容
A	"Pyt"
B	"yth" ✅
C	"ytho"
D	"tho"

答案

B

📖 解析：

字符串索引：

Python
  P   y   t   h   o   n
  0   1   2   3   4   5
 -6  -5  -4  -3  -2  -1

[1:4] 取索引 1 到 3（左闭右开，不包含4）
索引 1='y'，2='t'，3='h' → "yth"

🔑 知识点：字符串切片

操作	结果	说明
`s[1:4]`	`"yth"`	索引1到3
`s[:3]`	`"Pyt"`	从头到索引2
`s[2:]`	`"thon"`	索引2到末尾
`s[-2:]`	`"on"`	最后2个字符
`s[::-1]`	`"nohtyP"`	反转字符串

📌 记忆要点

切片 [a:b] 左闭右开，包含 a 不包含 b
索引从 0 开始，负索引从 -1 开始

第 9 题¶

以下关于字符串方法的描述，错误的是（）。

选项	内容
A	split() 将字符串按指定分隔符拆分为列表
B	join() 将序列中的字符串连接为一个字符串
C	replace() 直接修改原字符串的内容 ✅
D	find() 找不到子串时返回-1

答案

C

📖 解析：

A 正确："a,b,c".split(",") → ["a", "b", "c"]
B 正确：",".join(["a", "b", "c"]) → "a,b,c"
C 错误：字符串是不可变的，replace() 返回新字符串，不修改原字符串
D 正确："hello".find("x") → -1

Python
s = "hello world"
new_s = s.replace("world", "python")
print(s)      # "hello world"（原字符串未变）
print(new_s)  # "hello python"（返回新字符串）

🔑 知识点：字符串方法与不可变性

字符串是不可变对象，所有字符串方法都返回新字符串
类似的：upper()、lower()、strip()、replace() 等都不修改原字符串

📌 记忆要点

字符串不可变，所有方法返回新字符串，原串不变
find() 找不到返回 -1，不是报错

第 10 题¶

表达式 "ababab".count("ab") 的结果是（）。

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

答案

C

📖 解析：

count("ab") 统计子串 "ab" 在字符串中出现的次数
"ababab" 中 "ab" 出现的位置：索引0、索引2、索引4
注意：count() 统计的是非重叠出现次数

Python
"ababab".count("ab")    # 3（位置0-1, 2-3, 4-5）
"aaa".count("aa")       # 1（非重叠，只匹配位置0-1）
"ababa".count("aba")    # 1（非重叠，位置0-2匹配后，位置2已使用）

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

str.count(sub) 统计子串非重叠出现次数
str.count(sub, start, end) 可指定搜索范围

📌 记忆要点

count() 统计非重叠出现次数

第 11 题¶

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

选项	内容
A	列表中的元素可以是不同类型
B	列表可以使用负数索引
C	列表是不可变数据类型 ✅
D	列表支持切片操作

答案

C

📖 解析：

A 正确：Python 列表可以混合存储不同类型，如 [1, "hello", 3.14, True]
B 正确：lst[-1] 取最后一个元素，lst[-2] 取倒数第二个
C 错误：列表是可变数据类型，可以增删改元素
D 正确：lst[1:3]、lst[::-1] 等切片操作都支持

🔑 知识点：列表特性

特性	说明
可变	可以增删改元素
有序	保持插入顺序
异构	元素可以是不同类型
支持索引	正索引和负索引
支持切片	`lst[start:stop:step]`

📌 记忆要点

列表是可变的，元组是不可变的
列表可以存储不同类型的元素

第 12 题¶

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

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

答案

B

📖 解析：

append() 将参数作为一个整体添加到列表末尾
[4, 5] 被作为一个元素添加，形成嵌套列表

Python
x = [1, 2, 3]
x.append([4, 5])
print(x)  # [1, 2, 3, [4, 5]]

# 如果想要 [1, 2, 3, 4, 5]，应该用 extend()
y = [1, 2, 3]
y.extend([4, 5])
print(y)  # [1, 2, 3, 4, 5]

# 或者用 +=
z = [1, 2, 3]
z += [4, 5]
print(z)  # [1, 2, 3, 4, 5]

🔑 知识点：列表 append vs extend

方法	效果	示例
`append(x)`	整体添加	`[1,2].append([3,4])` → `[1,2,[3,4]]`
`extend(x)`	逐个添加	`[1,2].extend([3,4])` → `[1,2,3,4]`
`insert(i,x)`	指定位置插入	`[1,2].insert(0,0)` → `[0,1,2]`

📌 记忆要点

append() 整体添加，extend() 逐个展开
append([4,5]) 产生嵌套，不是合并

第 13 题¶

已知 d = {'a': 1, 'b': 2, 'c': 3}，以下操作会报错的是（）。

选项	内容
A	d['a']
B	d.get('d')
C	d['d'] ✅
D	'a' in d

答案

C

📖 解析：

A：d['a'] → 1，键存在，正常访问
B：d.get('d') → None，键不存在时不报错，返回 None
C：d['d'] → KeyError，键不存在时用 [] 访问会报错
D：'a' in d → True，检查键是否存在

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

d['a']          # 1 ✅
d.get('d')      # None ✅（不报错）
d.get('d', 0)   # 0 ✅（指定默认值）
d['d']          # ❌ KeyError: 'd'
'a' in d        # True ✅

🔑 知识点：字典访问方式

方式	键不存在时	示例
`d[key]`	报 KeyError	`d['d']` → ❌
`d.get(key)`	返回 None	`d.get('d')` → None
`d.get(key, default)`	返回默认值	`d.get('d', 0)` → 0

📌 记忆要点

d[key] 键不存在会报错，d.get(key) 不会
in 对字典检查的是键，不是值

第 14 题¶

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

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

答案

B

📖 解析：

[1, 2, 2, 3, 3, 3] 是列表，长度为 6
set([1, 2, 2, 3, 3, 3]) → {1, 2, 3}，集合自动去重
len({1, 2, 3}) → 3

Python
set([1, 2, 2, 3, 3, 3])  # {1, 2, 3}
len({1, 2, 3})            # 3

🔑 知识点：集合（set）特性

特性	说明
去重	自动去除重复元素
无序	不保持插入顺序
可变	可以增删元素（`add`/`remove`）
不支持索引	`s[0]` 会报错

📌 记忆要点

set() 自动去重，常用于去重操作
集合无序，不支持索引访问

第 15 题¶

下列关于Python函数的说法，正确的是（）。

选项	内容
A	函数必须有return语句
B	函数可以有多个return语句 ✅
C	函数只能返回一个值
D	函数定义时必须指定参数类型

答案

B

📖 解析：

A 错误：函数可以没有 return，此时默认返回 None
B 正确：函数可以有多个 return（如通过 if-else 分支），但每次调用只执行其中一个
C 错误：Python 函数可以返回多个值（本质是返回元组）
D 错误：Python 是动态类型，定义函数时不需要指定参数类型

Python
# 多个 return
def check(n):
    if n > 0:
        return "正数"
    elif n < 0:
        return "负数"
    else:
        return "零"

# 无 return
def greet(name):
    print("Hello", name)
# greet("Tom") 返回 None

# 返回多个值
def divide(a, b):
    return a // b, a % b   # 返回元组
q, r = divide(17, 3)      # q=5, r=2

🔑 知识点：函数返回值

情况	返回值
有 `return value`	返回 value
无 `return` 或 `return` 无值	返回 `None`
`return a, b`	返回元组 `(a, b)`

📌 记忆要点

函数可以有多个 return，但每次只执行一个
无 return 的函数返回 None
返回多个值本质是返回元组

第 16 题¶

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

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

选项	内容
A	3
B	6 ✅
C	报错
D	5

答案

B

📖 解析：

func(a, b=2) 中 b=2 是默认参数
调用 func(3) 时，a=3，b 使用默认值 2
返回 3 * 2 = 6

Python
func(3)       # a=3, b=2(默认) → 6
func(3, 4)    # a=3, b=4 → 12
func(3, b=5)  # a=3, b=5 → 15（关键字参数）

🔑 知识点：默认参数

默认参数必须放在非默认参数后面
调用时可以省略默认参数
默认参数不要使用可变对象（如列表、字典）

Python
# ❌ 常见陷阱
def append_to(item, lst=[]):
    lst.append(item)
    return lst

# ✅ 正确写法
def append_to(item, lst=None):
    if lst is None:
        lst = []
    lst.append(item)
    return lst

📌 记忆要点

默认参数在定义时赋值，调用时可省略
默认参数不要用可变对象（重要陷阱！）

第 17 题¶

for i in range(1, 10, 3): 中，i 依次取值为（）。

选项	内容
A	1, 2, 3
B	1, 4, 7 ✅
C	1, 4, 7, 10
D	3, 6, 9

答案

B

📖 解析：

range(1, 10, 3)：起始=1，终止=10（不包含），步长=3
取值过程：1, 1+3=4, 4+3=7, 7+3=10（超出，停止）
所以 i 依次取值：1, 4, 7

Python
range(1, 10, 3)  # 1, 4, 7
range(0, 10, 2)  # 0, 2, 4, 6, 8
range(10, 0, -1) # 10, 9, 8, ..., 1（递减）
range(5)         # 0, 1, 2, 3, 4（默认起始0，步长1）

🔑 知识点：range() 函数

用法	含义	示例
`range(n)`	0 到 n-1	`range(5)` → 0,1,2,3,4
`range(a, b)`	a 到 b-1	`range(2, 6)` → 2,3,4,5
`range(a, b, step)`	a 到 b-1，步长 step	`range(1, 10, 3)` → 1,4,7

📌 记忆要点

range(start, stop, step) 左闭右开，不含 stop
步长为负数时可递减

第 18 题¶

下列关于break和continue的说法，正确的是（）。

选项	内容
A	break只跳过当前这一次循环
B	continue跳出整个循环
C	break跳出整个循环 ✅
D	break和continue功能相同

答案

C

📖 解析：

A 错误：break 跳出整个循环，不是跳过一次
B 错误：continue 跳过本次循环的剩余语句，继续下一次，不是跳出整个循环
C 正确：break 立即终止整个循环，执行循环后的语句
D 错误：两者功能完全不同

Python
# break 示例
for i in range(5):
    if i == 3:
        break    # 遇到3就终止整个循环
    print(i)     # 输出: 0 1 2

# continue 示例
for i in range(5):
    if i == 3:
        continue  # 跳过3，继续下一次
    print(i)      # 输出: 0 1 2 4

🔑 知识点：break vs continue

语句	作用	影响
`break`	终止整个循环	跳出循环体
`continue`	跳过本次剩余语句	进入下一次循环

📌 记忆要点

break 终止整个循环，continue 跳过当次
两者只影响最内层循环

第 19 题¶

尝试访问列表中不存在的索引时，会抛出（）异常。

选项	内容
A	ValueError
B	KeyError
C	IndexError ✅
D	TypeError

答案

C

📖 解析：

A 错误：ValueError 是值不合法，如 int("abc")
B 错误：KeyError 是字典键不存在
C 正确：IndexError 是索引越界
D 错误：TypeError 是类型不兼容的操作

Python
lst = [1, 2, 3]
lst[5]       # ❌ IndexError: list index out of range

d = {'a': 1}
d['b']       # ❌ KeyError: 'b'

int("abc")   # ❌ ValueError: invalid literal

"1" + 1      # ❌ TypeError: can only concatenate str to str

🔑 知识点：常见异常类型

异常类型	触发场景
`IndexError`	索引越界
`KeyError`	字典键不存在
`ValueError`	值不合法
`TypeError`	类型不兼容
`NameError`	变量未定义
`FileNotFoundError`	文件不存在

📌 记忆要点

索引越界 → IndexError，字典键不存在 → KeyError

第 20 题¶

要从列表 [10, 20, 30, 40, 50] 中随机选取2个不重复的元素，应使用（）。

选项	内容
A	random.choice()
B	random.sample() ✅
C	random.shuffle()
D	random.randint()

答案

B

📖 解析：

A 错误：random.choice() 只能随机选1个元素
B 正确：random.sample(seq, k) 随机选取 k 个不重复元素
C 错误：random.shuffle() 是打乱列表顺序，不选取
D 错误：random.randint(a, b) 生成随机整数，不用于选取

Python
import random
lst = [10, 20, 30, 40, 50]

random.sample(lst, 2)    # [20, 50]（示例，随机2个不重复）
random.choice(lst)        # 30（随机1个）
random.shuffle(lst)       # 原地打乱 lst
random.randint(1, 10)     # 7（1到10的随机整数）

🔑 知识点：random 模块常用函数

函数	功能	返回
`choice(seq)`	随机选1个	单个元素
`sample(seq, k)`	随机选k个不重复	列表
`shuffle(list)`	原地打乱	None
`randint(a, b)`	随机整数[a,b]	整数
`random()`	[0,1)浮点数	浮点数

📌 记忆要点

选多个不重复 → sample()，选1个 → choice()

第 21 题¶

下列程序执行后，输出结果是（）。

Python
x = "hello"
x[0] = "H"
print(x)

选项	内容
A	Hello
B	hello
C	报错 ✅
D	HELLO

答案

C

📖 解析：

字符串是不可变类型，不能通过索引修改其中的字符
x[0] = "H" 会抛出 TypeError: 'str' object does not support item assignment
要修改字符串，必须创建新字符串：

Python
# 方法1：切片拼接
x = "hello"
x = "H" + x[1:]   # "Hello"

# 方法2：replace
x = "hello".replace("h", "H")  # "Hello"

# 方法3：先转列表再转回
x = list("hello")
x[0] = "H"
x = "".join(x)    # "Hello"

🔑 知识点：字符串不可变性

字符串是不可变对象，不能原地修改
列表是可变对象，可以通过索引修改

📌 记忆要点

字符串不可变，x[0] = "H" 会报 TypeError
修改字符串需创建新字符串（切片、replace等）

第 22 题¶

下列值中，在布尔上下文中为False的是（）。

选项	内容
A	"0"
B	[0]
C	{0:0}
D	0.0 ✅

答案

D

📖 解析：

A："0" 是非空字符串 → True（字符串内容不影响，只要非空）
B：[0] 是非空列表 → True（列表内含元素即为真）
C：{0:0} 是非空字典 → True（字典含键值对即为真）
D：0.0 是零值 → False

Python
bool("0")    # True（非空字符串）
bool([0])    # True（非空列表）
bool({0:0})  # True（非空字典）
bool(0.0)    # False（零值）
bool("")     # False（空字符串）
bool([])     # False（空列表）
bool({})     # False（空字典）

🔑 知识点：Python 假值（Falsy Values）

以下值在布尔上下文中为 False：

值	说明
`None`	空值
`False`	布尔假
`0`, `0.0`	零
`""`	空字符串
`[]`	空列表
`()`	空元组
`{}`	空字典
`set()`	空集合

📌 记忆要点

零值（0, 0.0）和空容器都是 Falsy
非空容器即使内容为假值（如 [0]、"0"）也是 Truthy

第 23 题¶

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

选项	内容
A	input()返回值的类型取决于用户输入
B	input()可以接收整数输入
C	input()始终返回字符串类型 ✅
D	input()和print()功能相同

答案

C

📖 解析：

A 错误：无论用户输入什么，input() 始终返回字符串
B 错误：input() 返回字符串，需要手动转换才能得到整数
C 正确：Python 3 中 input() 始终返回 str 类型
D 错误：input() 是输入，print() 是输出，功能完全不同

Python
# Python 3 中 input() 始终返回字符串
x = input("输入: ")   # 输入 123
type(x)               # <class 'str'>

# 需要手动转换
n = int(input("输入数字: "))    # 转为整数
f = float(input("输入小数: "))  # 转为浮点数

🔑 知识点：input() 函数

Python 3：input() 始终返回字符串
Python 2：input() 会按表达式求值，raw_input() 返回字符串
需要数值时必须手动类型转换

📌 记忆要点

Python 3 的 input() → 永远返回 str
需要数值时用 int()、float() 转换

第 24 题¶

以下文件打开模式中，用于追加写入的是（）。

选项	内容
A	'r'
B	'w'
C	'a' ✅
D	'x'

答案

C

📖 解析：

A：'r' 只读模式，文件必须存在
B：'w' 写入模式，覆盖已有内容（文件不存在则创建）
C：'a' 追加模式，在文件末尾追加内容（文件不存在则创建）
D：'x' 独占创建模式，文件已存在则报错

Python
# 'r' - 只读
f = open("a.txt", "r")

# 'w' - 覆盖写入（原内容丢失！）
f = open("a.txt", "w")

# 'a' - 追加写入（在末尾添加）
f = open("a.txt", "a")

# 'r+' - 读写
f = open("a.txt", "r+")

🔑 知识点：文件打开模式

模式	含义	文件存在时	文件不存在时
`'r'`	只读	读取	报错
`'w'`	写入	覆盖	创建
`'a'`	追加	末尾追加	创建
`'r+'`	读写	读写	报错
`'x'`	独占创建	报错	创建

📌 记忆要点

'r' 只读，'w' 覆盖，'a' 追加
'w' 会清空原文件内容，慎用！

✅ 二、判断题¶

第1题 ✅ 对¶

题目： Python中列表和字符串都支持切片操作。

答案

✔ 对

解析：

列表和字符串都是序列类型，都支持切片
切片语法：seq[start:stop:step]

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

s = "hello"
s[1:4]    # "ell"

知识点范围： 序列类型的通用操作

📖 拓展

所有序列类型（列表、字符串、元组）都支持：索引、切片、+ 拼接、* 重复、in 成员判断、len() 长度

记忆要点： 列表、字符串、元组都是序列，支持切片

第2题 ❌ 错¶

题目： Python中字典的键和值都必须是字符串类型。

答案

✘ 错

解析：

字典的键必须是不可变（hashable）类型，不限于字符串
字典的值可以是任意类型

Python
# 键可以是 int、tuple、str 等
d = {1: "一", "two": 2, (3, 4): "元组键"}

# 键不能是可变类型
d = {[1, 2]: "值"}  # ❌ TypeError: unhashable type: 'list'

# 值可以是任意类型
d = {"a": [1, 2], "b": {"x": 1}, "c": lambda x: x+1}

知识点范围： 字典键值类型约束

记忆要点： 键 → 不可变类型（int/str/tuple等），值 → 任意类型

第3题 ✅ 对¶

题目： 在Python中，if、elif、else后面的代码块必须缩进。

答案

✔ 对

解析：

Python 使用缩进来标识代码块，而非大括号
if、elif、else 后面的代码块必须缩进（通常4个空格）
缩进不一致会导致 IndentationError

Python
# ✅ 正确缩进
if True:
    print("缩进正确")

# ❌ 缺少缩进
if True:
print("缺少缩进")  # IndentationError

知识点范围： Python 缩进规则

记忆要点： Python 用缩进表示代码块，必须缩进

第4题 ❌ 错¶

题目： for循环只能用于遍历列表，不能遍历字符串和元组。

答案

✘ 错

解析：

for 循环可以遍历任何可迭代对象
包括：列表、字符串、元组、字典、集合、range 等

Python
# 遍历字符串
for ch in "hello":
    print(ch)

# 遍历元组
for item in (1, 2, 3):
    print(item)

# 遍历字典（遍历的是键）
for key in {'a': 1, 'b': 2}:
    print(key)

# 遍历 range
for i in range(5):
    print(i)

知识点范围： for 循环与可迭代对象

记忆要点： for 可遍历所有可迭代对象，不限于列表

第5题 ✅ 对¶

题目： Python中，0、0.0、""、[]、None在布尔上下文中都等价于False。

答案

✔ 对

解析：

以下值都是 Falsy（布尔值为 False）：

值	类型
`0`	整数零
`0.0`	浮点零
`""`	空字符串
`[]`	空列表
`None`	空值

Python
bool(0)     # False
bool(0.0)   # False
bool("")    # False
bool([])    # False
bool(None)  # False

知识点范围： Python Falsy 值

📖 拓展

其他 Falsy 值：(), {}, set(), False

记忆要点： 零值和空容器都是 Falsy

第6题 ❌ 错¶

题目： 在函数内部修改全局变量时，不需要使用global关键字声明。

答案

✘ 错

解析：

在函数内部读取全局变量不需要 global 声明
但修改（赋值）全局变量必须使用 global 声明，否则会创建同名局部变量

Python
count = 0

def increment():
    count += 1    # ❌ UnboundLocalError

def increment_correct():
    global count
    count += 1    # ✅ 正确修改全局变量

知识点范围： global 关键字与变量作用域

📖 拓展

Python
x = 10

def read_global():
    print(x)      # ✅ 读取全局变量，无需 global

def modify_global():
    global x
    x = 20        # ✅ 修改全局变量，需要 global

def local_variable():
    x = 30        # ✅ 这是局部变量，不影响全局 x
    print(x)

记忆要点： 读取全局变量不用 global，修改全局变量必须用 global

第7题 ✅ 对¶

题目： Python中，字符串的split()方法如果不指定参数，默认按空白字符分割。

答案

✔ 对

解析：

split() 不传参数时，按任意空白字符（空格、制表符、换行等）分割
连续的空白字符视为一个分隔符
会自动去除首尾空白

Python
"a  b\tc\nd".split()    # ['a', 'b', 'c', 'd']
"a,b,c".split(",")      # ['a', 'b', 'c']（指定分隔符）
"a  b  c".split(" ")    # ['a', '', 'b', '', 'c']（按单个空格，有空串）

知识点范围： split() 方法

📖 拓展

split() 与 split(" ") 的区别 — 前者按任意连续空白分割，后者严格按单个空格分割

记忆要点： 不传参时按任意空白分割，自动处理连续空白

第8题 ❌ 错¶

题目： set（集合）中的元素是有序的，可以通过索引访问。

答案

✘ 错

解析：

集合是无序的，元素没有固定位置
不能通过索引访问：s[0] 会报 TypeError
集合的主要用途：去重、成员判断、集合运算

Python
s = {3, 1, 2}
s[0]         # ❌ TypeError: 'set' object is not subscriptable

# 集合的正确用法
1 in s       # True（成员判断，O(1)）
s.add(4)     # 添加元素
s.remove(1)  # 删除元素

# 集合运算
{1,2,3} & {2,3,4}  # {2,3} 交集
{1,2,3} | {2,3,4}  # {1,2,3,4} 并集
{1,2,3} - {2,3,4}  # {1} 差集

知识点范围： 集合（set）特性

记忆要点： 集合无序、无索引、去重、支持集合运算

第9题 ✅ 对¶

题目： while循环的循环次数在编写程序时不需要预先确定。

答案

✔ 对

解析：

while 循环根据条件决定是否继续，循环次数可以在运行时确定
典型场景：用户输入循环、网络请求重试、游戏主循环

Python
# 循环次数不确定
while True:
    cmd = input("输入命令(q退出): ")
    if cmd == 'q':
        break

for 循环通常用于遍历已知长度的序列
while 循环更适合循环次数不确定的情况

知识点范围： while vs for

记忆要点： while 适合次数不确定的循环，for 适合遍历已知序列

第10题 ❌ 错¶

题目： Python中，==和is的作用完全相同。

答案

✘ 错

解析：

== 比较两个对象的值是否相等
is 比较两个对象是否是同一个对象（内存地址是否相同）

Python
a = [1, 2, 3]
b = [1, 2, 3]

a == b    # True（值相等）
a is b    # False（不同对象，内存地址不同）

c = a
a is c    # True（同一个对象）

# 小整数池
x = 256
y = 256
x is y    # True（小整数缓存）

x = 257
y = 257
x is y    # False（超出缓存范围）

知识点范围： == vs is

运算符	比较内容	示例
`==`	值相等	`[1,2] == [1,2]` → True
`is`	同一对象	`[1,2] is [1,2]` → False

记忆要点： == 比较值，is 比较身份（内存地址）

第11题 ✅ 对¶

题目： for...else结构中，当循环正常结束（未被break中断）时，else块会执行。

答案

✔ 对

解析：

for...else 中，else 在循环正常结束时执行
如果循环被 break 中断，else 不执行

Python
# 正常结束 → else 执行
for i in range(5):
    if i == 10:
        break
else:
    print("循环正常结束")   # ✅ 会执行

# 被break中断 → else不执行
for i in range(5):
    if i == 3:
        break
else:
    print("循环正常结束")   # ❌ 不会执行

知识点范围： for...else 结构

📖 拓展

while...else 规则相同

记忆要点： else 在循环未被 break 时执行

第12题 ❌ 错¶

题目： 使用list.append()方法可以向列表指定位置插入元素。

答案

✘ 错

解析：

append() 只能在列表末尾添加元素
在指定位置插入元素应使用 insert() 方法

Python
lst = [1, 2, 3]

lst.append(4)       # [1, 2, 3, 4]（末尾添加）
lst.insert(0, 0)    # [0, 1, 2, 3, 4]（在索引0处插入）
lst.insert(2, 99)   # [0, 1, 99, 2, 3, 4]（在索引2处插入）

知识点范围： 列表添加元素的方法**

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

记忆要点： append() 末尾添加，insert() 指定位置插入

第13题 ✅ 对¶

题目： Python中，del关键字可以删除列表中的元素，也可以删除变量。

答案

✔ 对

解析：

del 可以删除列表元素（按索引）
del 也可以删除变量

Python
# 删除列表元素
lst = [1, 2, 3, 4, 5]
del lst[2]       # [1, 2, 4, 5]
del lst[1:3]     # [1, 5]

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

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

知识点范围： del 关键字

📖 拓展

del 与列表的 remove()、pop() 的区别

方法	功能	示例
`del lst[i]`	按索引删除	`del lst[0]`
`lst.remove(x)`	按值删除第一个	`lst.remove(3)`
`lst.pop(i)`	按索引删除并返回	`x = lst.pop(0)`

记忆要点： del 可删除列表元素、字典键、变量

第14题 ❌ 错¶

题目： 字符串方法strip()可以去除字符串中间的空白字符。

答案

✘ 错

解析：

strip() 只去除字符串两端的空白字符，不影响中间
如需去除中间空白，需要用 replace() 或其他方法

Python
"  hello  world  ".strip()      # "hello  world"（两端空白去除）
"  hello  world  ".lstrip()     # "hello  world  "（只去左端）
"  hello  world  ".rstrip()     # "  hello  world"（只去右端）

# 去除所有空白
"  hello  world  ".replace(" ", "")  # "helloworld"

知识点范围： strip() 方法**

方法	功能
`strip()`	去除两端空白
`lstrip()`	去除左端空白
`rstrip()`	去除右端空白
`replace(" ", "")`	去除所有空格

记忆要点： strip() 只去两端，不去中间

✏️ 三、程序填空题¶

第1题：计算1~100所有偶数的和¶

题目： 计算1到100中所有偶数的和，并输出结果。

原始代码（含填空）：

Python
total = 0
i = 1
#**********begin1**********
_______
#**********end1**********
    if i % 2 == 0:
        #**********begin2**********
        _______
        #**********end2**********
    #**********begin3**********
    _______
    #**********end3**********
print("1到100所有偶数的和为:", total)

✅ 填空答案

begin1： while i <= 100:
begin2： total += i（或 total = total + i）
begin3： i += 1（或 i = i + 1）

完整正确代码

Python
# 计算1~100所有偶数的和
# 思路：遍历1到100，判断是否为偶数，累加偶数
total = 0       # 累加器，初始为0
i = 1           # 计数器，从1开始

while i <= 100:            # 【填空1】循环条件：i从1到100
    if i % 2 == 0:         # 判断是否为偶数
        total += i         # 【填空2】累加偶数
    i += 1                 # 【填空3】计数器+1，避免死循环

print("1到100所有偶数的和为:", total)   # 输出: 1到100所有偶数的和为: 2550

运行结果： 1到100所有偶数的和为: 2550

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

while循环、条件判断、累加

📖 拓展

Python
# 方法2：for循环
total = 0
for i in range(1, 101):
    if i % 2 == 0:
        total += i
print("1到100所有偶数的和为:", total)

# 方法3：range步长
total = sum(range(2, 101, 2))  # 2,4,6,...,100
print("1到100所有偶数的和为:", total)

# 方法4：数学公式
# 2+4+6+...+100 = 2*(1+2+3+...+50) = 2*50*51/2 = 2550
n = 50
total = 2 * n * (n + 1) // 2
print("1到100所有偶数的和为:", total)

📌 记忆要点

累加器初始为 0，累乘器初始为 1
i % 2 == 0 判断偶数，i % 2 != 0 判断奇数
while 循环别忘了计数器 +1

第2题：判断奇偶函数¶

题目： 编写函数判断一个整数是偶数还是奇数，并在主程序中调用。

原始代码（含填空）：

Python
def is_even(n):
    #**********begin1**********
    _______
    #**********end1**********
        return True
    else:
        return False

num = int(input("请输入一个整数:"))
#**********begin2**********
_______
#**********end2**********
if result:
    print(num, "是偶数")
else:
    print(num, "是奇数")

✅ 填空答案

begin1： if n % 2 == 0:
begin2： result = is_even(num)

完整正确代码

Python
# 判断奇偶的函数
def is_even(n):
    if n % 2 == 0:         # 【填空1】判断是否为偶数
        return True
    else:
        return False

num = int(input("请输入一个整数:"))
result = is_even(num)       # 【填空2】调用函数，保存返回值

if result:
    print(num, "是偶数")
else:
    print(num, "是奇数")

运行示例： 输入 6 → 输出 6 是偶数

🔑 知识点：函数定义与调用、return语句、取余运算

函数定义与调用、return语句、取余运算

📖 拓展

Python
# 方法2：简化版
def is_even(n):
    return n % 2 == 0   # 直接返回布尔值

# 方法3：三元表达式输出
num = int(input("请输入一个整数:"))
print(num, "是偶数" if num % 2 == 0 else "是奇数")

# 方法4：位运算判断（偶数最低位为0）
def is_even(n):
    return (n & 1) == 0

📌 记忆要点

def 函数名(参数): 定义函数
return 返回值，没有 return 则返回 None
调用：结果 = 函数名(实参)

第3题：列表排序与切片¶

题目： 将成绩列表升序排序，并输出最高3个成绩。

原始代码（含填空）：

Python
scores = [85, 92, 78, 90, 66, 88, 73]
#**********begin1**********
_______
#**********end1**********
print("升序排列:", scores)
#**********begin2**********
print("最高3个成绩:", _______)
#**********end2**********

✅ 填空答案

begin1： scores.sort()
begin2： scores[-3:]

完整正确代码

Python
# 列表排序与切片
scores = [85, 92, 78, 90, 66, 88, 73]

scores.sort()                    # 【填空1】升序排序
print("升序排列:", scores)        # [66, 73, 78, 85, 88, 90, 92]

print("最高3个成绩:", scores[-3:])  # 【填空2】取最后3个（最大的3个）
                                  # [88, 90, 92]

运行结果：

Python
升序排列: [66, 73, 78, 85, 88, 90, 92]
最高3个成绩: [88, 90, 92]

🔑 知识点：列表排序、负索引切片

列表排序、负索引切片

📖 拓展

Python
# sort() vs sorted()
lst = [3, 1, 2]
lst.sort()           # 原地排序，返回 None
new_lst = sorted(lst) # 返回新列表，原列表不变

# 降序排序
lst.sort(reverse=True)

# 取最大3个（不排序）
import heapq
top3 = heapq.nlargest(3, scores)  # [92, 90, 88]

📌 记忆要点

sort() 原地排序，sorted() 返回新列表
scores[-3:] 取最后3个元素
列表索引从 0 开始，负索引从 -1 开始

🔧 四、程序改错题¶

第1题：水仙花数判断¶

题目： 判断用户输入的三位数是否为水仙花数。水仙花数是指一个三位数，其各位数字的立方和等于该数本身，如153 = 1³+5³+3³。

原始代码（含错误）：

Python
num = int(input("请输入一个三位数:"))
#**********begin1**********
bai = num / 100
#**********end1**********
shi = num // 10 % 10
ge = num % 10
#**********begin2**********
if bai ** 3 + shi ** 3 + ge ** 3 = num:
#**********end2**********
    print(num, "是水仙花数")
#**********begin3**********
else
#**********end3**********
    print(num, "不是水仙花数")

✅ 错误修正

错误位置	原代码	修正后	错误原因
begin1	`num / 100`	`num // 100`	`/` 是浮点除法，`//` 才是整除
begin2	`= num`	`== num`	`=` 是赋值，`==` 才是比较
begin3	`else`	`else:`	else后缺少冒号

完整正确代码

Python
# 水仙花数判断
# 思路：分解百位、十位、个位，判断立方和是否等于原数
num = int(input("请输入一个三位数:"))

bai = num // 100            # ✅ 修正1：整除取百位
shi = num // 10 % 10        # 整除10再取余10 → 十位
ge = num % 10               # 取余10 → 个位

if bai ** 3 + shi ** 3 + ge ** 3 == num:  # ✅ 修正2：== 比较
    print(num, "是水仙花数")
else:                       # ✅ 修正3：加冒号
    print(num, "不是水仙花数")

运行示例：

Python
输入: 153
153 是水仙花数

输入: 123
123 不是水仙花数

🔑 知识点：整除运算、比较运算符、分支语法

整除运算、比较运算符、分支语法

📌 记忆要点

/ 浮点除 vs // 整除，取各位数字要用 //
= 赋值 vs == 比较（最常见的笔误）
else: 冒号不能忘

第2题：列表求平均值¶

题目： 计算列表中所有元素的平均值并输出。

原始代码（含错误）：

Python
lst = [85, 92, 78, 90, 66]
total = 0
#**********begin1**********
for i in range(lst):
#**********end1**********
    total = total + lst[i]
#**********begin2**********
avg = total % len(lst)
#**********end2**********
#**********begin3**********
print("平均值为:" + avg)
#**********end3**********

✅ 错误修正

错误位置	原代码	修正后	错误原因
begin1	`range(lst)`	`range(len(lst))`	`range()` 需要整数参数，不能直接传列表
begin2	`total % len(lst)`	`total / len(lst)`	`%` 是取余，`/` 才是除法
begin3	`"平均值为:" + avg`	`"平均值为:", avg` 或 `"平均值为:" + str(avg)`	字符串与数字不能直接用 `+` 拼接

完整正确代码

Python
# 计算列表平均值
lst = [85, 92, 78, 90, 66]
total = 0

for i in range(len(lst)):       # ✅ 修正1：len(lst) 获取列表长度
    total = total + lst[i]

avg = total / len(lst)           # ✅ 修正2：/ 除法，不是 % 取余
print("平均值为:", avg)           # ✅ 修正3：用逗号分隔，自动转换类型

运行结果： 平均值为: 82.2

🔑 知识点：range()与len()、算术运算符、字符串与数字拼接

range()与len()、算术运算符、字符串与数字拼接

📌 记忆要点

range(len(lst)) 遍历列表索引
% 取余 vs / 除法，别混淆
字符串与数字拼接用 , 或 str() 转换

第3题：字符串统计¶

题目： 统计字符串中字母和数字的个数。

原始代码（含错误）：

Python
s = input("请输入字符串:")
letter = 0
digit = 0
#**********begin1**********
for ch in s
#**********end1**********
    #**********begin2**********
    if ch.isalpha():
        letter += 1
    elif ch.isdigit
        digit += 1
    #**********end2**********
#**********begin3**********
print("字母:", letter, "数字:", digit
#**********end3**********

✅ 错误修正

错误位置	原代码	修正后	错误原因
begin1	`for ch in s`	`for ch in s:`	for循环末尾缺少冒号
begin2	`elif ch.isdigit`	`elif ch.isdigit():`	方法调用缺少括号
begin3	`print("字母:", letter, "数字:", digit`	`print("字母:", letter, "数字:", digit)`	print缺少右括号

完整正确代码

Python
# 统计字符串中字母和数字的个数
s = input("请输入字符串:")
letter = 0
digit = 0

for ch in s:                     # ✅ 修正1：加冒号
    if ch.isalpha():
        letter += 1
    elif ch.isdigit():            # ✅ 修正2：加括号
        digit += 1

print("字母:", letter, "数字:", digit)  # ✅ 修正3：加右括号

运行示例：

Python
输入: Hello123World
字母: 10 数字: 3

🔑 知识点：for循环语法、字符串方法、函数调用

for循环语法、字符串方法、函数调用

📌 记忆要点

for、if、elif、else 等语句末尾必须有冒号 :
方法调用必须带括号：isdigit() 不是 isdigit
括号必须成对出现

第4题：文件写入¶

题目： 将学生成绩列表写入文件。

原始代码（含错误）：

Python
scores = ["张三:85", "李四:92", "王五:78"]
#**********begin1**********
f = open("scores.txt", "r")
#**********end1**********
#**********begin2**********
for score in scores:
    f.writeline(score + "\n")
#**********end2**********
#**********begin3**********
f.close
#**********end3**********

✅ 错误修正

错误位置	原代码	修正后	错误原因
begin1	`"r"`	`"w"`	`"r"` 是只读模式，写入应用 `"w"`
begin2	`f.writeline()`	`f.write()`	文件对象没有 `writeline` 方法，应使用 `write`
begin3	`f.close`	`f.close()`	close 是方法，需要加括号调用

完整正确代码

Python
# 将学生成绩写入文件
scores = ["张三:85", "李四:92", "王五:78"]

f = open("scores.txt", "w")       # ✅ 修正1：写入模式 "w"
for score in scores:
    f.write(score + "\n")          # ✅ 修正2：write() 方法
f.close()                          # ✅ 修正3：加括号调用

# 推荐写法：with 语句自动关闭文件
# with open("scores.txt", "w") as f:
#     for score in scores:
#         f.write(score + "\n")

🔑 知识点：文件操作、打开模式、文件方法

文件操作、打开模式、文件方法

📖 拓展

文件打开模式与方法：

模式	含义
`"r"`	只读
`"w"`	写入（覆盖）
`"a"`	追加

方法	功能
`f.write(s)`	写入字符串
`f.writelines(lst)`	写入字符串列表
`f.read()`	读取全部
`f.readline()`	读取一行
`f.readlines()`	读取所有行到列表

📌 记忆要点

读文件 → "r"，写文件 → "w"，追加 → "a"
write() 写入字符串，writelines() 写入列表
方法调用必须加括号：close() 不是 close
推荐使用 with 语句自动管理文件

💻 五、程序设计题¶

第1题：打印数字三角形¶

题目： 编写程序，打印如下数字三角形：

方法1：基础for循环（推荐，最直观）

Python
def main():
    for i in range(1, 6):
        for j in range(1, i + 1):
            print(j, end=" ")
        print()

main()

方法2：while循环

Python
def main():
    i = 1
    while i <= 5:
        j = 1
        while j <= i:
            print(j, end=" ")
            j += 1
        print()
        i += 1

main()

方法3：列表推导式 + join（更Pythonic）

Python
def main():
    for i in range(1, 6):
        line = " ".join(str(j) for j in range(1, i + 1))
        print(line)

main()

🔑 知识点：嵌套循环、print控制输出、字符串拼接

嵌套循环、print控制输出、字符串拼接

📖 拓展

Python
# 倒数字三角形
# 5 4 3 2 1
# 4 3 2 1
# 3 2 1
# 2 1
# 1
for i in range(5, 0, -1):
    for j in range(i, 0, -1):
        print(j, end=" ")
    print()

📌 记忆要点

外层循环控制行数，内层循环控制每行内容
print(..., end=" ") 不换行输出
print() 单独换行

第2题：计算1到100中所有3的倍数的和¶

题目： 计算1到100中所有3的倍数的和，格式化输出：1到100中3的倍数的和为:1683

方法1：for循环 + 条件判断

Python
def main():
    total = 0
    for i in range(1, 101):
        if i % 3 == 0:       # 判断是否为3的倍数
            total += i
    print("1到100中3的倍数的和为:%d" % total)

main()

方法2：while循环

Python
def main():
    total = 0
    i = 1
    while i <= 100:
        if i % 3 == 0:
            total += i
        i += 1
    print("1到100中3的倍数的和为:%d" % total)

main()

方法3：range步长（最高效）

Python
# range(3, 101, 3) 直接生成3的倍数序列
def main():
    total = sum(range(3, 101, 3))
    print("1到100中3的倍数的和为:%d" % total)

main()
# 验证：3+6+9+...+99 = 3*(1+2+3+...+33) = 3*33*34/2 = 1683

方法4：数学公式

Python
# 等差数列求和：S = n*(首项+末项)/2
# 首项=3, 末项=99, 项数=33
def main():
    total = 33 * (3 + 99) // 2
    print("1到100中3的倍数的和为:%d" % total)

main()

运行结果： 1到100中3的倍数的和为:1683

🔑 知识点：循环、条件判断、range步长、等差数列

循环、条件判断、range步长、等差数列

📌 记忆要点

range(start, stop, step) 可指定步长
range(3, 101, 3) 直接生成 3 的倍数序列
等差数列求和：n * (首项 + 末项) / 2
判断倍数：i % n == 0