跳转至

程序填空题解析

第1题：while循环求累加和

题目： 使用while循环计算1到100的累加和，并输出结果。

Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
total = 0
i = 1
#**********begin1**********
_______
#**********end1**********
    total += i
    #**********begin2**********
    _______
    #**********end2**********
print("1到100的累加和为:", total)

✅ 填空答案

  • begin1： while i <= 100:

  • begin2： i += 1

完整正确代码

Python
1
2
3
4
5
6
total = 0
i = 1
while i <= 100:       # 【填空1】循环条件：i从1到100
    total += i
    i += 1             # 【填空2】循环变量递增，避免死循环
print("1到100的累加和为:", total)

运行结果： 1到100的累加和为: 5050

解析：

  • begin1：while循环需要循环条件，i 从1开始，累加到100为止，所以条件为 i <= 100
  • begin2：每次循环结束后 i 必须递增，否则 i 永远为1，条件永远为True，导致死循环
  • 累加和公式验证：1+2+...+100 = 100 * 101 / 2 = 5050

🔑 知识点：while循环与累加

  • while循环三要素：初始化、循环条件、更新变量（缺一不可）
  • 累加模式：total = 0 → 循环中 total += i
  • while vs for的选择：已知次数用 for，条件驱动用 while
Python
1
2
3
4
# for循环等价写法（更简洁）
total = 0
for i in range(1, 101):
    total += i
📖 拓展
Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
# 方法2：数学公式（高斯求和）
total = 100 * 101 // 2  # 等差数列求和公式 n*(n+1)/2

# 方法3：内置函数
total = sum(range(1, 101))

# 扩展：求1到n的偶数和
n = 100
total = 0
i = 2
while i <= n:
    total += i
    i += 2
print(total)  # 2550

📌 记忆要点

  • while循环必写三要素：初始值 → 条件 → 更新（忘写更新会死循环！）
  • 累加模板：total = 0 初始化，total += i 累加
  • range(1, 101) 包含1不包含101，对应 i <= 100

第2题：字符串大小写统计

题目： 统计字符串中大写字母、小写字母和其他字符的个数。

Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
s = "Hello World! 2024"
upper_count = 0
lower_count = 0
other_count = 0
for ch in s:
    #**********begin1**********
    _______
    #**********end1**********
        upper_count += 1
    #**********begin2**********
    _______
    #**********end2**********
        lower_count += 1
    else:
        other_count += 1
print("大写字母:", upper_count)
print("小写字母:", lower_count)
print("其他字符:", other_count)

✅ 填空答案

  • begin1： if ch.isupper():

  • begin2： elif ch.islower():

完整正确代码

Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
s = "Hello World! 2024"
upper_count = 0
lower_count = 0
other_count = 0
for ch in s:
    if ch.isupper():        # 【填空1】判断是否为大写字母
        upper_count += 1
    elif ch.islower():      # 【填空2】判断是否为小写字母
        lower_count += 1
    else:
        other_count += 1
print("大写字母:", upper_count)
print("小写字母:", lower_count)
print("其他字符:", other_count)

运行结果：

Text Only
1
2
3
大写字母: 2
小写字母: 8
其他字符: 6

解析：

  • begin1：ch.isupper() 判断字符是否为大写字母（A-Z），对应统计 upper_count
  • begin2：ch.islower() 判断字符是否为小写字母（a-z），对应统计 lower_count
  • 其余字符（空格、标点、数字等）归入 other_count
  • 注意 begin2 必须用 elif 而非 if，否则一个字符可能被多次计数

🔑 知识点：字符串判断方法

方法 功能 示例
isupper() 是否全为大写字母 "A".isupper() → True
islower() 是否全为小写字母 "a".islower() → True
isdigit() 是否为数字字符 "3".isdigit() → True
isalpha() 是否为字母 "A".isalpha() → True
isspace() 是否为空白字符 " ".isspace() → True
  • if...elif...else 结构保证每个字符只被归入一个类别
  • 如果 begin2 写成 if，则大写字母不会被 else 捕获，逻辑正确但效率更低（每次都判断所有条件）
📖 拓展
Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 方法2：使用 isalpha() + isupper()/islower() 组合
for ch in s:
    if ch.isalpha():
        if ch.isupper():
            upper_count += 1
        else:
            lower_count += 1
    else:
        other_count += 1

# 方法3：ASCII码判断
for ch in s:
    if 'A' <= ch <= 'Z':
        upper_count += 1
    elif 'a' <= ch <= 'z':
        lower_count += 1
    else:
        other_count += 1

# 方法4：统计所有类别
s = "Hello World! 2024"
print(f"大写: {sum(1 for ch in s if ch.isupper())}")
print(f"小写: {sum(1 for ch in s if ch.islower())}")
print(f"数字: {sum(1 for ch in s if ch.isdigit())}")

📌 记忆要点

  • isupper()/islower()/isdigit() 是字符串的判断方法，返回布尔值
  • 多分支判断用 if...elif...else，每个条件互斥
  • 遍历字符串：for ch in s 逐字符处理

第3题：列表元素筛选

题目： 从列表中筛选出所有正数，并存入新列表输出。

Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
nums = [-3, 5, -1, 8, 0, 12, -7, 4]
#**********begin1**********
_______
#**********end1**********
for n in nums:
    #**********begin2**********
    _______
    #**********end2**********
        positives.append(n)
print("正数列表:", positives)

✅ 填空答案

  • begin1： positives = []

  • begin2： if n > 0:

完整正确代码

Python
1
2
3
4
5
6
nums = [-3, 5, -1, 8, 0, 12, -7, 4]
positives = []          # 【填空1】创建空列表存放正数
for n in nums:
    if n > 0:           # 【填空2】判断是否为正数（不含0）
        positives.append(n)
print("正数列表:", positives)

运行结果： 正数列表: [5, 8, 12, 4]

解析：

  • begin1：创建空列表 positives = []，用于存放筛选出的正数
  • begin2：条件判断 n > 0，注意正数不含0，所以用 > 而非 >=
  • 列表筛选的通用模式：创建空列表 → 遍历 → 条件判断 → append

🔑 知识点：列表筛选

  • 筛选模式三步：新建空列表 → 遍历原列表 → 满足条件则 append
  • append() 在列表末尾添加元素
  • 注意"正数"（> 0）和"非负数"（>= 0）的区别
条件 含义 0属于吗
n > 0 正数 否
n >= 0 非负数 是
n < 0 负数 否
📖 拓展
Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
# 方法2：列表推导式（Pythonic写法）
positives = [n for n in nums if n > 0]

# 方法3：filter函数
positives = list(filter(lambda n: n > 0, nums))

# 扩展：多条件筛选
# 筛选正偶数
pos_even = [n for n in nums if n > 0 and n % 2 == 0]

# 筛选绝对值大于5的数
big = [n for n in nums if abs(n) > 5]

📌 记忆要点

  • 列表筛选模板：空列表 = [] → for x in lst: → if 条件: → append
  • n > 0 是正数，n >= 0 是非负数，注意审题
  • 列表推导式简写：[x for x in lst if 条件]

第4题：字典统计成绩等级

题目： 根据成绩列表统计各等级人数：90及以上为A，8089为B，7079为C，60~69为D，60以下为E。

Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
scores = [95, 82, 73, 65, 55, 88, 91, 47, 78, 60]
grades = {}
for score in scores:
    if score >= 90:
        grade = 'A'
    elif score >= 80:
        grade = 'B'
    elif score >= 70:
        grade = 'C'
    elif score >= 60:
        grade = 'D'
    else:
        grade = 'E'
    #**********begin1**********
    _______
    #**********end1**********
#**********begin2**********
_______
#**********end2**********
    print(f"等级{g}: {grades[g]}人")

✅ 填空答案

  • begin1： grades[grade] = grades.get(grade, 0) + 1

  • begin2： for g in sorted(grades.keys()): 或 for g in sorted(grades):

完整正确代码

Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
scores = [95, 82, 73, 65, 55, 88, 91, 47, 78, 60]
grades = {}
for score in scores:
    if score >= 90:
        grade = 'A'
    elif score >= 80:
        grade = 'B'
    elif score >= 70:
        grade = 'C'
    elif score >= 60:
        grade = 'D'
    else:
        grade = 'E'
    grades[grade] = grades.get(grade, 0) + 1   # 【填空1】字典计数
for g in sorted(grades.keys()):                  # 【填空2】按等级排序输出
    print(f"等级{g}: {grades[g]}人")

运行结果：

Text Only
1
2
3
4
5
等级A: 2人
等级B: 2人
等级C: 2人
等级D: 2人
等级E: 2人

解析：

  • begin1：grades[grade] = grades.get(grade, 0) + 1 是字典计数的标准写法
    • grades.get(grade, 0) — 如果等级已存在返回计数，不存在返回0
    • + 1 后赋值回去，实现计数加1
  • begin2：for g in sorted(grades.keys()): 遍历排序后的键
    • sorted() 按字母顺序排列，保证输出顺序为 A, B, C, D, E
    • 不排序时字典遍历顺序不确定（虽然Python 3.7+保持插入顺序，但不一定是字母序）

🔑 知识点：字典计数

  • 字典计数核心写法：d[key] = d.get(key, 0) + 1
  • dict.get(key, default) — 键存在返回对应值，不存在返回default
写法 说明
grades.get(grade, 0) + 1 推荐：简洁，一行搞定
if grade in grades: grades[grade] += 1 等价写法：更啰嗦
from collections import Counter 更高级：Counter(scores)
  • sorted(dict) 等价于 sorted(dict.keys())，返回排序后的键列表
📖 拓展
Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# 方法2：使用 collections.Counter（更简洁）
from collections import Counter
grade_list = []
for score in scores:
    if score >= 90: grade_list.append('A')
    elif score >= 80: grade_list.append('B')
    elif score >= 70: grade_list.append('C')
    elif score >= 60: grade_list.append('D')
    else: grade_list.append('E')
grades = Counter(grade_list)
for g in sorted(grades):
    print(f"等级{g}: {grades[g]}人")

# 方法3：使用 setdefault
grades = {}
for score in scores:
    # ... 省略等级判断 ...
    grades.setdefault(grade, 0)
    grades[grade] += 1

# 方法4：使用 defaultdict
from collections import defaultdict
grades = defaultdict(int)  # 默认值为0
for score in scores:
    # ... 省略等级判断 ...
    grades[grade] += 1

📌 记忆要点

  • 字典计数：d[key] = d.get(key, 0) + 1
  • get(key, default) 避免 KeyError，default为0时实现计数
  • 遍历排序键：for k in sorted(d): 保证输出有序

第5题：函数判断素数

题目： 编写函数判断一个数是否为素数，在主程序中调用并输出结果。

Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
def is_prime(n):
    if n < 2:
        return False
    #**********begin1**********
    _______
    #**********end1**********
        if n % i == 0:
            #**********begin2**********
            _______
            #**********end2**********
    return True

num = 17
if is_prime(num):
    print(f"{num}是素数")
else:
    print(f"{num}不是素数")

✅ 填空答案

  • begin1： for i in range(2, n):

  • begin2： return False

完整正确代码

Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
def is_prime(n):
    if n < 2:
        return False
    for i in range(2, n):     # 【填空1】从2到n-1逐一试除
        if n % i == 0:
            return False       # 【填空2】能被整除，不是素数
    return True

num = 17
if is_prime(num):
    print(f"{num}是素数")
else:
    print(f"{num}不是素数")

运行结果： 17是素数

解析：

  • begin1：for i in range(2, n) 遍历2到n-1的所有整数，检查n是否能被i整除
    • range(2, n) 生成 2, 3, ..., n-1
    • 不需要从1开始（任何数都能被1整除），也不需要包含n（任何数都能被自身整除）
  • begin2：return False — 如果n能被某个i整除（n % i == 0），则n不是素数，立即返回False
    • 注意是 return False 而不是 break，因为函数只需要知道"不是素数"即可直接返回
    • 如果整个循环都没有返回False，说明n不能被2到n-1的任何数整除，是素数，返回True

🔑 知识点：素数判断

  • 素数定义：大于1的自然数，只能被1和自身整除
  • 判断逻辑：如果 n < 2，不是素数；否则检查2到n-1是否有因子
  • 函数中 return 可提前退出，效率优于 break + 标志变量
Python
1
2
3
4
5
6
7
8
9
# 优化版：只需检查到 √n
import math
def is_prime(n):
    if n < 2:
        return False
    for i in range(2, int(math.sqrt(n)) + 1):
        if n % i == 0:
            return False
    return True
📖 拓展
Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# 方法2：优化到√n（考试常用）
def is_prime(n):
    if n < 2:
        return False
    if n == 2:
        return True
    if n % 2 == 0:
        return False
    for i in range(3, int(n**0.5) + 1, 2):  # 只检查奇数
        if n % i == 0:
            return False
    return True

# 找出1到100的所有素数
primes = [n for n in range(2, 101) if is_prime(n)]
print(primes)
# [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47,
#  53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

# 方法3：埃拉托斯特尼筛法（批量找素数）
def sieve(n):
    is_p = [True] * (n + 1)
    is_p[0] = is_p[1] = False
    for i in range(2, int(n**0.5) + 1):
        if is_p[i]:
            for j in range(i*i, n+1, i):
                is_p[j] = False
    return [i for i in range(n+1) if is_p[i]]

📌 记忆要点

  • 素数判断模板：n < 2 → False → for i in range(2, n) → n % i == 0 → False → return True
  • 函数中用 return 替代 break，更简洁高效
  • 优化：只需试除到 √n，即 range(2, int(n**0.5)+1)

第6题：文件行数统计

题目： 读取文本文件，统计文件的行数和非空行数。

Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
total_lines = 0
non_empty_lines = 0
#**********begin1**********
_______
#**********end1**********
    for line in f:
        total_lines += 1
        #**********begin2**********
        _______
        #**********end2**********
            non_empty_lines += 1
print("总行数:", total_lines)
print("非空行数:", non_empty_lines)

✅ 填空答案

  • begin1： with open("data.txt", "r", encoding="utf-8") as f:

  • begin2： if line.strip():

完整正确代码

Python
1
2
3
4
5
6
7
8
9
total_lines = 0
non_empty_lines = 0
with open("data.txt", "r", encoding="utf-8") as f:   # 【填空1】打开文件
    for line in f:
        total_lines += 1
        if line.strip():                               # 【填空2】判断是否为非空行
            non_empty_lines += 1
print("总行数:", total_lines)
print("非空行数:", non_empty_lines)

运行结果（假设文件内容有5行，其中3行非空）：

Text Only
1
2
总行数: 5
非空行数: 3

解析：

  • begin1：with open("data.txt", "r", encoding="utf-8") as f: 打开文件用于读取
    • "r" — 只读模式
    • encoding="utf-8" — 指定编码，处理中文时避免乱码
    • with 语句确保文件使用后自动关闭
  • begin2：if line.strip(): 判断行是否非空
    • line.strip() 去除首尾空白字符（空格、制表符、换行符等）
    • 去除空白后如果为空字符串 ""，在布尔上下文中为 False
    • 如果去除空白后仍有内容，则为 True（非空行）
    • 不能用 if line != "\n":，因为行可能只有空格 " \n"

🔑 知识点：文件读取与空行判断

  • with open(...) as f: 是推荐的文件操作方式，自动关闭文件
  • for line in f: 逐行读取，每行末尾包含 \n
  • strip() 去除首尾空白，常用于判断空行和清理数据
方法 作用
line.strip() 去除首尾空白
line.lstrip() 去除左侧空白
line.rstrip() 去除右侧空白（保留缩进）
line.rstrip('\n') 只去除末尾换行
  • 空字符串在布尔上下文中为 False，非空为 True
📖 拓展
Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
# 方法2：使用 readlines()
with open("data.txt", "r", encoding="utf-8") as f:
    lines = f.readlines()
total_lines = len(lines)
non_empty_lines = len([line for line in lines if line.strip()])

# 方法3：统计空行数
empty_lines = total_lines - non_empty_lines
print(f"空行数: {empty_lines}")

# 方法4：同时统计字符数和单词数
with open("data.txt", "r", encoding="utf-8") as f:
    text = f.read()
char_count = len(text)
word_count = len(text.split())
line_count = text.count('\n') + 1
print(f"字符数: {char_count}, 单词数: {word_count}, 行数: {line_count}")

📌 记忆要点

  • 文件打开：with open("文件名", "r", encoding="utf-8") as f:
  • 逐行读取：for line in f:
  • 判断非空行：if line.strip():（空字符串为False）
  • strip() 去除首尾所有空白字符，包括空格、\t、\n

第7题：回文字符串判断

题目： 判断一个字符串是否为回文字符串（正读和反读相同）。

Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
def is_palindrome(s):
    left = 0
    right = len(s) - 1
    #**********begin1**********
    _______
    #**********end1**********
        if s[left] != s[right]:
            #**********begin2**********
            _______
            #**********end2**********
        left += 1
        right -= 1
    return True

text = "level"
if is_palindrome(text):
    print(f'"{text}"是回文字符串')
else:
    print(f'"{text}"不是回文字符串')

✅ 填空答案

  • begin1： while left < right:

  • begin2： return False

完整正确代码

Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
def is_palindrome(s):
    left = 0
    right = len(s) - 1
    while left < right:          # 【填空1】左右指针未相遇时继续比较
        if s[left] != s[right]:
            return False          # 【填空2】左右字符不等，不是回文
        left += 1
        right -= 1
    return True

text = "level"
if is_palindrome(text):
    print(f'"{text}"是回文字符串')
else:
    print(f'"{text}"不是回文字符串')

运行结果： "level"是回文字符串

解析：

  • begin1：while left < right: 双指针循环条件，当左指针小于右指针时继续比较
    • left < right 表示两指针还未相遇，还有字符需要比较
    • 当 left >= right 时，所有字符对都已比较完毕，说明是回文
  • begin2：return False 如果发现 s[left] != s[right]，即左右字符不相等，直接返回 False
    • 在函数中用 return 直接退出，无需标志变量
    • 如果整个循环都没有返回 False，说明所有字符对都相等，最后返回 True

🔑 知识点：回文字符串判断

  • 回文：正读和反读相同，如 "level"、"racecar"、"上海自来水来自海上"
  • 双指针法：左指针从0开始，右指针从末尾开始，向中间靠拢比较
  • 核心逻辑：s[left] != s[right] 则非回文，left 和 right 向中间移动
字符串 left/right过程 结果
"level" l=l, e=e, v(相遇) True
"hello" h!=l False
"aba" a=a, b(相遇) True
Python
1
2
3
# 最简写法：字符串反转
def is_palindrome(s):
    return s == s[::-1]
📖 拓展
Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
# 方法2：字符串反转（最简洁）
def is_palindrome_v2(s):
    return s == s[::-1]

# 方法3：忽略大小写和空格
def is_palindrome_v3(s):
    s = s.lower().replace(" ", "")
    return s == s[::-1]

# 方法4：递归判断
def is_palindrome_v4(s):
    if len(s) <= 1:
        return True
    if s[0] != s[-1]:
        return False
    return is_palindrome_v4(s[1:-1])

# 测试
print(is_palindrome_v2("racecar"))   # True
print(is_palindrome_v3("A man a plan a canal Panama"))  # True

📌 记忆要点

  • 双指针法：left = 0, right = len(s) - 1, 向中间移动
  • 简洁写法：s == s[::-1] 利用切片反转
  • s[::-1] 是字符串反转的惯用写法

第8题：九九乘法表

题目： 使用嵌套循环输出九九乘法表。

Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
#**********begin1**********
_______
#**********end1**********
    #**********begin2**********
    _______
    #**********end2**********
        print(f"{i}*{j}={i*j}", end="\t")
    #**********begin3**********
    _______
    #**********end3**********

✅ 填空答案

  • begin1： for i in range(1, 10):

  • begin2： for j in range(1, i + 1):

  • begin3： print()

完整正确代码

Python
1
2
3
4
for i in range(1, 10):           # 【填空1】外层循环：行号1~9
    for j in range(1, i + 1):    # 【填空2】内层循环：列号1~i
        print(f"{i}*{j}={i*j}", end="\t")
    print()                       # 【填空3】每行结束后换行

运行结果：

Text Only
1
2
3
4
5
6
7
8
9
1*1=1
2*1=2   2*2=4
3*1=3   3*2=6   3*3=9
4*1=4   4*2=8   4*3=12  4*4=16
5*1=5   5*2=10  5*3=15  5*4=20  5*5=25
6*1=6   6*2=12  6*3=18  6*4=24  6*5=30  6*6=36
7*1=7   7*2=14  7*3=21  7*4=28  7*5=35  7*6=42  7*7=49
8*1=8   8*2=16  8*3=24  8*4=32  8*5=40  8*6=48  8*7=56  8*8=64
9*1=9   9*2=18  9*3=27  9*4=36  9*5=45  9*6=54  9*7=63  9*8=72  9*9=81

解析：

  • begin1：for i in range(1, 10) 外层循环控制行号，从1到9
    • range(1, 10) 生成 1, 2, ..., 9
  • begin2：for j in range(1, i + 1) 内层循环控制每行的列数
    • 第1行输出1个式子（j从1到1）
    • 第2行输出2个式子（j从1到2）
    • 第i行输出i个式子（j从1到i）
    • 所以 range(1, i + 1) 是关键
  • begin3：print() 每行结束后换行
    • 内层循环中 end="\t" 使得同行式子不换行，用制表符分隔
    • 外层循环末尾需要一个空 print() 来换行

🔑 知识点：嵌套循环与九九乘法表

  • 嵌套循环：外层控制行，内层控制列
  • range(1, 10) 生成1到9的序列（不含10）
  • print(..., end="\t") 不换行，用制表符分隔
  • print() 输出空行（仅换行）
元素 作用
end="\t" 同行输出，制表符分隔
print() 换行
range(1, i+1) 第i行输出i个式子
📖 拓展
Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
# 方法2：完整矩形乘法表（9x9）
for i in range(1, 10):
    for j in range(1, 10):
        print(f"{i}*{j}={i*j:2d}", end="  ")
    print()

# 方法3：用 while 循环实现
i = 1
while i <= 9:
    j = 1
    while j <= i:
        print(f"{i}*{j}={i*j}", end="\t")
        j += 1
    print()
    i += 1

# 方法4：对齐优化版本
for i in range(1, 10):
    for j in range(1, i + 1):
        print(f"{j}x{i}={i*j:2d}", end="  ")
    print()

📌 记忆要点

  • 九九乘法表：外层 range(1, 10)，内层 range(1, i+1)
  • end="\t" 同行输出，print() 换行
  • 内层范围 i+1 是关键：第i行输出i个式子

第9题：冒泡排序基础版

题目： 使用冒泡排序对列表进行升序排列。

Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
lst = [64, 34, 25, 12, 22, 11, 90]
n = len(lst)
for i in range(n):
    for j in range(0, n - i - 1):
        #**********begin1**********
        _______
        #**********end1**********
            #**********begin2**********
            _______
            #**********end2**********
print("排序后:", lst)

✅ 填空答案

  • begin1： if lst[j] > lst[j + 1]:

  • begin2： lst[j], lst[j + 1] = lst[j + 1], lst[j]

完整正确代码

Python
1
2
3
4
5
6
7
lst = [64, 34, 25, 12, 22, 11, 90]
n = len(lst)
for i in range(n):
    for j in range(0, n - i - 1):
        if lst[j] > lst[j + 1]:                    # 【填空1】前大于后则交换
            lst[j], lst[j + 1] = lst[j + 1], lst[j]  # 【填空2】交换两元素
print("排序后:", lst)

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

解析：

  • begin1：if lst[j] > lst[j + 1] 判断相邻元素是否需要交换
    • 升序排列：前一个比后一个大时交换（大的往后"冒泡"）
    • 降序排列：改为 if lst[j] < lst[j + 1]
  • begin2：lst[j], lst[j + 1] = lst[j + 1], lst[j] Python 元组解包交换
    • 等价于 temp = lst[j]; lst[j] = lst[j+1]; lst[j+1] = temp
    • Python 的写法更简洁，无需临时变量
  • range(0, n - i - 1) 控制内层循环范围，每轮结束后末尾已排好，范围缩小

🔑 知识点：冒泡排序

  • 核心思想：相邻元素两两比较，大的往后换，每轮将最大值"冒泡"到末尾
  • 外层循环：for i in range(n) 控制轮数
  • 内层循环：for j in range(0, n - i - 1) 每轮比较范围递减
  • 时间复杂度：O(n^2)
轮次 比较范围 结果
第1轮 j: 0~5 最大值到末尾
第2轮 j: 0~4 次大值到倒数第二
... ... ...
📖 拓展
Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# 方法2：冒泡排序（带提前退出优化）
def bubble_sort(lst):
    n = len(lst)
    for i in range(n - 1):
        swapped = False
        for j in range(n - 1 - i):
            if lst[j] > lst[j + 1]:
                lst[j], lst[j + 1] = lst[j + 1], lst[j]
                swapped = True
        if not swapped:
            break
    return lst

# 方法3：降序排列
lst = [64, 34, 25, 12, 22, 11, 90]
n = len(lst)
for i in range(n):
    for j in range(0, n - i - 1):
        if lst[j] < lst[j + 1]:  # 改为 < 号
            lst[j], lst[j + 1] = lst[j + 1], lst[j]
print("降序:", lst)

# 方法4：使用内置排序
lst = [64, 34, 25, 12, 22, 11, 90]
lst.sort()           # 原地升序
lst.sort(reverse=True)  # 原地降序
new_lst = sorted(lst)   # 返回新列表

📌 记忆要点

  • 冒泡排序核心：相邻比较 lst[j] > lst[j+1]，大的往后交换
  • 交换写法：lst[j], lst[j+1] = lst[j+1], lst[j]（Python元组解包）
  • 升序用 >，降序用 <
  • 内层范围 n - i - 1：每轮少比较一个（末尾已排好）

第10题：文件读取与平均分计算

题目： 从文件中读取学生成绩（每行一个分数），计算平均分、最高分和最低分。

Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
scores = []
#**********begin1**********
_______
#**********end1**********
    for line in f:
        score = float(line.strip())
        #**********begin2**********
        _______
        #**********end2**********

if scores:
    avg = sum(scores) / len(scores)
    #**********begin3**********
    _______
    #**********end3**********
    print(f"平均分: {avg:.1f}, 最高分: {max_score}, 最低分: {min_score}")

✅ 填空答案

  • begin1： with open("scores.txt", "r", encoding="utf-8") as f:

  • begin2： scores.append(score)

  • begin3： max_score, min_score = max(scores), min(scores)

完整正确代码

Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
scores = []
with open("scores.txt", "r", encoding="utf-8") as f:  # 【填空1】打开文件读取
    for line in f:
        score = float(line.strip())
        scores.append(score)                            # 【填空2】添加到列表

if scores:
    avg = sum(scores) / len(scores)
    max_score, min_score = max(scores), min(scores)    # 【填空3】求最大最小值
    print(f"平均分: {avg:.1f}, 最高分: {max_score}, 最低分: {min_score}")

运行结果（假设文件内容为 85.5, 92.0, 78.5, 95.0, 88.0）：

Text Only
1
平均分: 87.8, 最高分: 95.0, 最低分: 78.5

解析：

  • begin1：with open("scores.txt", "r", encoding="utf-8") as f: 打开文件
    • "r" 只读模式，encoding="utf-8" 避免编码问题
    • with 语句自动关闭文件
  • begin2：scores.append(score) 将每个分数添加到列表中
    • float(line.strip()) 已将每行转为浮点数
    • 需要 append 到列表才能在后续使用
  • begin3：max_score, min_score = max(scores), min(scores) 计算最高和最低分
    • max() 返回列表中的最大值
    • min() 返回列表中的最小值
    • 用元组解包一行完成两个赋值
    • 等价写法：max_score = max(scores) + min_score = min(scores)

🔑 知识点：文件读取与列表统计

  • 文件读取 + 列表收集是常见模式：打开文件 → 逐行读取 → 转换类型 → append到列表
  • 常用统计函数：
函数 功能 示例
sum(lst) 求和 sum([85, 92, 78]) → 255
len(lst) 长度 len([85, 92, 78]) → 3
max(lst) 最大值 max([85, 92, 78]) → 92
min(lst) 最小值 min([85, 92, 78]) → 78
  • f"{avg:.1f}" 格式化输出保留1位小数
  • if scores: 检查列表非空，避免空列表时 sum/len 报错
📖 拓展
Python
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# 方法2：手动计算最大最小值（不使用内置函数）
if scores:
    total = 0
    max_score = scores[0]
    min_score = scores[0]
    for s in scores:
        total += s
        if s > max_score:
            max_score = s
        if s < min_score:
            min_score = s
    avg = total / len(scores)
    print(f"平均分: {avg:.1f}, 最高分: {max_score}, 最低分: {min_score}")

# 方法3：一行读取所有成绩
with open("scores.txt", "r", encoding="utf-8") as f:
    scores = [float(line.strip()) for line in f]

# 方法4：使用 statistics 模块
import statistics
if scores:
    avg = statistics.mean(scores)
    print(f"平均分: {avg:.1f}")
    print(f"中位数: {statistics.median(scores)}")

# 处理文件中可能有空行的情况
with open("scores.txt", "r", encoding="utf-8") as f:
    scores = [float(line.strip()) for line in f if line.strip()]

📌 记忆要点

  • 文件读取模式：with open("文件", "r", encoding="utf-8") as f:
  • 收集数据到列表：scores.append(score)
  • 列表统计四件套：sum(), len(), max(), min()
  • 格式化保留小数：f"{value:.1f}" 保留1位
  • 空列表检查：if scores: 避免除零错误