Python 模拟考试 4 — 解析

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

第1题¶

Python中，以下哪个不是合法的标识符？（）

选项	内容
A	`_private`
B	`MAX_SIZE`
C	`for` ✅
D	`student1`

答案

C

📖 解析：

A 合法：下划线开头的标识符合法，常用于表示私有变量
B 合法：全大写加下划线的标识符合法，常用于表示常量
C 不合法：for 是 Python 关键字，不能用作标识符
D 合法：字母开头，包含字母和数字，完全合法

Python
_private = 1    # ✅ 合法
MAX_SIZE = 100  # ✅ 合法
for = 10        # ❌ SyntaxError: invalid syntax
student1 = "Tom" # ✅ 合法

🔑 知识点：Python标识符规则

标识符只能包含字母、数字和下划线 _
标识符不能以数字开头
标识符不能是 Python 关键字（如 if、for、while、class 等）
标识符区分大小写

📌 记忆要点

关键字不能当标识符，数字不能开头。可用 keyword.kwlist 查看所有关键字。

第2题¶

表达式 5 % 2 + 5 // 2 的结果是（）。

选项	内容
A	3
B	3.0
C	4
D	4.0

答案

C

📖 解析：

5 % 2 = 1（取余：5除以2余1）
5 // 2 = 2（整除：5除以2商2）
1 + 2 = 3

Python
% 2    # 1（取余）
// 2   # 2（整除，向下取整）
% 2 + 5 // 2  # 1 + 2 = 3

🔑 知识点：算术运算符优先级与整除取余

运算符	含义	示例
`%`	取余	`5 % 2 = 1`
`//`	整除（地板除）	`5 // 2 = 2`
`/`	浮点除	`5 / 2 = 2.5`

注意：% 和 // 优先级相同，从左到右计算，但此题中两者独立运算后再相加。

📌 记忆要点

% 取余得余数，// 整除得商。两者都是整数运算时结果为整数。

第3题¶

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

选项	内容
A	字符串是不可变类型
B	字符串可以用单引号或双引号定义
C	字符串支持索引和切片操作
D	字符串可以直接通过索引修改字符 ✅

答案

D

📖 解析：

A 正确：字符串是不可变（immutable）类型，创建后不能修改
B 正确：单引号 'hello' 和双引号 "hello" 完全等价
C 正确：字符串支持索引 s[0] 和切片 s[1:3]
D 错误：字符串不可变，s[0] = 'H' 会抛出 TypeError

Python
s = "hello"
s[0] = "H"  # ❌ TypeError: 'str' object does not support item assignment

# 修改字符串需创建新字符串
s = "H" + s[1:]        # "Hello"
s = s.replace("h", "H") # "Hello"

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

字符串是不可变类型，所有"修改"操作都创建新字符串
列表是可变类型，可以通过索引修改：lst[0] = 10 ✅
元组也是不可变类型，不能通过索引修改

📌 记忆要点

字符串不可变！s[0] = 'H' 会报 TypeError。修改字符串需用切片拼接或 replace()。

第4题¶

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

Python
a = [1, 2, 3]
b = a
b[0] = 10
print(a[0])

选项	内容
A	1
B	10 ✅
C	报错
D	不确定

答案

B

📖 解析：

b = a 是引用赋值，b 和 a 指向同一个列表对象
b[0] = 10 修改的是这个共享对象，a 也受影响
因此 a[0] 变为 10

Python
a = [1, 2, 3]
b = a          # b 和 a 指向同一个对象
b[0] = 10      # 修改共享对象
print(a[0])    # 10（a 也被修改了）

# 如果想要独立副本：
c = a.copy()   # 或 c = a[:]
c[0] = 99
print(a[0])    # 仍然是 10（a 不受影响）

🔑 知识点：引用与拷贝

操作	类型	修改是否互相影响
`b = a`	引用赋值	✅ 影响
`b = a.copy()`	浅拷贝	❌ 不影响
`b = a[:]`	浅拷贝	❌ 不影响
`b = copy.deepcopy(a)`	深拷贝	❌ 不影响（含嵌套）

📌 记忆要点

b = a 是引用，不是拷贝！修改 b 会影响 a。用 a.copy() 或 a[:] 创建独立副本。

第5题¶

表达式 "Python"[-1] 的结果是（）。

选项	内容
A	"P"
B	"n" ✅
C	"o"
D	报错

答案

B

📖 解析：

负数索引从字符串末尾开始计数
-1 表示最后一个字符，-2 表示倒数第二个

Python
s = "Python"
# 正索引:  P(0)  y(1)  t(2)  h(3)  o(4)  n(5)
# 负索引: P(-6) y(-5) t(-4) h(-3) o(-2) n(-1)

s[-1]   # "n"（最后一个字符）
s[-2]   # "o"（倒数第二个）
s[-6]   # "P"（第一个字符）

🔑 知识点：负数索引

负数索引从 -1 开始，表示最后一个元素
s[-1] 等价于 s[len(s)-1]
列表、元组、字符串都支持负数索引

📌 记忆要点

-1 是最后一个元素，-2 是倒数第二个。正索引从 0 开始，负索引从 -1 开始。

第6题¶

下列哪个不是Python的内置函数？（）

选项	内容
A	`len()`
B	`print()`
C	`add()` ✅
D	`type()`

答案

C

📖 解析：

A：len() 是内置函数，返回对象长度
B：print() 是内置函数，输出内容
C：add() 不是内置函数，它是集合（set）的方法，如 s.add(1)
D：type() 是内置函数，返回对象类型

Python
len([1, 2, 3])   # 3 ✅ 内置函数
print("hello")    # hello ✅ 内置函数
type(42)          # <class 'int'> ✅ 内置函数

add(1, 2)         # ❌ NameError: name 'add' is not defined
s = {1, 2}
s.add(3)          # ✅ add是集合的方法，不是内置函数

🔑 知识点：内置函数 vs 方法

内置函数：可以直接调用，如 len()、print()、type()、input()、range() 等
方法：需要通过对象调用，如 list.append()、set.add()、str.upper()

📌 记忆要点

add() 是集合的方法，不是内置函数。内置函数直接调用，方法需要 对象.方法名() 调用。

第7题¶

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

选项	内容
A	实参和形参必须同名
B	函数调用时必须提供所有参数的值
C	Python支持默认参数和可变参数 ✅
D	函数只能返回一个值

答案

C

📖 解析：

A 错误：实参和形参不需要同名，按位置或关键字对应即可
B 错误：有默认值的参数可以省略，不必提供所有参数
C 正确：Python 支持默认参数 def f(a, b=1) 和可变参数 def f(*args, **kwargs)
D 错误：Python 函数可以返回多个值（本质是返回元组）

Python
# 默认参数
def greet(name, msg="你好"):
    print(msg, name)

greet("小明")          # 你好 小明（使用默认值）
greet("小明", "早上好") # 早上好 小明（覆盖默认值）

# 可变参数
def add(*args):
    return sum(args)

add(1, 2, 3)  # 6

# 返回多个值
def calc(a, b):
    return a + b, a - b  # 返回元组

s, d = calc(10, 3)  # s=13, d=7

🔑 知识点：函数参数类型

参数类型	语法	说明
位置参数	`def f(a, b)`	按位置传递
默认参数	`def f(a, b=1)`	可省略，使用默认值
可变位置参数	`def f(*args)`	收集多余位置参数为元组
可变关键字参数	`def f(**kwargs)`	收集多余关键字参数为字典

📌 记忆要点

Python 支持默认参数和可变参数。实参形参不需要同名，函数可以返回多个值。

第8题¶

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

Python
x = 10
def func():
    x = 20
    print(x, end=" ")
func()
print(x)

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

答案

B

📖 解析：

x = 10 是全局变量
func() 内部的 x = 20 创建了一个局部变量 x，不影响全局变量
func() 内部 print(x) 输出局部变量 x = 20
func() 外部 print(x) 输出全局变量 x = 10

Python
x = 10            # 全局变量

def func():
    x = 20        # 局部变量（与全局变量同名但不同）
    print(x, end=" ")  # 输出局部变量 20

func()            # 输出: 20
print(x)          # 输出: 10（全局变量未改变）

# 如果想修改全局变量：
def func2():
    global x
    x = 20        # 修改全局变量

🔑 知识点：局部变量与全局变量

函数内部的赋值操作创建局部变量，不会修改全局变量
要在函数内修改全局变量，必须使用 global 声明
函数内可以读取全局变量，但赋值会创建同名局部变量

📌 记忆要点

函数内赋值创建局部变量，不影响全局变量。修改全局变量需用 global 声明。

第9题¶

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

选项	内容
A	"ABC"
B	["ABC"]
C	['A', 'B', 'C'] ✅
D	报错

答案

C

📖 解析：

list() 函数将可迭代对象转换为列表
字符串是可迭代对象，每个字符成为列表的一个元素
list("ABC") → ['A', 'B', 'C']

Python
list("ABC")       # ['A', 'B', 'C']
list("hello")     # ['h', 'e', 'l', 'l', 'o']
list(range(3))    # [0, 1, 2]
list((1, 2, 3))   # [1, 2, 3]

# 反向操作：列表转字符串
"".join(['A', 'B', 'C'])  # "ABC"

🔑 知识点：list() 与类型转换

转换	示例	结果
字符串→列表	`list("abc")`	`['a', 'b', 'c']`
列表→字符串	`"".join(['a','b','c'])`	`"abc"`
元组→列表	`list((1,2,3))`	`[1, 2, 3]`
列表→元组	`tuple([1,2,3])`	`(1, 2, 3)`

📌 记忆要点

list("ABC") 将字符串拆分为字符列表 ['A', 'B', 'C']，反向操作用 "".join()。

第10题¶

下列关于Python文件操作的说法，错误的是（）。

选项	内容
A	`with`语句可以自动关闭文件
B	`read()`方法读取整个文件内容
C	`readline()`方法读取所有行 ✅
D	`"rb"`模式表示二进制读取

答案

C

📖 解析：

A 正确：with 语句是上下文管理器，退出时自动调用 close()
B 正确：read() 读取整个文件内容为一个字符串
C 错误：readline() 只读取一行，readlines() 才读取所有行
D 正确："rb" 表示二进制读取模式

Python
# readline() - 每次读取一行
with open("test.txt", "r") as f:
    line1 = f.readline()  # 读取第一行
    line2 = f.readline()  # 读取第二行

# readlines() - 读取所有行到列表
with open("test.txt", "r") as f:
    lines = f.readlines()  # 返回列表，每个元素是一行

# read() - 读取全部内容为一个字符串
with open("test.txt", "r") as f:
    content = f.read()     # 返回整个文件内容

🔑 知识点：文件读取方法

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

📌 记忆要点

readline() 读取一行，readlines() 读取所有行。with 语句自动关闭文件。

第11题¶

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

Python
lst = [3, 1, 4, 1, 5]
lst.sort(reverse=True)
print(lst)

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

答案

B

📖 解析：

sort() 是列表的原地排序方法，直接修改原列表
reverse=True 表示降序排列
[3, 1, 4, 1, 5] 降序排列 → [5, 4, 3, 1, 1]

Python
lst = [3, 1, 4, 1, 5]
lst.sort(reverse=True)
print(lst)  # [5, 4, 3, 1, 1]

# 升序（默认）
lst.sort()              # [1, 1, 3, 4, 5]
lst.sort(reverse=False) # [1, 1, 3, 4, 5]

# 注意：sort() 返回 None
result = lst.sort()     # result 是 None

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

方法	是否修改原列表	返回值
`lst.sort()`	✅ 原地修改	`None`
`sorted(lst)`	❌ 不修改	新列表

两者都支持 reverse 和 key 参数。

📌 记忆要点

sort(reverse=True) 降序排序。sort() 原地排序返回 None，sorted() 返回新列表。

第12题¶

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

选项	内容
A	6.0
B	6.33... ✅
C	6
D	5

答案

B

📖 解析：

10 / 3 = 3.333...（浮点除法，结果为浮点数）
10 // 3 = 3（整除，结果为整数）
3.333... + 3 = 6.333...

Python
/ 3      # 3.3333333333333335（浮点除法）
// 3     # 3（整除）
/ 3 + 10 // 3  # 3.333... + 3 = 6.333...

🔑 知识点：除法运算符

运算符	含义	结果类型	示例
`/`	浮点除法	float	`10 / 3` → 3.333...
`//`	整除（地板除）	int	`10 // 3` → 3
`%`	取余	int	`10 % 3` → 1

注意：浮点数参与运算时，结果为浮点数。3.333... + 3 → 6.333...

📌 记忆要点

/ 浮点除得浮点数，// 整除得整数。浮点数 + 整数 = 浮点数。

第13题¶

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

选项	内容
A	元组使用圆括号定义
B	元组是不可变序列
C	单个元素的元组写作 `(1,)`
D	元组不支持索引访问 ✅

答案

D

📖 解析：

A 正确：元组用圆括号 () 定义，如 (1, 2, 3)
B 正确：元组是不可变序列，创建后不能修改元素
C 正确：单元素元组必须加逗号 (1,)，否则 (1) 只是整数 1
D 错误：元组支持索引访问，如 t[0]、t[-1]，只是不支持索引赋值

Python
t = (1, 2, 3, 4, 5)

# 元组支持索引访问
t[0]     # 1 ✅
t[-1]    # 5 ✅
t[1:3]   # (2, 3) ✅

# 元组不支持索引赋值
t[0] = 10  # ❌ TypeError: 'tuple' object does not support item assignment

# 单元素元组的陷阱
type((1))    # <class 'int'>（不是元组！）
type((1,))   # <class 'tuple'>（加逗号才是元组）

🔑 知识点：元组特性

特性	元组	列表
定义	`()`	`[]`
可变性	不可变	可变
索引访问	✅	✅
索引赋值	❌	✅
切片	✅	✅
可作为字典键	✅	❌

📌 记忆要点

元组支持索引访问，只是不支持索引修改。单元素元组必须加逗号 (1,)。

第14题¶

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

Python
s = "Python Programming"
print(s.find("thon"))

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

答案

A

📖 解析：

find() 方法返回子串第一次出现的起始索引，找不到返回 -1
"Python" 中各字符索引：P(0) y(1) t(2) h(3) o(4) n(5)
"thon" 从索引 2 开始匹配：t(2) h(3) o(4) n(5) ✅
因此 find("thon") 返回 2

Python
s = "Python Programming"
#  P  y  t  h  o  n     P  r  o  g  r  a  m  m  i  n  g
#  0  1  2  3  4  5  6  7  8  9  10 11 12 13 14 15 16 17

s.find("thon")     # 2（从索引2开始匹配）
s.find("Prog")     # 7
s.find("Java")     # -1（找不到）
s.find("n")        # 5（第一次出现的位置）

🔑 知识点：字符串查找方法

方法	找到时	找不到时
`find()`	返回起始索引	返回 -1
`index()`	返回起始索引	抛出 ValueError
`in`	True	False

find() 和 index() 的区别：找不到时行为不同。

📌 记忆要点

find() 找到返回起始索引，找不到返回 -1。index() 找到返回起始索引，找不到报错。

第15题¶

下列哪个表达式可以判断变量x是否为偶数？（）

选项	内容
A	`x / 2 == 0`
B	`x % 2 == 0` ✅
C	`x // 2 == 0`
D	`x ** 2 == 0`

答案

B

📖 解析：

A 错误：x / 2 == 0 是浮点除法，4/2=2.0≠0，判断偶数应取余而非除法
B 正确：x % 2 == 0 取余判断，偶数除以2余0
C 错误：x // 2 == 0 只有0和1才满足（如 3//2=1≠0, 2//2=1≠0）
D 错误：x ** 2 == 0 只有x为0才满足

Python
# 判断偶数的正确方法
x = 4
x % 2 == 0    # True ✅（4除以2余0）

# 错误方法
x / 2 == 0    # 4/2=2.0 ≠ 0，False ❌
x // 2 == 0   # 4//2=2 ≠ 0，False ❌
x ** 2 == 0   # 4**2=16 ≠ 0，False ❌

# 判断奇数
x % 2 != 0    # 或 x % 2 == 1

🔑 知识点：取余运算判断整除性

判断	表达式
偶数	`x % 2 == 0`
奇数	`x % 2 != 0`
3的倍数	`x % 3 == 0`
5的倍数	`x % 5 == 0`

📌 记忆要点

判断偶数用 x % 2 == 0，取余运算 % 是判断整除性的标准方法。

第16题¶

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

Python
def f(x, y=[]):
    y.append(x)
    return y
print(f(1))
print(f(2))

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

答案

B

📖 解析：

这是经典的可变默认参数陷阱
y=[] 在函数定义时只创建一次，之后每次调用共享同一个列表
f(1)：y = []，追加1 → 返回 [1]
f(2)：y = [1]（上次的列表），追加2 → 返回 [1, 2]

Python
def f(x, y=[]):    # 默认参数 y 在定义时创建一次
    y.append(x)
    return y

f(1)    # [1]      （y=[] → 追加1 → [1]）
f(2)    # [1, 2]   （y=[1] → 追加2 → [1, 2]）
f(3)    # [1, 2, 3]（y=[1,2] → 追加3 → [1, 2, 3]）

# 正确写法：使用 None 作为默认值
def f_correct(x, y=None):
    if y is None:
        y = []      # 每次调用都创建新列表
    y.append(x)
    return y

f_correct(1)  # [1]
f_correct(2)  # [2]（独立的列表）

🔑 知识点：可变默认参数陷阱

默认参数在函数定义时创建，不是每次调用时创建
可变对象（列表、字典、集合）作为默认参数会"记忆"上次的修改
正确做法：用 None 作为默认值，在函数体内创建新对象

📌 记忆要点

可变默认参数陷阱：列表、字典、集合作为默认参数会共享。用 y=None + if y is None: y = [] 代替。

第17题¶

表达式 "hello".capitalize() 的结果是（）。

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

答案

B

📖 解析：

capitalize() 将字符串的第一个字符大写，其余字符小写
"hello" → "Hello"
即使原字符串中间有大写，也会被小写化

Python
"hello".capitalize()       # "Hello"
"HELLO".capitalize()       # "Hello"
"hELLO".capitalize()       # "Hello"
"hello world".capitalize() # "Hello world"

# 注意与其他方法的区别
"hello".upper()      # "HELLO"（全部大写）
"hello".title()      # "Hello"（每个单词首字母大写）
"hello world".title() # "Hello World"

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

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

📌 记忆要点

capitalize() 首字母大写 + 其余小写。title() 每个单词首字母大写。upper() 全部大写。

第18题¶

下列关于Python列表切片的说法，正确的是（）。

选项	内容
A	切片会修改原列表
B	`lst[::-1]` 返回原列表的反转副本 ✅
C	切片的步长不能为负数
D	切片结果与原列表共享同一块内存

答案

B

📖 解析：

A 错误：切片创建新列表，不会修改原列表
B 正确：lst[::-1] 创建原列表的反转副本，原列表不变
C 错误：切片步长可以为负数，[::-1] 就是步长为 -1 的例子
D 错误：切片创建新列表，与原列表不共享内存

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

# 切片创建新列表
new_lst = lst[::-1]  # [5, 4, 3, 2, 1]
print(lst)            # [1, 2, 3, 4, 5]（原列表不变）

# 验证不共享内存
lst[0] = 99
print(new_lst)        # [5, 4, 3, 2, 1]（不受影响）

# 常用切片操作
lst[1:4]     # [2, 3, 4]（索引1到3）
lst[::2]     # [1, 3, 5]（步长2）
lst[::-1]    # [5, 4, 3, 2, 1]（反转）
lst[-3:]     # [3, 4, 5]（最后3个）

🔑 知识点：切片特性

切片语法：lst[start:stop:step]
切片总是创建新对象（浅拷贝）
步长为负数时，从右向左取元素
lst[::-1] 是反转列表/字符串的常用技巧

📌 记忆要点

切片创建新对象，不修改原列表。[::-1] 反转序列。步长可以为负数。

第19题¶

下列哪个选项可以正确创建一个空集合？（）

选项	内容
A	`{}`
B	`set()` ✅
C	`[]`
D	`()`

答案

B

📖 解析：

A：{} 创建的是空字典，不是空集合
B：set() 创建空集合 ✅
C：[] 创建空列表
D：() 创建空元组

Python
type({})      # <class 'dict'>（空字典！）
type(set())   # <class 'set'>（空集合 ✅）
type([])      # <class 'list'>（空列表）
type(())      # <class 'tuple'>（空元组）

# 创建非空集合可以直接用花括号
s = {1, 2, 3}     # <class 'set'> ✅
type(s)            # <class 'set'>

# 但空花括号是字典，不是集合！
empty_dict = {}    # 字典
empty_set = set()  # 集合

🔑 知识点：空容器创建方式

容器类型	空容器创建
列表	`[]` 或 `list()`
字典	`{}` 或 `dict()`
集合	`set()`（注意：不是 `{}`）
元组	`()` 或 `tuple()`

📌 记忆要点

{} = 空字典，set() = 空集合。非空集合可以用 {1, 2, 3}，但空集合必须用 set()。

第20题¶

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

Python
x = 0
for i in range(1, 6):
    if i % 2 == 0:
        continue
    x += i
print(x)

选项	内容
A	15
B	9 ✅
C	6
D	4

答案

B

📖 解析：

range(1, 6) 生成 1, 2, 3, 4, 5
i % 2 == 0 判断偶数，偶数时 continue 跳过
只累加奇数：1 + 3 + 5 = 9

循环轮次	i	i % 2 == 0	操作	x
1	1	False（奇数）	x += 1	1
2	2	True（偶数）	continue 跳过	1
3	3	False（奇数）	x += 3	4
4	4	True（偶数）	continue 跳过	4
5	5	False（奇数）	x += 5	9

Python
x = 0
for i in range(1, 6):
    if i % 2 == 0:   # 偶数跳过
        continue
    x += i            # 只累加奇数
print(x)              # 9

# 等价写法
x = sum(i for i in range(1, 6) if i % 2 != 0)  # 9

🔑 知识点：continue 语句

continue 跳过当前循环的剩余语句，直接进入下一次循环
break 跳出整个循环
两者区别：continue 只跳过一次，break 终止全部

📌 记忆要点

continue 跳过当次，break 终止全部。本题跳过偶数，只累加奇数 1+3+5=9。

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

第1题 ✅ 对¶

题目： Python中，3 + 4j 是合法的复数表示。

答案

✔ 对

解析：

Python 支持复数类型，3 + 4j 中 3 是实部，4j 是虚部
j 或 J 表示虚数单位
可以用 type(3+4j) 验证为 <class 'complex'>

Python
z = 3 + 4j
type(z)     # <class 'complex'>
z.real      # 3.0（实部）
z.imag      # 4.0（虚部）
z.conjugate()  # (3-4j)（共轭复数）

记忆要点： Python 原生支持复数，虚数单位用 j 或 J，实部和虚部可通过 .real 和 .imag 访问。

第2题 ✅ 对¶

题目： tuple() 可以将列表转换为元组。

答案

✔ 对

解析：

tuple() 是内置函数，可以将可迭代对象转换为元组
列表转元组是最常见的用法

Python
tuple([1, 2, 3])      # (1, 2, 3)
tuple("abc")          # ('a', 'b', 'c')
tuple(range(3))       # (0, 1, 2)
tuple({1, 2, 3})      # (1, 2, 3)（集合转元组）

# 反向操作：元组转列表
list((1, 2, 3))       # [1, 2, 3]

记忆要点： tuple() 列表转元组，list() 元组转列表。

第3题 ❌ 错¶

题目： 字典的 keys() 方法返回的是一个列表。

答案

✘ 错

解析：

Python 3 中 keys() 返回的是 dict_keys 视图对象，不是列表
视图对象是动态的，字典变化时视图也变化
可以用 list() 将视图对象转为列表

Python
d = {'a': 1, 'b': 2, 'c': 3}
type(d.keys())    # <class 'dict_keys'>（不是列表！）
list(d.keys())    # ['a', 'b', 'c']（转为列表）

# 视图是动态的
keys = d.keys()   # dict_keys(['a', 'b', 'c'])
d['d'] = 4        # 添加新键值对
print(list(keys)) # ['a', 'b', 'c', 'd']（视图自动更新）

记忆要点： Python 3 中 keys()、values()、items() 返回视图对象，不是列表。用 list() 转换。

第4题 ✅ 对¶

题目： Python中，字符串的 * 运算符可以重复字符串。

答案

✔ 对

解析：

字符串 * 整数 = 重复字符串
这是序列类型的通用操作

Python
"ab" * 3      # "ababab"
"-" * 10      # "----------"
"ha" * 0      # ""（空字符串）
[1, 2] * 3    # [1, 2, 1, 2, 1, 2]（列表也支持）
(1,) * 3      # (1, 1, 1)（元组也支持）

记忆要点： 序列类型（字符串、列表、元组）都支持 * 重复操作。

第5题 ✅ 对¶

题目： if 语句可以没有 else 子句。

答案

✔ 对

解析：

if 可以单独使用，不需要配对 else
else 是可选的

Python
# 只有 if
if score >= 60:
    print("及格")

# if-else
if score >= 60:
    print("及格")
else:
    print("不及格")

# if-elif-else
if score >= 90:
    print("优秀")
elif score >= 60:
    print("及格")
else:
    print("不及格")

记忆要点： if 可以单独使用，else 和 elif 是可选的。

第6题 ✅ 对¶

题目： 函数定义时，带默认值的参数必须放在没有默认值的参数后面。

答案

✔ 对

解析：

默认参数必须在非默认参数之后，否则语法错误
这是因为 Python 按位置匹配参数

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

# ❌ 错误：默认参数在前
def f(a=1, b, c):   # SyntaxError
    pass

# ✅ 关键字参数可以打乱顺序调用
def f(a, b=1, c=2):
    pass

f(10)           # a=10, b=1, c=2
f(10, 20)       # a=10, b=20, c=2
f(10, c=30)     # a=10, b=1, c=30

记忆要点： 默认参数必须放在非默认参数后面，否则 SyntaxError。

第7题 ❌ 错¶

题目： list.remove(x) 方法会删除列表中所有值为x的元素。

答案

✘ 错

解析：

remove(x) 只删除第一个值为 x 的元素
如果要删除所有匹配元素，需要循环或列表推导

Python
lst = [1, 2, 3, 2, 4, 2]
lst.remove(2)
print(lst)    # [1, 3, 2, 4, 2]（只删除了第一个2）

# 删除所有2
lst = [1, 2, 3, 2, 4, 2]
lst = [x for x in lst if x != 2]
print(lst)    # [1, 3, 4]

# 或者循环删除（从后往前删）
lst = [1, 2, 3, 2, 4, 2]
while 2 in lst:
    lst.remove(2)
print(lst)    # [1, 3, 4]

记忆要点： remove() 只删除第一个匹配元素。删除所有匹配需用列表推导式或循环。

第8题 ❌ 错¶

题目： Python中的 elif 可以单独使用，不需要与 if 配对。

答案

✘ 错

解析：

elif 必须跟在 if 或另一个 elif 后面，不能单独使用
elif 是 else if 的缩写，必须先有 if

Python
# ❌ 错误：elif 不能单独使用
elif x > 0:
    print("正数")

# ✅ 正确：elif 必须与 if 配对
if x > 0:
    print("正数")
elif x < 0:
    print("负数")
else:
    print("零")

记忆要点： elif 不能单独使用，必须跟在 if 后面。else 也不能单独使用。

第9题 ✅ 对¶

题目： 字符串方法 join() 的调用者是分隔符，参数是要连接的序列。

答案

✔ 对

解析：

join() 的调用者是分隔符字符串，参数是可迭代对象
语法：分隔符.join(序列)

Python
# 分隔符.join(序列)
",".join(["a", "b", "c"])     # "a,b,c"
" ".join(["Hello", "World"])  # "Hello World"
"".join(["H", "e", "l", "l", "o"])  # "Hello"
"-".join("2024")              # "2-0-2-4"

# 注意：序列中的元素必须是字符串
",".join([1, 2, 3])           # ❌ TypeError
",".join(str(x) for x in [1, 2, 3])  # ✅ "1,2,3"

记忆要点： join() 的调用者是分隔符，参数是要连接的序列。记忆口诀："分隔符连接序列"。

第10题 ❌ 错¶

题目： dict.pop(key) 与 del dict[key] 的功能完全相同。

答案

✘ 错

解析：

两者都能删除字典中的键值对，但有重要区别：
pop(key) 返回被删除的值，del dict[key] 不返回任何值
pop(key, default) 可以指定键不存在时的默认值，避免报错
del dict[key] 在键不存在时抛出 KeyError

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

# pop() 返回被删除的值
val = d.pop('b')     # val = 2
print(d)             # {'a': 1, 'c': 3}

# del 不返回值
del d['a']           # 无返回值
print(d)             # {'c': 3}

# pop() 可以指定默认值
d.pop('z', '不存在')  # '不存在'（键不存在，返回默认值）
d.pop('z')           # ❌ KeyError（键不存在且无默认值）
del d['z']           # ❌ KeyError（键不存在）

记忆要点： pop() 返回被删除的值且可设默认值，del 不返回值且键不存在时报错。

第11题 ✅ 对¶

题目： Python中，while 循环可以嵌套使用。

答案

✔ 对

解析：

Python 支持循环嵌套，包括 while 嵌套 while、for 嵌套 for、以及混合嵌套
嵌套循环常用于处理二维数据结构

Python
# while 嵌套 while：打印乘法表
i = 1
while i <= 9:
    j = 1
    while j <= i:
        print(f"{j}×{i}={i*j}", end="\t")
        j += 1
    print()
    i += 1

# for 嵌套 for：遍历二维列表
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
for row in matrix:
    for item in row:
        print(item, end=" ")
    print()

记忆要点： Python 支持循环嵌套，内层循环完整执行一遍后外层才推进一次。

第12题 ❌ 错¶

题目： 使用 import math 后，可以直接使用 sqrt() 函数。

答案

✘ 错

解析：

import math 导入模块后，需要用 math.sqrt() 调用，不能直接用 sqrt()
只有 from math import sqrt 才能直接使用 sqrt()

Python
# 方式1：import 模块
import math
math.sqrt(16)    # 4.0 ✅
sqrt(16)         # ❌ NameError

# 方式2：from 模块 import 函数
from math import sqrt
sqrt(16)         # 4.0 ✅

# 方式3：from 模块 import *（不推荐）
from math import *
sqrt(16)         # 4.0 ✅ 但容易命名冲突

记忆要点： import math 需用 math.sqrt()，from math import sqrt 才能直接用 sqrt()。

第13题 ✅ 对¶

题目： Python中，True + True 的结果是 2。

答案

✔ 对

解析：

Python 中 True 等价于整数 1，False 等价于整数 0
布尔值可以参与算术运算

Python
True + True     # 2
True + False    # 1
False + False   # 0
True * 5        # 5
int(True)       # 1
int(False)      # 0
bool(1)         # True
bool(0)         # False

# 实用场景：统计列表中满足条件的元素个数
nums = [1, 2, 3, 4, 5, 6]
count = sum(x % 2 == 0 for x in nums)  # 3（偶数个数）

记忆要点： True = 1，False = 0。布尔值可参与算术运算。

第14题 ❌ 错¶

题目： random.randrange(1, 10) 和 random.randint(1, 10) 生成的随机整数范围相同。

答案

✘ 错

解析：

randrange(1, 10) 生成 [1, 10) 范围的随机整数，即 1~9（不包含10）
randint(1, 10) 生成 [1, 10] 范围的随机整数，即 1~10（包含10）
两者的范围不同！

Python
import random

# randrange(start, stop) — 不包含 stop
random.randrange(1, 10)  # 1~9（不含10）

# randint(a, b) — 包含两端
random.randint(1, 10)    # 1~10（含10）

# randrange 也可以指定步长
random.randrange(0, 10, 2)  # 0, 2, 4, 6, 8（偶数）

# 记忆类比
# randrange 类似 range — 左闭右开
# randint — 左闭右闭

记忆要点： randrange 类似 range，左闭右开不含上限；randint 两端都包含。

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

第1题：计算阶乘¶

题目： 计算用户输入的正整数n的阶乘。

Python
n = int(input("请输入一个正整数:"))
result = 1
#**********begin1**********
_______
#**********end1**********
    result = result * i
print(n, "的阶乘为:", result)

✅ 填空答案

begin1： for i in range(1, n + 1):

完整正确代码

Python
# 计算阶乘
# 思路：n! = 1 × 2 × 3 × ... × n
n = int(input("请输入一个正整数:"))
result = 1                           # 累乘器初始为1

for i in range(1, n + 1):            # 【填空】从1乘到n
    result = result * i              # 累乘

print(n, "的阶乘为:", result)

运行示例： 输入 5 → 输出 5 的阶乘为: 120

🔑 知识点：for循环、range函数、累乘

累乘器初始值为 1（不是0，因为0乘任何数都是0）
range(1, n + 1) 生成 1 到 n 的序列（左闭右开）
阶乘公式：n! = 1 * 2 * 3 * ... * n

📖 拓展

Python
# 方法2：while循环
n = int(input("请输入一个正整数:"))
result = 1
i = 1
while i <= n:
    result *= i
    i += 1
print(n, "的阶乘为:", result)

# 方法3：递归
def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n - 1)

# 方法4：math模块
import math
print(math.factorial(5))  # 120

📌 记忆要点

累乘器初始为 1，累加器初始为 0
range(1, n+1) 包含 n，range(1, n) 不包含 n
result *= i 等价于 result = result * i

第2题：查找列表中的最大值和最小值¶

题目： 找出列表中的最大值和最小值。

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

✅ 填空答案

begin1： max_num = nums[0] 和 min_num = nums[0]
begin2： elif num < min_num:

完整正确代码

Python
# 查找列表最大值和最小值
# 思路：假设第一个元素既是最小值也是最大值，逐一比较更新
nums = [34, 12, 56, 78, 23, 45, 67, 89]

max_num = nums[0]                    # 【填空1】初始最大值为第一个元素
min_num = nums[0]                    # 【填空1】初始最小值为第一个元素

for num in nums:
    if num > max_num:
        max_num = num                # 更新最大值
    elif num < min_num:              # 【填空2】比当前最小值更小则更新
        min_num = num

print("最大值:", max_num, "最小值:", min_num)

运行结果： 最大值: 89 最小值: 12

🔑 知识点：最大最小值查找、初始值设定

最大值初始设为列表第一个元素，逐一比较更新
最小值同理
不能设为0，因为列表元素可能全为负数

📖 拓展

Python
# 方法2：内置函数
max_num = max(nums)   # 89
min_num = min(nums)   # 12

# 方法3：排序后取首尾
sorted_nums = sorted(nums)
min_num = sorted_nums[0]   # 12
max_num = sorted_nums[-1]  # 89

📌 记忆要点

最大值/最小值初始值设为列表第一个元素，不能设为0
使用 elif 而非 if，因为一个数不可能同时大于最大值且小于最小值
内置函数 max() 和 min() 更简洁

第3题：字符串大小写转换¶

题目： 将字符串中的大写字母转为小写，小写字母转为大写。

Python
s = input("请输入字符串:")
result = ""
for ch in s:
    #**********begin1**********
    _______
    #**********end1**********
        result += ch.lower()
    else:
        #**********begin2**********
        _______
        #**********end2**********
print("转换后:", result)

✅ 填空答案

begin1： if ch.isupper():
begin2： result += ch.upper()

完整正确代码

Python
# 字符串大小写互换
# 思路：遍历每个字符，大写转小写，小写转大写
s = input("请输入字符串:")
result = ""

for ch in s:
    if ch.isupper():                 # 【填空1】判断是否为大写字母
        result += ch.lower()         # 大写转小写
    else:
        result += ch.upper()         # 【填空2】小写转大写

print("转换后:", result)

运行示例： 输入 Hello → 输出 转换后: hELLO

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

方法	功能
`isupper()`	判断是否全为大写
`islower()`	判断是否全为小写
`upper()`	转换为大写
`lower()`	转换为小写
`swapcase()`	大小写互换

📖 拓展

Python
# 方法2：使用 swapcase() 一行搞定
s = input("请输入字符串:")
print("转换后:", s.swapcase())

# 方法3：列表推导式
s = input("请输入字符串:")
result = "".join(ch.lower() if ch.isupper() else ch.upper() for ch in s)
print("转换后:", result)

📌 记忆要点

isupper() 判断大写，islower() 判断小写
upper() 转大写，lower() 转小写，swapcase() 互换
swapcase() 可以直接实现本题功能

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

第1题：判断回文字符串¶

题目： 判断输入的字符串是否为回文字符串（正读反读相同）。

Python
s = input("请输入字符串:")
#**********begin1**********
if s == s.reverse():
#**********end1**********
    print(s, "是回文字符串")
else:
    print(s, "不是回文字符串")

✅ 错误修正

错误位置	原代码	修正后	错误原因
begin1	`s.reverse()`	`s[::-1]`	字符串没有 `reverse()` 方法，用切片反转

完整正确代码

Python
# 判断回文字符串
# 思路：将字符串反转后与原字符串比较
s = input("请输入字符串:")

if s == s[::-1]:                    # ✅ 修正：用切片反转字符串
    print(s, "是回文字符串")
else:
    print(s, "不是回文字符串")

运行示例：

Python
输入: abcba
abcba 是回文字符串

输入: hello
hello 不是回文字符串

🔑 知识点：字符串反转方法

字符串没有 reverse() 方法（reverse() 是列表的方法）
字符串反转方式：
s[::-1]（切片，最常用）
"".join(reversed(s))
递归

Python
# 字符串反转
s = "hello"
s[::-1]                 # "olleh" ✅
"".join(reversed(s))    # "olleh" ✅
s.reverse()             # ❌ AttributeError: 'str' object has no attribute 'reverse'

# 列表反转
lst = [1, 2, 3]
lst.reverse()           # ✅ 原地反转，lst变为 [3, 2, 1]

📌 记忆要点

字符串没有 reverse() 方法，用 s[::-1] 反转
列表才有 reverse() 方法（原地反转，返回 None）
回文判断：s == s[::-1]

第2题：统计单词数量¶

题目： 统计字符串中英文单词的数量。

Python
text = input("请输入一段英文:")
#**********begin1**********
words = text.split("")
#**********end1**********
#**********begin2**********
count = words.len()
#**********end2**********
print("单词数量:", count)

✅ 错误修正

错误位置	原代码	修正后	错误原因
begin1	`text.split("")`	`text.split()` 或 `text.split(" ")`	`split("")` 空字符串分隔符报错
begin2	`words.len()`	`len(words)`	Python 用 `len()` 函数，不是 `.len()` 方法

完整正确代码

Python
# 统计英文单词数量
text = input("请输入一段英文:")

words = text.split()               # ✅ 修正1：不传参按空白分割
count = len(words)                  # ✅ 修正2：用 len() 函数

print("单词数量:", count)

运行示例： 输入 Hello World Python → 输出 单词数量: 3

🔑 知识点：split() 方法和 len() 函数

split() 不传参时按任意空白字符分割（空格、制表符、换行等）
split("") 传空字符串会报错 ValueError
split(" ") 按单个空格分割（多个连续空格会产生空串）
Python 获取长度用 len() 函数，不是 .len() 方法

Python
"hello world".split()     # ["hello", "world"] ✅
"hello world".split(" ")  # ["hello", "world"] ✅
"hello world".split("")   # ❌ ValueError

len([1, 2, 3])     # 3 ✅
[1, 2, 3].len()    # ❌ AttributeError

📌 记忆要点

split() 不传参按空白分割，split("") 会报错
长度用 len() 函数，不是 .len() 方法
Python 风格：len(obj) 而非 obj.len()

第3题：计算列表中偶数的平均值¶

题目： 计算列表中偶数的平均值。

Python
nums = [12, 15, 8, 23, 16, 9, 4, 31, 20]
even_nums = []
#**********begin1**********
for num in nums:
    if num / 2 == 0:
        even_nums.append(num)
#**********end1**********
#**********begin2**********
avg = sum(even_nums) / len(even_nums)
#**********end2**********
#**********begin3**********
print("偶数的平均值为:" + avg)
#**********end3**********

✅ 错误修正

错误位置	原代码	修正后	错误原因
begin1	`num / 2 == 0`	`num % 2 == 0`	判断偶数用取余 `%`，不是除法 `/`
begin2	`avg = sum(even_nums) / len(even_nums)`	需加空列表检查	空列表时 `len()` 为0，除以0报错
begin3	`"偶数的平均值为:" + avg`	`"偶数的平均值为:" + str(avg)` 或用逗号	字符串与浮点数不能直接用 `+` 拼接

完整正确代码

Python
# 计算列表中偶数的平均值
nums = [12, 15, 8, 23, 16, 9, 4, 31, 20]
even_nums = []

for num in nums:
    if num % 2 == 0:                        # ✅ 修正1：用取余判断偶数
        even_nums.append(num)

if len(even_nums) == 0:                     # ✅ 修正2：检查空列表
    print("列表中没有偶数")
else:
    avg = sum(even_nums) / len(even_nums)
    print("偶数的平均值为:", avg)             # ✅ 修正3：用逗号分隔输出

# 输出: 偶数的平均值为: 12.0
# 偶数: 12, 8, 16, 4, 20 → (12+8+16+4+20)/5 = 60/5 = 12.0

🔑 知识点：取余运算、空列表检查、字符串拼接

判断偶数：num % 2 == 0（取余），不是 num / 2 == 0（除法）
除法前检查除数是否为0，避免 ZeroDivisionError
字符串与数字拼接：用 str() 转换或用 print() 逗号分隔

Python
# 判断偶数的常见错误
4 / 2    # 2.0 ≠ 0 ❌
4 % 2    # 0 == 0 ✅
4 // 2   # 2 ≠ 0 ❌

# 字符串拼接数字
"值:" + str(3.14)     # "值:3.14" ✅
"值:" + 3.14          # ❌ TypeError
print("值:", 3.14)    # 值: 3.14 ✅
print(f"值:{3.14}")   # 值:3.14 ✅

📌 记忆要点

判断偶数用 % 取余，不是 / 除法
除法前检查除数不为0
字符串 + 数字 = TypeError，用 str() 转换或逗号分隔

第4题：类与对象¶

题目： 定义一个矩形类，包含长和宽，并计算面积和周长。

Python
class Rectangle:
    #**********begin1**********
    def __init__(self, length, width)
    #**********end1**********
        self.length = length
        self.width = width

    def area(self):
        return self.length * self.width

    #**********begin2**********
    def perimeter(self):
        return 2 * (self.length + self.width
    #**********end2**********

rect = Rectangle(5, 3)
#**********begin3**********
print("面积:", area())
print("周长:", rect.perimeter())
#**********end3**********

✅ 错误修正

错误位置	原代码	修正后	错误原因
begin1	`def __init__(self, length, width)`	`def __init__(self, length, width):`	函数定义末尾缺少冒号
begin2	`return 2 * (self.length + self.width`	`return 2 * (self.length + self.width)`	缺少右括号
begin3	`area()`	`rect.area()`	需要通过实例调用方法

完整正确代码

Python
# 矩形类
class Rectangle:
    def __init__(self, length, width):      # ✅ 修正1：加冒号
        self.length = length
        self.width = width

    def area(self):
        return self.length * self.width

    def perimeter(self):
        return 2 * (self.length + self.width)  # ✅ 修正2：加右括号

rect = Rectangle(5, 3)
print("面积:", rect.area())                  # ✅ 修正3：通过实例调用
print("周长:", rect.perimeter())
# 输出: 面积: 15  周长: 16

🔑 知识点：类定义、方法调用、语法规则

函数/方法定义末尾必须有冒号 :
括号必须成对出现
实例方法通过 实例名.方法名() 调用，不能直接用 方法名()

Python
# 类定义的基本结构
class ClassName:
    def __init__(self, 参数):    # 构造方法，注意冒号
        self.属性 = 参数

    def 方法名(self):            # 实例方法，注意冒号
        return 结果

# 调用方法
obj = ClassName(参数)
obj.方法名()                      # ✅ 通过实例调用
方法名()                          # ❌ 直接调用会报错

📌 记忆要点

函数/方法定义必须有冒号 :
括号必须成对
实例方法必须通过实例调用：对象.方法名()

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

第1题：杨辉三角¶

题目： 编写程序，打印n行杨辉三角。例如n=6时：

Text Only
1 2 3 4 5 6	`1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1`

方法1：嵌套循环（推荐，最直观）

Python
def yanghui(n):
    triangle = []
    for i in range(n):
        row = [1]  # 每行第一个元素是1
        for j in range(1, i):
            # 当前元素 = 上一行左上方元素 + 上一行正上方元素
            row.append(triangle[i-1][j-1] + triangle[i-1][j])
        if i > 0:
            row.append(1)  # 每行最后一个元素是1
        triangle.append(row)

    # 打印杨辉三角
    for row in triangle:
        print(" ".join(str(num) for num in row))

n = int(input("请输入行数:"))
yanghui(n)

方法2：利用上一行生成下一行

Python
def yanghui(n):
    row = [1]
    for i in range(n):
        print(" ".join(str(x) for x in row))
        # 生成下一行：首尾各加1，中间元素为相邻两数之和
        row = [1] + [row[j] + row[j+1] for j in range(len(row)-1)] + [1]
        # 第0行特殊处理（只有[1]，不加末尾的1）
        if i == 0:
            row = [1, 1]

n = int(input("请输入行数:"))
yanghui(n)

方法3：公式法（组合数）

Python
def yanghui(n):
    for i in range(n):
        row = []
        for j in range(i + 1):
            # C(i, j) = i! / (j! * (i-j)!)
            value = 1
            for k in range(j):
                value = value * (i - k) // (k + 1)
            row.append(value)
        print(" ".join(str(x) for x in row))

n = int(input("请输入行数:"))
yanghui(n)

运行结果（n=6）：

Text Only
1 2 3 4 5 6	`1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1`

🔑 知识点：杨辉三角规律、嵌套循环、列表操作

杨辉三角规律：每行首尾为1，中间元素 = 上一行左上方 + 上一行正上方
第i行有i+1个元素
triangle[i-1][j-1] + triangle[i-1][j] 计算中间元素

📖 拓展

Python
# 杨辉三角的数学性质：
# 1. 第n行第k个元素 = C(n-1, k-1)（组合数）
# 2. 每行元素之和 = 2^(n-1)
# 3. 对称性：第n行第k个 = 第n行第(n-k+1)个

# 验证每行之和
for i in range(1, 7):
    print(f"第{i}行之和: {2**(i-1)}")

📌 记忆要点

杨辉三角：首尾为1，中间 = 左上 + 正上
外层循环控制行数，内层循环控制每行元素
join() 格式化输出，元素间用空格分隔

第2题：成绩等级判断¶

题目： 编写程序，输入学生成绩（0~100的整数），输出对应的等级。

等级规则： - 90~100：优秀 - 80~89：良好 - 70~79：中等 - 60~69：及格 - 0~59：不及格

要求： 1. 输入多个学生成绩，输入-1结束 2. 统计各等级人数 3. 输出统计结果

方法1：if-elif 分支 + 循环输入

Python
def grade_statistics():
    excellent = 0  # 优秀
    good = 0       # 良好
    medium = 0     # 中等
    passing = 0    # 及格
    failing = 0    # 不及格

    while True:
        score = int(input("请输入成绩(0-100, 输入-1结束):"))
        if score == -1:
            break
        if score < 0 or score > 100:
            print("成绩无效，请重新输入")
            continue

        if score >= 90:
            excellent += 1
        elif score >= 80:
            good += 1
        elif score >= 70:
            medium += 1
        elif score >= 60:
            passing += 1
        else:
            failing += 1

    # 输出统计结果
    print(f"优秀: {excellent}人")
    print(f"良好: {good}人")
    print(f"中等: {medium}人")
    print(f"及格: {passing}人")
    print(f"不及格: {failing}人")

grade_statistics()

方法2：使用字典存储统计

Python
def grade_statistics():
    grades = {"优秀": 0, "良好": 0, "中等": 0, "及格": 0, "不及格": 0}

    while True:
        score = int(input("请输入成绩(0-100, 输入-1结束):"))
        if score == -1:
            break
        if score < 0 or score > 100:
            print("成绩无效，请重新输入")
            continue

        if score >= 90:
            grades["优秀"] += 1
        elif score >= 80:
            grades["良好"] += 1
        elif score >= 70:
            grades["中等"] += 1
        elif score >= 60:
            grades["及格"] += 1
        else:
            grades["不及格"] += 1

    for grade, count in grades.items():
        print(f"{grade}: {count}人")

grade_statistics()

方法3：使用列表存储成绩后批量处理

Python
def grade_statistics():
    scores = []
    while True:
        score = int(input("请输入成绩(0-100, 输入-1结束):"))
        if score == -1:
            break
        if 0 <= score <= 100:
            scores.append(score)
        else:
            print("成绩无效，请重新输入")

    # 批量统计
    excellent = sum(1 for s in scores if s >= 90)
    good = sum(1 for s in scores if 80 <= s < 90)
    medium = sum(1 for s in scores if 70 <= s < 80)
    passing = sum(1 for s in scores if 60 <= s < 70)
    failing = sum(1 for s in scores if s < 60)

    print(f"优秀: {excellent}人")
    print(f"良好: {good}人")
    print(f"中等: {medium}人")
    print(f"及格: {passing}人")
    print(f"不及格: {failing}人")

grade_statistics()

运行示例：

Text Only

请输入成绩(0-100, 输入-1结束):95
请输入成绩(0-100, 输入-1结束):85
请输入成绩(0-100, 输入-1结束):75
请输入成绩(0-100, 输入-1结束):65
请输入成绩(0-100, 输入-1结束):55
请输入成绩(0-100, 输入-1结束):92
请输入成绩(0-100, 输入-1结束):88
请输入成绩(0-100, 输入-1结束):73
请输入成绩(0-100, 输入-1结束):68
请输入成绩(0-100, 输入-1结束):42
请输入成绩(0-100, 输入-1结束):90
请输入成绩(0-100, 输入-1结束):83
请输入成绩(0-100, 输入-1结束):78
请输入成绩(0-100, 输入-1结束):62
请输入成绩(0-100, 输入-1结束):35
请输入成绩(0-100, 输入-1结束):-1
优秀: 3人
良好: 5人
中等: 4人
及格: 2人
不及格: 1人

🔑 知识点：if-elif分支、循环输入、统计计数

if-elif-else 实现多条件判断，注意从高到低判断
while True + break 实现循环输入
计数器变量初始为 0

📖 拓展

Python
# 使用函数封装等级判断逻辑
def get_grade(score):
    if score >= 90:
        return "优秀"
    elif score >= 80:
        return "良好"
    elif score >= 70:
        return "中等"
    elif score >= 60:
        return "及格"
    else:
        return "不及格"

# 使用 collections.Counter 自动统计
from collections import Counter
scores = [95, 85, 75, 65, 55]
grade_list = [get_grade(s) for s in scores]
counter = Counter(grade_list)
for grade in ["优秀", "良好", "中等", "及格", "不及格"]:
    print(f"{grade}: {counter.get(grade, 0)}人")

📌 记忆要点

if-elif-else 从高到低判断，匹配一个后不再判断其他分支
while True + 输入判断 + break 实现循环输入
统计计数：初始化计数器为0，满足条件时 +=1

知识点覆盖总结

题型	知识点
单选1-5	标识符规则、算术运算符、字符串不可变、引用赋值、负数索引
单选6-10	内置函数vs方法、函数参数、局部全局变量、list()转换、文件操作
单选11-15	sort排序、除法运算符、元组特性、find方法、取余判断
单选16-20	可变默认参数、字符串方法、切片特性、集合创建、continue语句
判断1-7	复数、tuple转换、keys视图、字符串重复、if语句、默认参数、remove方法
判断8-14	elif语法、join方法、pop与del、while嵌套、import语法、布尔值、随机函数
填空1-3	阶乘计算、最大最小值、大小写转换
改错1-4	字符串反转、split与len、取余与类型、类定义语法
编程1-2	杨辉三角、成绩等级统计