期末模拟练习

原创于 2026-06-27 22:15:36 发布 · 259 阅读

9 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#python

python的学习小汇总专栏收录该内容

20 篇文章

订阅专栏

一、读程序写结果（共10题）

请阅读以下程序，写出运行结果。

第1题（算术运算）

# print() 输出内容到屏幕上
# 浮点数除法，结果为浮点数
print(15 / 4)
# 整除运算，结果为整数（向下取整）
print(15 // 4)
# 取余运算，求余数
print(15 % 4)
# 幂运算，2的3次方
print(2 ** 3)

答案：

解析：

15 / 4 = 3.75（普通除法，返回浮点数）
15 // 4 = 3（整除，商向下取整得3）
15 % 4 = 3（取余，15除以4余3）
2 ** 3 = 8（幂运算，2的3次方等于8）

第2题（字符串索引）

# 声明字符串变量 s，赋值为 "Hello Python"
s = "Hello Python"
# 索引访问：s 中下标为0的字符（第一个字符）
print(s[0])
# 索引访问：s 中下标为-1的字符（倒数第一个字符）
print(s[-1])
# 索引访问：s 中下标为6的字符
print(s[6])
# 切片操作：取 s 中下标 0到4 的子串（左闭右开）
print(s[0:5])

答案：

H
n
P
Hello

解析：

s[0] 取字符串第1个字符，即 'H'
s[-1] 用负索引取倒数第1个字符，即 'n'
s[6] 取下标为6的字符，字符串索引从0开始：H(0)e(1)l(2)l(3)o(4) (5)P(6)，即 'P'
s[0:5] 切片取下标0至4（不含5）的子串，即 'Hello'

第3题（字符串方法）

# 声明字符串变量 s，赋值为 "  Hello World  "（首尾带空格）
s = "  Hello World  "
# strip() 去除首尾空白字符后输出
print(s.strip())
# upper() 将所有字母转为大写后输出
print(s.upper())
# split() 按空白字符分割字符串，返回列表后输出
print(s.split())

答案：

Hello World
  HELLO WORLD  
['Hello', 'World']

解析：

strip() 去除首尾空格，中间空格保留，输出 Hello World
upper() 将所有小写字母转为大写，输出 HELLO WORLD （空格不变）
split() 默认按空白字符分割，且会合并连续空白，返回列表 ['Hello', 'World']

第4题（列表操作）

# 创建列表 lst，初始元素为 [1, 2, 3]
lst = [1, 2, 3]
# append() 在列表末尾追加元素 4
lst.append(4)
# insert(1, 10) 在下标1的位置插入元素10
lst.insert(1, 10)
# print() 输出内容到屏幕上
print(lst)
# len() 获取列表长度后输出
print(len(lst))

答案：

[1, 10, 2, 3, 4]
5

解析：

初始列表 [1, 2, 3]
append(4) 后变为 [1, 2, 3, 4]
insert(1, 10) 在下标1位置插入10，原下标1及其后的元素全部右移，变为 [1, 10, 2, 3, 4]
len(lst) 返回列表元素个数为5

第5题（字典操作）

# 创建字典 d，包含键 "a" 和 "b"
d = {"a": 1, "b": 2}
# 为字典新增键值对 "c": 3
d["c"] = 3
# get("d", 0) 获取键"d"的值，若不存在则返回默认值0
print(d.get("d", 0))
# in 运算符：判断 "a" 是否为字典 d 的键
print("a" in d)

答案：

0
True

解析：

字典 d 当前有键 "a", "b", "c"，没有 "d"
d.get("d", 0) 键 "d" 不存在，返回默认值 0
"a" in d 判断 "a" 是否为字典的键，存在则返回 True

第6题（if-elif 多分支）

# 声明整型变量 score，赋值为 78
score = 78
# if-elif-else 多分支判断分数等级
if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 70:
    print("中等")
elif score >= 60:
    print("及格")
else:
    print("不及格")

答案：

中等

解析：

score = 78，先判断 score >= 90：不成立
再判断 score >= 80：不成立
再判断 score >= 70：成立，执行 print("中等")，后续分支不再执行

第7题（简单函数）

# 定义函数 add，接收两个参数 x 和 y
def add(x, y):
    # 返回 x 与 y 的和
    return x + y

# 调用 add(3, 5)，将返回值输出到屏幕
print(add(3, 5))

答案：

解析：

add(3, 5) 调用函数，传入实参 x=3, y=5
函数返回 3 + 5 = 8，print() 输出结果

第8题（for 循环累计）

# 声明整型变量 s，赋值为 0（累加器）
s = 0
# for 循环：遍历 range(1, 6) 中的每个元素（即 1,2,3,4,5）
for i in range(1, 6):
    # 将 s 进行 += 运算并赋值回自身
    s += i
# print() 输出内容到屏幕上
print(s)

答案：

解析：

range(1, 6) 生成整数序列 1, 2, 3, 4, 5
循环累加：s = 0 + 1 + 2 + 3 + 4 + 5 = 15
最终 print(s) 输出 15

第9题（嵌套循环输出图案）

# for 循环：遍历 range(1, 6) 中的每个元素（控制行数，共5行）
for i in range(1, 6):
    # for 循环：遍历 range(i) 中的每个元素（第i行输出i个星号）
    for j in range(i):
        # 输出星号，end="" 表示不换行
        print("*", end="")
    # 内层循环结束后换行
    print()

答案：

*
**
***
****
*****

解析：

外层循环 i 控制行数，从1到5共5行
内层循环 j 控制每行输出的星号个数：第 i 行输出 i 个星号
end="" 让 print() 输出后不换行
内层循环结束后的 print() 起换行作用
形成直角三角形的星号图案

第10题（类对象）

# 定义 Counter 类
class Counter:
    # __init__ 构造方法，初始化计数器
    def __init__(self):
        # 给当前对象设置属性 count，初始值为 0
        self.count = 0

    # add 方法：接收参数 n，将计数累加 n
    def add(self, n):
        # 将传入的 n 累加到 count 属性
        self.count += n

    # get 方法：返回当前 count 值
    def get(self):
        # 返回 count 属性值
        return self.count

# 创建 Counter 类的实例对象 c
c = Counter()
# 调用 add(3) 方法，count 变为 3
c.add(3)
# 调用 add(5) 方法，count 变为 8
c.add(5)
# 调用 add(2) 方法，count 变为 10
c.add(2)
# 调用 get() 方法，获取当前 count 值并输出
print(c.get())

答案：

解析：

创建 Counter 对象时，self.count 初始化为0
先后调用 add(3)、add(5)、add(2)，累计 0 + 3 + 5 + 2 = 10
c.get() 返回当前 count 值10，print() 输出

二、补全程序题（共10题）

请在下划线处填上正确的代码，使程序完整且能正常运行。

第1题（求1-100偶数和）

补全程序，计算1到100之间所有偶数的和。

# 声明整型变量 total，赋值为 0（累加器）
total = 0
# for 循环：遍历 range(________, ________, ________) 中的每个元素（从2开始，步长为2）
for i in range(________, ________, ________):
    # 将 total 进行 += 运算并赋值回自身
    total ________ i
# print() 输出内容到屏幕上
print(total)

答案：

第1空：2
第2空：101
第3空：2
第4空：+=

解析：

range(2, 101, 2) 从2开始到100（不含101），步长为2，产生序列 2, 4, 6, ..., 100
total += i 将每个偶数累加到 total 中
最终得到 1-100 所有偶数的和 = 2550

第2题（列表求最大值）

补全程序，找出列表中的最大值。

# 创建列表 lst，包含5个整数元素
lst = [3, 9, 2, 7, 5]
# 声明整型变量 max_val，赋值为列表的 ________ 个元素
max_val = lst[________]
# for 循环：遍历 range(1, ________) 中的每个元素（从下标1开始遍历）
for i in range(1, ________):
    # 判断 lst[i] 是否 ________ max_val
    if lst[i] ________ max_val:
        # 将 ________ 的值赋给 max_val
        max_val = ________
# print() 输出内容到屏幕上
print(max_val)

答案：

第1空：0（取列表第一个元素 lst[0]）
第2空：len(lst)
第3空：>
第4空：lst[i]

解析：

max_val = lst[0] 先假设第一个元素最大
for i in range(1, len(lst)) 从下标1遍历到末尾
遇到 lst[i] > max_val 则更新 max_val = lst[i]
遍历结束后 max_val 为最大值 9

第3题（字典字符统计）

补全程序，统计字符串中每个字符出现的次数。

# 声明字符串变量 s，赋值为 "hello"
s = "hello"
# 创建 ________ 字典 d，用 {} 表示
d = ________
# for 循环：遍历字符串 s 中的每个字符
for ch in s:
    # 用 get 方法统计次数，键不存在时默认值为 ________
    d[ch] = d.get(ch, ________) + 1
# print() 输出内容到屏幕上
print(d)

答案：

第1空：{}
第2空：0

解析：

d = {} 创建空字典用于存储字符计数
d.get(ch, 0) 尝试获取键 ch 的值，若不存在则返回默认值 0
d[ch] = d.get(ch, 0) + 1 将该字符的计数+1后写回字典
最终输出 {'h': 1, 'e': 1, 'l': 2, 'o': 1}

第4题（字符串反转）

补全程序，将字符串反转输出。

# 声明字符串变量 s，赋值为 "Python"
s = "Python"
# 切片操作：步长为-1，从后往前取字符实现反转
result = s[________]
# print() 输出内容到屏幕上
print(result)

答案：

第1空：::-1

解析：

s[::-1] 切片语法：起始和结束省略（取全部），步长为-1（反向）
等效于从最后一个字符开始依次向前取，实现反转
输出结果为 nohtyP

第5题（判断素数）

补全程序，判断一个数是否为素数。

# 声明整型变量 n，赋值为 17
n = 17
# 声明布尔型变量 flag，赋值为 ________（假设 n 是素数）
flag = ________
# for 循环：遍历 range(2, int(n**0.5)+1) 中的每个元素（检查因子）
for i in range(2, int(n ** 0.5) + 1):
    # if 判断 n % i == ________ 是否成立（i 能否整除 n）
    if n % i ________ 0:
        # 将 flag 设为 ________（说明不是素数）
        flag = ________
        # 终止循环
        break
# print() 输出内容到屏幕上
print("是素数" if flag else "不是素数")

答案：

第1空：True
第2空：==
第3空：False

解析：

flag = True 先假设 n 是素数
从2到sqrt(n)检查是否存在因子：n % i == 0 表示 i 能整除 n
若找到因子，flag = False 并 break 跳出循环
17没有因子（除了1和自身），flag 保持 True，输出 “是素数”

第6题（文件读取行数）

补全程序，读取文件并统计行数。

# 用 ________ 语句打开文件，文件名为 "data.txt"，模式为只读
with ________("data.txt", "r", encoding="utf-8") as f:
    # f.________() 读取文件所有行，返回列表
    lines = f.________()
# ________ 函数获取行数并输出
print(________(lines))

答案：

第1空：open
第2空：readlines
第3空：len

解析：

with open("data.txt", "r", encoding="utf-8") as f 以只读方式打开文件
f.readlines() 读取所有行，返回一个列表，每个元素为一行字符串
len(lines) 获取列表长度，即文件总行数
with 语句会在代码块结束后自动关闭文件

第7题（函数定义填充）

补全函数定义，实现两数相加。

# def 定义函数 ________，接收两个参数 a 和 b
def ________(a, b):
    # ________ 表达式计算 a + b 并返回
    ________ a + b

# 调用函数，输出结果
print(add(3, 4))

答案：

第1空：add
第2空：return

解析：

def add(a, b) 定义名为 add 的函数，接收两个形参
return a + b 计算两数之和并返回结果
add(3, 4) 调用返回7，print() 输出7

第8题（列表生成式）

补全程序，用列表生成式创建1-10中所有偶数的列表。

# 列表生成式：对 range(1, 11) 中 ________ 成立的元素生成列表
lst = [________ for i in range(1, 11) ________ i % 2 == 0]
# print() 输出内容到屏幕上
print(lst)

答案：

第1空：i
第2空：if

解析：

[i for i in range(1, 11) if i % 2 == 0] 列表生成式语法
for i in range(1, 11) 遍历1到10
if i % 2 == 0 筛选条件：只保留偶数
i 是最前面要放入列表的元素
输出结果为 [2, 4, 6, 8, 10]

第9题（冒泡排序填空）

补全冒泡排序算法，对列表进行升序排序。

# 定义函数 bubble_sort，接收一个列表参数
def bubble_sort(lst):
    # len() 获取列表长度
    n = len(lst)
    # 外层循环：控制排序趟数，共 n-1 趟
    for i in range(________):
        # 内层循环：每趟比较相邻元素，范围逐渐缩小
        for j in range(________):
            # 如果前一个元素 ________ 后一个元素，则交换
            if lst[j] ________ lst[j + 1]:
                # 交换两元素位置
                lst[j], lst[j + 1] = ________, ________

# 测试列表
nums = [5, 2, 8, 1, 9]
# 调用冒泡排序函数
bubble_sort(nums)
# print() 输出内容到屏幕上
print(nums)

答案：

第1空：n - 1
第2空：n - 1 - i
第3空：>
第4空：lst[j + 1]
第5空：lst[j]

解析：

外层循环 for i in range(n - 1) 控制趟数：n个元素最多需要n-1趟
内层循环 for j in range(n - 1 - i) 每趟比较时已排好的元素不再参与
if lst[j] > lst[j + 1] 升序排序时，前大后小就交换
lst[j], lst[j + 1] = lst[j + 1], lst[j] Python 特色交换写法
最终输出 [1, 2, 5, 8, 9]

第10题（文件读取填空）

完善以下程序，读取文件 data.txt 的内容并统计行数。

# 使用 with 语句打开文件，模式为只读
with open("data.txt", ________) as f:
    # 读取所有行，返回列表
    lines = f.________()
    # 输出文件总行数
    print("总行数：", ________(lines))

答案：

第1空：'r'（只读模式）
第2空：readlines()（读取所有行返回列表）
第3空：len()（计算列表长度即行数）

解析：with open() 自动管理文件关闭；readlines() 一次读取所有行；len() 统计列表元素个数。

三、编程题（共10题）

请编写完整程序解决以下问题。每题附参考代码（带逐行注释）。

第1题（计算1到100的和）

编写程序，计算1到100所有整数的和并输出。

参考代码：

# 声明整型变量 total，赋值为 0（累加器）
total = 0
# for 循环：遍历 range(1, 101) 中的每个元素（1到100）
for i in range(1, 101):
    # 将 total 进行 += 运算并赋值回自身
    total += i
# print() 输出内容到屏幕上
print(total)

输出结果：

另一种解法（使用公式）：

n = 100
total = n * (n + 1) // 2  # 等差数列求和公式：n(n+1)/2
print(total)

第2题（输出100以内7的倍数）

编写程序，输出100以内所有7的倍数。

参考代码：

# for 循环：遍历 range(1, 101) 中的每个元素
for i in range(1, 101):
    # if 判断 i % 7 == 0 是否成立（i 是否为7的倍数）
    if i % 7 == 0:
        # print() 输出内容到屏幕上
        print(i)

输出结果：

另一种解法（使用列表生成式）：

# 列表生成式一行搞定
multiples = [i for i in range(7, 100, 7)]
print(multiples)
# 或者只打印
print([i for i in range(1, 100) if i % 7 == 0])

第3题（判断素数）

编写程序，输入一个正整数 n，判断它是否为素数。

参考代码：

# input() 接收用户输入，int() 转为整数
n = int(input("请输入一个正整数: "))
# 声明布尔型变量 is_prime，赋值为 True（先假设是素数）
is_prime = True
# if 判断 n <= 1 是否成立（1及以下的数不是素数）
if n <= 1:
    # 将 is_prime 设为 False
    is_prime = False
else:
    # for 循环：检查2到sqrt(n)之间是否存在因子
    for i in range(2, int(n ** 0.5) + 1):
        # if 判断 n % i == 0 是否成立（i能整除n）
        if n % i == 0:
            # 将 is_prime 设为 False（不是素数）
            is_prime = False
            # 终止循环
            break
# print() 输出结果到屏幕上
print("是素数" if is_prime else "不是素数")

另一种解法（函数封装）：

def is_prime(n):
    if n < 2:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

n = int(input("请输入一个正整数："))
print("是素数" if is_prime(n) else "不是素数")

第4题（统计字母和数字个数）

编写程序，输入一个字符串，统计其中字母和数字的个数。

参考代码：

# input() 接收用户输入的字符串
s = input("请输入一个字符串: ")
# 声明整型变量 letters，赋值为 0（字母计数器）
letters = 0
# 声明整型变量 digits，赋值为 0（数字计数器）
digits = 0
# for 循环：遍历字符串 s 中的每个字符
for ch in s:
    # if 判断 ch 是否为字母
    if ch.isalpha():
        # 字母计数 +1
        letters += 1
    # elif 判断 ch 是否为数字
    elif ch.isdigit():
        # 数字计数 +1
        digits += 1
# print() 输出内容到屏幕上
print(f"字母个数: {letters}")
# print() 输出内容到屏幕上
print(f"数字个数: {digits}")

另一种解法（使用字符串方法）：

s = input("请输入一个字符串：")
letters = sum(1 for ch in s if ch.isalpha())
digits = sum(1 for ch in s if ch.isdigit())
print(f"字母个数：{letters}")
print(f"数字个数：{digits}")

第5题（计算阶乘）

编写程序，输入一个正整数 n，输出 n 的阶乘（n!）。

参考代码：

# input() 接收用户输入，int() 转为整数
n = int(input("请输入一个正整数: "))
# 声明整型变量 result，赋值为 1（阶乘初值）
result = 1
# for 循环：遍历 range(1, n+1) 中的每个元素（1到n）
for i in range(1, n + 1):
    # 将 result 进行 *= 运算并赋值回自身
    result *= i
# print() 输出内容到屏幕上
print(f"{n}! = {result}")

另一种解法（使用 math 模块）：

import math
n = int(input("请输入一个正整数："))
print(math.factorial(n))

第6题（定义判断偶数的函数）

编写程序，定义一个函数判断一个数是否为偶数，并调用测试。

参考代码：

# 定义函数 is_even，接收一个参数 num
def is_even(num):
    # 返回 num % 2 == 0 的布尔值（True表示偶数）
    return num % 2 == 0

# 调用函数并输出结果
# print() 输出内容到屏幕上
print(is_even(4))
# print() 输出内容到屏幕上
print(is_even(7))

输出结果：

True
False

另一种解法（使用 lambda）：

is_even = lambda x: x % 2 == 0
n = int(input("请输入一个整数："))
print("偶数" if is_even(n) else "奇数")

第7题（学生成绩平均分）

编写程序，用列表存储5个学生的成绩，计算并输出平均分。

参考代码：

# 创建列表 scores，存储5个学生的成绩
scores = [85, 92, 78, 90, 88]
# 声明整型变量 total，赋值为 0（累加器）
total = 0
# for 循环：遍历列表 scores 中的每个元素
for score in scores:
    # 将 total 进行 += 运算并赋值回自身
    total += score
# 用总分除以人数得到平均分
average = total / len(scores)
# print() 输出内容到屏幕上，保留2位小数
print(f"平均分: {average:.2f}")

输出结果：

平均分: 86.60

另一种解法（使用 sum 函数）：

scores = []
for i in range(5):
    score = float(input(f"请输入第{i+1}个学生的成绩："))
    scores.append(score)

average = sum(scores) / len(scores)
print(f"平均分为：{average:.2f}")

第8题（删除列表中的重复元素）

输入一个列表，删除其中的重复元素，保留原有顺序，输出处理后的列表。

参考代码：

# 从键盘输入列表，用 eval 解析
lst = eval(input("请输入一个列表："))

# 创建新列表存储不重复的元素
result = []
for item in lst:
    if item not in result:
        result.append(item)

print("去重后的列表：", result)

另一种解法（使用集合，不保留顺序）：

lst = eval(input("请输入一个列表："))
# set 自动去重，再转回 list
result = list(set(lst))
print("去重后的列表：", result)
# 注意：set 不保留原顺序！

再一种解法（保留顺序的简洁写法）：

lst = eval(input("请输入一个列表："))
seen = set()
result = []
for item in lst:
    if item not in seen:
        seen.add(item)
        result.append(item)
print("去重后的列表：", result)

第9题（统计单词出现次数）

编写程序，输入一个字符串，用字典统计每个单词出现的次数，输出统计结果。

参考代码：

# input() 接收用户输入的字符串
text = input("请输入一段英文: ")
# split() 按空白字符分割字符串，返回单词列表
words = text.split()
# 创建空字典 word_count，用 {} 表示
word_count = {}
# for 循环：遍历单词列表 words 中的每个元素
for word in words:
    # 用 get 方法统计次数：键不存在则默认值为0，再加1
    word_count[word] = word_count.get(word, 0) + 1
# for 循环：遍历 word_count 中的每个键值对
for word, count in word_count.items():
    # print() 输出单词及其出现次数
    print(f"{word}: {count}")

另一种解法（使用 collections.Counter）：

from collections import Counter

s = input("请输入一个字符串：")
words = s.split()
word_count = Counter(words)
print(word_count)

第10题（律师事务所诉讼费计算）

某律师事务所本月代理了 n 个案件，需按标准计算每个案件的诉讼费。诉讼费收取标准：

标的额 ≤ 1万元，收50元
1万 < 标的额 ≤ 10万，超出1万部分按2.5%收取
10万 < 标的额 ≤ 20万，超出10万部分按2%收取
标的额 > 20万，超出20万部分按1.5%收取

请从键盘输入案件数量 n，使用循环结构依次输入每个案件的标的额（元），计算并输出每个案件的诉讼费（保留2位小数）及本月诉讼费总收入（保留2位小数）。

参考代码：

# 从键盘输入本月案件数量，转换为整数
n = int(input("请输入本月案件数量："))

# 初始化本月诉讼费总收入为0.0
total_fee = 0.0

# 循环n次，依次处理每个案件
for i in range(1, n + 1):
    # 输入第i个案件的标的额（元），转换为浮点数
    amount = float(input(f"请输入第{i}个案件标的额（元）："))

    # 根据标的额分段计算诉讼费
    if amount <= 10000:
        fee = 50
    elif amount <= 100000:
        fee = 50 + (amount - 10000) * 0.025
    elif amount <= 200000:
        fee = 50 + 90000 * 0.025 + (amount - 100000) * 0.02
    else:
        fee = 50 + 90000 * 0.025 + 100000 * 0.02 + (amount - 200000) * 0.015

    # 累加到本月总收入
    total_fee += fee

    # 输出该案件诉讼费，保留2位小数
    print(f"第{i}个案件诉讼费：{fee:.2f}元")

# 输出本月诉讼费总收入，保留2位小数
print(f"本月诉讼费总收入：{total_fee:.2f}元")

另一种解法（使用列表存储费率，更易于扩展）：

n = int(input("请输入本月案件数量："))
total = 0.0

# 分段费率表：(上限, 基础费, 费率)
tiers = [
    (10000, 50, 0),
    (100000, 50, 0.025),
    (200000, 50 + 90000*0.025, 0.02),
    (float('inf'), 50 + 90000*0.025 + 100000*0.02, 0.015)
]

for i in range(1, n + 1):
    amount = float(input(f"请输入第{i}个案件标的额（元）："))
    for limit, base, rate in tiers:
        if amount <= limit:
            if rate == 0:
                fee = base
            else:
                fee = base + (amount - prev_limit) * rate
            break
        prev_limit = limit
    total += fee
    print(f"第{i}个案件诉讼费：{fee:.2f}元")

print(f"本月诉讼费总收入：{total:.2f}元")

第11题（勾股数）

勾股数是指满足 a² + b² = c² 的正整数三元组 (a, b, c)，且 a < b < c。请编写程序，输入最大边长上限 n，输出所有满足条件的勾股数。

参考代码：

n = int(input())  # 输入最大边长上限

lt = []
for c in range(1, n + 1):
    for b in range(1, c):
        for a in range(1, b):
            if a ** 2 + b ** 2 == c ** 2:
                lt.append((a, b, c))

print(len(lt))
print(lt)

另一种解法（使用列表生成式 + 优化范围）：

n = int(input())

# 利用 a < b < c 和 a² + b² = c² 的关系优化
# c 最大为 n，b 最大为 c-1，a 最大为 b-1
lt = [(a, b, c) for c in range(1, n+1)
      for b in range(1, c)
      for a in range(1, b)
      if a**2 + b**2 == c**2]

print(len(lt))
print(lt)

进一步优化（减少循环次数）：

n = int(input())
lt = []
for c in range(5, n+1):  # 最小勾股数 3,4,5，所以 c 从 5 开始
    for b in range(2, c):
        a = int((c**2 - b**2) ** 0.5)
        if a < b and a > 0 and a**2 + b**2 == c**2:
            lt.append((a, b, c))
print(len(lt))
print(lt)

第12题（病虫害传播模拟）

某农田发现病虫害，初始感染植株数为10株。每过一天，新增感染植株数为当前已感染植株数的30%（向下取整），同时农民每天会清除5株病株。请自定义函数 disease_spread(days)，输入天数，返回每天结束时的感染植株数。若某天感染植株数降为0，则提前终止并提示"病虫害已清除"。主程序输入监测天数，调用函数输出每天的感染情况。

参考代码：

import math

def disease_spread(days):
    """
    迭代计算病虫害传播情况
    参数days：计划监测天数
    返回：实际经历天数（若提前清除则小于days）
    """
    # 初始感染植株数
    infected = 10
    print(f"初始感染：{infected}株")

    # 迭代每一天
    for day in range(1, days + 1):
        # 计算新增感染：当前感染数的30%，向下取整
        new_infected = int(infected * 0.3)
        # 更新感染数：原有 + 新增 - 清除
        infected = infected + new_infected - 5

        # 若感染数降为0或负数，置为0并提前结束
        if infected <= 0:
            infected = 0
            print(f"第{day}天结束，感染{infected}株")
            print(f"病虫害已清除，共历时{day}天")
            return day  # 提前返回实际天数

        # 输出当天结束时的感染数
        print(f"第{day}天结束，感染{infected}株")

    # 若未提前清除，返回计划天数
    return days

# 主程序
# 输入监测天数
n = int(input("请输入监测天数："))
# 调用迭代函数
actual_days = disease_spread(n)

# 若未提前清除，输出提示
if actual_days == n:
    print("监测期结束，最终感染株数未清零")

另一种解法（不使用函数，直接写主逻辑）：

infected = 10
print(f"初始感染：{infected}株")

days = int(input("请输入监测天数："))
cleared = False

for day in range(1, days + 1):
    new_infected = int(infected * 0.3)
    infected = infected + new_infected - 5
    if infected <= 0:
        infected = 0
        print(f"第{day}天结束，感染{infected}株")
        print(f"病虫害已清除，共历时{day}天")
        cleared = True
        break
    print(f"第{day}天结束，感染{infected}株")

if not cleared:
    print("监测期结束，最终感染株数未清零")

第13题（家电销售排序 + 文件写入）

某电商平台双十一前十名的各家电品牌销售指数存放在一个二维列表中，具体为：

[["万和", 89.8], ["容声", 91.4], ["老板电器", 88.3], ["科沃斯", 88.7],
 ["米家", 89.1], ["戴森", 91.1], ["美的", 88.8], ["西门子", 92.5],
 ["海尔", 96.6], ["九阳", 90.3]]

请编程用排序算法实现根据各品牌销售指数的升序排列，并将结果写入文件 px.txt 中。

参考代码：

# 原始数据：品牌及销售指数
sales_data = [
    ["万和", 89.8],
    ["容声", 91.4],
    ["老板电器", 88.3],
    ["科沃斯", 88.7],
    ["米家", 89.1],
    ["戴森", 91.1],
    ["美的", 88.8],
    ["西门子", 92.5],
    ["海尔", 96.6],
    ["九阳", 90.3]
]

def selection_sort_asc(data):
    """选择排序（升序），按每个子列表的第2个元素（销售指数）排序"""
    n = len(data)
    for i in range(n):
        # 假设当前位置为最小值索引
        min_idx = i
        # 在未排序部分查找真正的最小值索引
        for j in range(i + 1, n):
            if data[j][1] < data[min_idx][1]:
                min_idx = j
        # 如果最小值索引发生变化，交换两个元素
        if min_idx != i:
            data[i], data[min_idx] = data[min_idx], data[i]

# 执行排序（升序）
selection_sort_asc(sales_data)

# 将排序后的结果写入文件 px.txt
with open("px.txt", "w", encoding="utf-8") as f:
    for brand, score in sales_data:
        # 每行格式：品牌,指数（保留一位小数）
        f.write(f"{brand},{score:.1f}\n")

print("排序完成，结果已写入 px.txt")

另一种解法（使用 sorted 函数 + lambda）：

sales_data = [
    ["万和", 89.8], ["容声", 91.4], ["老板电器", 88.3],
    ["科沃斯", 88.7], ["米家", 89.1], ["戴森", 91.1],
    ["美的", 88.8], ["西门子", 92.5], ["海尔", 96.6], ["九阳", 90.3]
]

# sorted 返回新列表，不改变原数据
sorted_data = sorted(sales_data, key=lambda x: x[1])

with open("px.txt", "w", encoding="utf-8") as f:
    for brand, score in sorted_data:
        f.write(f"{brand},{score:.1f}
")

print("排序完成，结果已写入 px.txt")