根据老师通知整理：选择题 20 题、判断题 10 题、程序设计题 4 题。程序题重点：密码安全审计工具、秒数转换器、圆的几何计算程序、学生信息管理系统（面向对象）。

---

0. 复习优先级

必须会默写

1. input() 输入、int() / float() 类型转换、print(f"...{变量:.2f}") 格式化输出。
2. if / elif / else 条件判断。
3. for / while 循环，break 和 continue。
4. 函数定义：def 函数名(参数):、return。
5. 类和对象：class、__init__、self、实例属性、实例方法。
6. 四个程序设计题的标准结构。

选择题和判断题重点

选择题里有读代码题，所以要特别注意：

• input() 得到的一定是字符串。
• / 的结果一定是浮点数，哪怕 4 / 2 结果也是 2.0。
• // 是整除，向负无穷取整：-17 // 5 == -4。
• % 是取余，不要写成 &。17 % 5 == 2。
• ** 是幂运算，2 ** 3 ** 2 == 512，因为等价于 2 ** (3 ** 2)。
• and 和 or 有短路求值。
• if name: 可以判断字符串是否非空。
• range(5) 是 0, 1, 2, 3, 4，不包含 5。
• 切片左闭右开："Python"[0:2] == "Py"。
• s[::-1] 是字符串反转。
• 判断 None 推荐用 is None。
• 函数没有 return 时默认返回 None。
• 类方法的第一个参数必须写 self。

---

1. 程序设计题一：密码安全审计工具

1.1 考点

• 字符串遍历。
• len() 判断长度。
• any() 判断是否存在某类字符。
• string.ascii_uppercase、string.ascii_lowercase、string.digits、string.punctuation。
• 字典保存规则结果。
• 函数拆分：输入、检测、评分、建议、报告。
• 文件追加写入：open(..., "a", encoding="utf-8")。
• datetime 生成时间戳。

1.2 必背核心代码

# datetime 用来获取当前审计时间
import datetime
# string 模块提供大小写字母、数字、标点符号等字符集合
import string

# 定义常量，后面如果规则变化，只需要改这里
MIN_LENGTH = 8
MAX_SCORE = 100
LOG_FILE_NAME = "audit_log.txt"


def check_complexity(password):
    """
    功能：检查密码复杂度
    参数：password 是用户输入的密码字符串
    返回：rules 字典，记录每条规则是否满足
    """
    rules = {
        # len(password) 获取字符串长度
        "has_length": len(password) >= MIN_LENGTH,
        # any(...) 表示只要有一个字符满足条件，结果就是 True
        "has_upper": any(ch in string.ascii_uppercase for ch in password),
        "has_lower": any(ch in string.ascii_lowercase for ch in password),
        "has_digit": any(ch in string.digits for ch in password),
        "has_symbol": any(ch in string.punctuation for ch in password),
    }
    return rules


def calculate_score(rules):
    """
    功能：根据规则检查结果计算分数
    参数：rules 是 check_complexity 返回的字典
    返回：score，最高不超过 MAX_SCORE
    """
    score = 0
    # 每满足一项规则就加对应分数
    if rules["has_length"]:
        score += 25
    if rules["has_upper"]:
        score += 15
    if rules["has_lower"]:
        score += 15
    if rules["has_digit"]:
        score += 15
    if rules["has_symbol"]:
        score += 30
    # min() 防止分数超过 100
    return min(score, MAX_SCORE)


def get_advice(score):
    """功能：根据分数给出文字建议"""
    if score >= 80:
        return "密码强度优秀"
    elif score >= 60:
        return "密码强度一般，建议增加字符类型"
    else:
        return "密码太弱，建议至少8位并包含大小写、数字和符号"


def generate_report(password, score, rules):
    """
    功能：生成审计报告，先打印到屏幕，再写入日志文件
    """
    # strftime 用来把时间格式化成 年-月-日 时:分:秒
    timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")

    # 用列表保存每一行报告，方便统一打印和写入文件
    lines = [
        f"审计时间：{timestamp}",
        f"密码长度：{len(password)}",
        f"长度达标：{rules['has_length']}",
        f"包含大写字母：{rules['has_upper']}",
        f"包含小写字母：{rules['has_lower']}",
        f"包含数字：{rules['has_digit']}",
        f"包含特殊符号：{rules['has_symbol']}",
        f"最终得分：{score}",
        f"建议：{get_advice(score)}",
    ]

    # "\n".join(lines) 表示用换行符把列表中的字符串连接起来
    print("\n".join(lines))

    # "a" 是追加模式，不会覆盖原来的日志
    # encoding="utf-8" 防止中文乱码
    with open(LOG_FILE_NAME, "a", encoding="utf-8") as file:
        for line in lines:
            file.write(line + "\n")
        file.write("-" * 30 + "\n")


def main():
    """主函数：负责调用上面的各个功能模块"""
    # input() 获取的永远是字符串
    password = input("请输入要检测的密码：")

    # 空字符串会被当作 False，所以 not password 可以判断是否为空
    if not password:
        print("密码不能为空")
        return

    # 先检测规则，再计算分数，最后生成报告
    rules = check_complexity(password)
    score = calculate_score(rules)
    generate_report(password, score, rules)


# 程序入口：只有直接运行本文件时，才会执行 main()
if __name__ == "__main__":
    main()

1.3 容易扣分点

• 忘记 import string 或 import datetime。
• 把 input() 得到的内容当成数字处理。
• 检测字符时只判断第一个字符，没有遍历整个密码。
• 写文件时使用 "w" 导致覆盖日志；审计日志更适合 "a" 追加。
• 当前课程文件 week3/password_audit.py 里有一处笔记残留，正确写法应是：

if any(char in string.ascii_uppercase for char in password):
    rules["has_upper"] = True

---

2. 程序设计题二：秒数转换器

2.1 考点

• input() 转 int。
• 整除 //。
• 取余 %。
• 分步计算：先算小时，再算剩余秒数，再算分钟和秒。

2.2 必背核心代码

def convert_seconds(total_seconds):
    """
    功能：把总秒数转换成 时、分、秒
    参数：total_seconds 是总秒数，整数
    返回：hours, minutes, seconds 三个整数
    """
    # 1小时 = 3600秒，用整除 // 得到完整的小时数
    hours = total_seconds // 3600

    # 用取余 % 得到去掉完整小时后还剩多少秒
    remaining = total_seconds % 3600

    # 1分钟 = 60秒，在剩余秒数中计算完整分钟数
    minutes = remaining // 60

    # 再取余，得到最后不足1分钟的秒数
    seconds = remaining % 60

    return hours, minutes, seconds


def main():
    # input() 返回字符串，要先用 int() 转成整数才能计算
    total_seconds = int(input("请输入总秒数："))

    # 简单的合法性判断，秒数不能是负数
    if total_seconds < 0:
        print("秒数不能为负数")
        return

    # 函数返回三个值，用三个变量接收
    hours, minutes, seconds = convert_seconds(total_seconds)

    # f-string 格式化输出
    print(f"{total_seconds}秒 = {hours}小时{minutes}分{seconds}秒")


# 程序入口
if __name__ == "__main__":
    main()

2.3 必会样例

3661秒 = 1小时1分1秒
60秒 = 0小时1分0秒
59秒 = 0小时0分59秒
3600秒 = 1小时0分0秒

2.4 容易扣分点

• 用 / 得到小数，而不是用 // 得到整数。
• 分钟写成 total_seconds // 60，忘记先去掉小时部分。
• 秒数写成 total_seconds % 3600，这只是去掉小时后的剩余秒，不是最终秒数。

正确逻辑：

hours = total_seconds // 3600
remaining = total_seconds % 3600
minutes = remaining // 60
seconds = remaining % 60

---

3. 程序设计题三：圆的几何计算程序

3.1 考点

• import math。
• math.pi。
• 面积：math.pi * radius ** 2。
• 周长：2 * math.pi * radius。
• 直径：2 * radius。
• 函数封装。
• 保留两位小数：{area:.2f}。

3.2 必背核心代码

# math 模块中有更精确的圆周率 math.pi
import math


def get_circle_area(radius):
    """
    功能：计算圆的面积
    公式：面积 = π × 半径²
    """
    return math.pi * radius ** 2


def get_circle_circumference(radius):
    """
    功能：计算圆的周长
    公式：周长 = 2 × π × 半径
    """
    return 2 * math.pi * radius


def get_circle_diameter(radius):
    """
    功能：计算圆的直径
    公式：直径 = 2 × 半径
    """
    return 2 * radius


def main():
    # 半径可能是小数，所以用 float() 转换
    radius = float(input("请输入圆的半径："))

    # 半径必须大于 0，否则圆没有实际意义
    if radius <= 0:
        print("半径必须大于0")
        return

    # 分别调用函数完成计算
    area = get_circle_area(radius)
    circumference = get_circle_circumference(radius)
    diameter = get_circle_diameter(radius)

    # :.2f 表示保留两位小数
    print(f"半径：{radius:.2f}")
    print(f"直径：{diameter:.2f}")
    print(f"周长：{circumference:.2f}")
    print(f"面积：{area:.2f}")


# 程序入口
if __name__ == "__main__":
    main()

3.3 容易扣分点

• 忘记 import math。
• 把 radius ** 2 写成 radius * 2，这不是平方。
• 忘记把输入转换成 float。
• 输出格式没有保留两位小数。
• 忘记判断半径是否大于 0。

---

4. 程序设计题四：学生信息管理系统（面向对象）

4.1 考点

• 定义类：class Student:。
• 构造方法：def __init__(self, ...):。
• 实例属性：self.name = name。
• 实例方法：def show_info(self):。
• 管理多个学生：列表 self.students = []。
• 增删查改。
• 菜单循环：while True。

4.2 最小可默写版本

这个版本适合考试时间紧时写，结构完整，能体现面向对象。

class Student:
    """
    Student 类表示一个学生对象
    每个学生对象都有学号、姓名、年龄、专业
    """

    def __init__(self, student_id, name, age, major):
        # __init__ 是构造方法，创建对象时自动执行
        # self 表示当前这个学生对象本身
        self.student_id = student_id
        self.name = name
        self.age = age
        self.major = major

    def show_info(self):
        """功能：显示当前学生对象的信息"""
        print(f"学号：{self.student_id}，姓名：{self.name}，年龄：{self.age}，专业：{self.major}")


class StudentManager:
    """
    StudentManager 类表示学生管理系统
    负责保存学生列表，并提供添加、查看、查找、删除、修改功能
    """

    def __init__(self):
        # 用列表保存多个学生对象
        self.students = []

    def add_student(self, student):
        """功能：添加一个学生对象到列表中"""
        self.students.append(student)
        print("添加成功")

    def show_all(self):
        """功能：显示所有学生信息"""
        # 空列表会被当作 False，所以 not self.students 表示列表为空
        if not self.students:
            print("暂无学生信息")
            return

        # 遍历列表，逐个调用学生对象的 show_info 方法
        for student in self.students:
            student.show_info()

    def find_student(self, student_id):
        """
        功能：根据学号查找学生
        找到就返回学生对象，找不到就返回 None
        """
        for student in self.students:
            if student.student_id == student_id:
                return student
        return None

    def delete_student(self, student_id):
        """功能：根据学号删除学生"""
        # 先查找，再删除，避免直接删除不存在的对象
        student = self.find_student(student_id)
        if student is None:
            print("未找到该学生")
        else:
            self.students.remove(student)
            print("删除成功")

    def update_student(self, student_id, name, age, major):
        """功能：根据学号修改学生信息"""
        # 先查找学生对象
        student = self.find_student(student_id)
        if student is None:
            print("未找到该学生")
        else:
            # 找到后，重新给实例属性赋值
            student.name = name
            student.age = age
            student.major = major
            print("修改成功")


def main():
    """主函数：显示菜单，根据用户选择调用对应功能"""
    # 创建一个学生管理系统对象
    manager = StudentManager()

    # 用 while True 实现菜单循环，直到用户选择 0 才退出
    while True:
        print("\n=== 学生信息管理系统 ===")
        print("1. 添加学生")
        print("2. 查看全部学生")
        print("3. 查找学生")
        print("4. 修改学生")
        print("5. 删除学生")
        print("0. 退出系统")

        choice = input("请选择功能：")

        if choice == "1":
            # 添加学生：先输入信息，再创建 Student 对象
            student_id = input("请输入学号：")
            name = input("请输入姓名：")
            # 年龄需要参与数值意义，所以转成 int
            age = int(input("请输入年龄："))
            major = input("请输入专业：")
            student = Student(student_id, name, age, major)
            manager.add_student(student)

        elif choice == "2":
            # 查看全部学生
            manager.show_all()

        elif choice == "3":
            # 查找学生：输入学号，调用 find_student
            student_id = input("请输入要查找的学号：")
            student = manager.find_student(student_id)
            if student is None:
                print("未找到该学生")
            else:
                student.show_info()

        elif choice == "4":
            # 修改学生：先输入学号，再输入新的信息
            student_id = input("请输入要修改的学号：")
            name = input("请输入新姓名：")
            age = int(input("请输入新年龄："))
            major = input("请输入新专业：")
            manager.update_student(student_id, name, age, major)

        elif choice == "5":
            # 删除学生：根据学号删除
            student_id = input("请输入要删除的学号：")
            manager.delete_student(student_id)

        elif choice == "0":
            # break 跳出 while True 循环，结束程序
            print("系统已退出")
            break

        else:
            # 用户输入了菜单以外的选项
            print("无效选择，请重新输入")


# 程序入口
if __name__ == "__main__":
    main()

4.3 如果时间不够，至少写出这个精简版

class Student:
    """定义学生类"""

    def __init__(self, student_id, name, age):
        # 创建学生对象时，保存学号、姓名、年龄
        self.student_id = student_id
        self.name = name
        self.age = age

    def introduce(self):
        # self 表示调用这个方法的具体学生对象
        print(f"学号：{self.student_id}，姓名：{self.name}，年龄：{self.age}")


# 用列表保存多个学生对象
students = []

# 创建两个学生对象
stu1 = Student("001", "张三", 18)
stu2 = Student("002", "李四", 19)

# 把学生对象加入列表
students.append(stu1)
students.append(stu2)

# 遍历列表，逐个显示学生信息
for student in students:
    student.introduce()

4.4 容易扣分点

• __init__ 前后都是两个下划线，不是 _init_。
• 方法第一个参数忘写 self。
• 创建对象时写成 Student.__init__(...)，正确是 Student(...)。
• 实例属性必须用 self.name，不是只写 name。
• 管理多个学生要用列表。
• 查找学生时要遍历列表。

---

5. 程序设计题五：学生成绩等级评定程序

5.1 考点

• input() 输入和 float() 类型转换。
• try...except 处理非数字输入。
• 分数范围判断：0 <= score <= 100。
• if / elif / else 多分支等级评定。
• 函数封装：输入、评定、输出分开写。

5.2 必背核心代码

# 学生成绩等级评定程序
# 功能：输入一个分数，判断等级并输出评语


def get_grade(score):
    # 条件从上到下判断，一旦满足就不会继续检查后面的 elif
    if score >= 90:
        grade = "A(优秀)"
        comment = "成绩优异，继续保持！"
    elif score >= 80:
        grade = "B(良好)"
        comment = "成绩不错，继续努力！"
    elif score >= 70:
        grade = "C(中等)"
        comment = "还有提升空间。"
    elif score >= 60:
        grade = "D(及格)"
        comment = "刚刚及格，需要加把劲。"
    else:
        grade = "F(不及格)"
        comment = "需要重新学习本课程。"

    # 一次返回两个结果：等级和评语
    return grade, comment


def main():
    # input() 返回字符串，要先转换成 float 才能比较大小
    score_text = input("请输入学生成绩：")

    # try...except 用来防止用户输入 abc 这类非数字内容导致程序崩溃
    try:
        score = float(score_text)
    except ValueError:
        print("错误：请输入有效的数字成绩")
        return

    # 分数必须在 0 到 100 之间
    if score < 0 or score > 100:
        print("错误：成绩必须在0到100之间")
        return

    # 调用函数获取等级和评语
    grade, comment = get_grade(score)

    # :.1f 表示保留 1 位小数
    print(f"分数：{score:.1f}")
    print(f"等级：{grade}")
    print(f"评语：{comment}")


# 程序入口
if __name__ == "__main__":
    main()

5.3 容易扣分点

• 忘记把 input() 转成 float。
• if score >= 90 后面忘记冒号。
• 等级判断顺序写反，比如先判断 score >= 60 会导致 90 分也被判为及格。
• 忘记判断分数范围，负数和 120 分也被当成有效成绩。
• try...except 的 except ValueError: 不能少冒号。

---

6. 程序设计题六：九九乘法表打印程序（while）

6.1 考点

• while 循环。
• 嵌套循环：外层控制行，内层控制列。
• print(..., end="\t") 不换行输出。
• 每一行结束后单独 print() 换行。
• 循环变量必须自增，否则会死循环。

6.2 必背核心代码

# 九九乘法表打印程序（while 版）
# 外层 while 控制行，内层 while 控制列

print("=" * 60)
print("九九乘法表（while 循环实现）")
print("=" * 60)

# row 表示当前行号，从 1 开始
row = 1

# 外层 while 循环：控制乘法表的行
while row <= 9:
    # col 表示当前列号，每一行都要从 1 开始
    col = 1

    # 内层 while 循环：控制当前行中的列
    while col <= row:
        # end="\t" 表示本次 print 结束后不换行，而是输出一个制表符
        print(f"{col}x{row}={col * row:2}", end="\t")

        # 列号自增，避免内层循环死循环
        col += 1

    # 当前行打印完后，输出换行
    print()

    # 行号自增，避免外层循环死循环
    row += 1

print("=" * 60)

6.3 容易扣分点

• 忘记 row += 1 或 col += 1，导致死循环。
• 内层循环条件写成 col <= 9，会打印完整矩形，不是常见三角形乘法表。
• 忘记每一行结束后的 print()，所有内容挤在一行。
• end="\t" 写错，输出格式会不整齐。

---

7. 程序设计题七：文本字符串处理程序

7.1 考点

• input() 获取文本。
• strip() 去除两端空白。
• len() 统计长度。
• 遍历字符串统计数字、字母、空格。
• upper()、lower()、replace()、split()、join()、切片反转。

7.2 必背核心代码

# 文本字符串处理程序
# 功能：对用户输入的一段文本进行清洗、统计和转换


def analyze_text(text):
    # strip() 去除字符串两端的空白字符
    clean_text = text.strip()

    # 初始化统计变量
    digit_count = 0
    alpha_count = 0
    space_count = 0

    # 遍历字符串中的每一个字符
    for char in clean_text:
        if char.isdigit():
            digit_count += 1
        elif char.isalpha():
            alpha_count += 1
        elif char.isspace():
            space_count += 1

    # 用字典保存处理结果，便于统一返回
    result = {
        "clean_text": clean_text,
        "length": len(clean_text),
        "upper_text": clean_text.upper(),
        "lower_text": clean_text.lower(),
        "reverse_text": clean_text[::-1],
        "digit_count": digit_count,
        "alpha_count": alpha_count,
        "space_count": space_count,
    }

    return result


def main():
    # input() 获取用户输入的文本，返回值一定是字符串
    text = input("请输入一段文本：")

    # 空字符串会被当作 False
    if not text:
        print("错误：文本不能为空")
        return

    # 调用文本分析函数
    info = analyze_text(text)

    print(f"清洗后文本：{info['clean_text']}")
    print(f"文本长度：{info['length']}")
    print(f"全大写：{info['upper_text']}")
    print(f"全小写：{info['lower_text']}")
    print(f"反转文本：{info['reverse_text']}")
    print(f"数字个数：{info['digit_count']}")
    print(f"字母个数：{info['alpha_count']}")
    print(f"空格个数：{info['space_count']}")

    # split() 按空格分割，join() 用指定符号重新连接
    words = info["clean_text"].split()
    joined_text = "-".join(words)
    print(f"分词结果：{words}")
    print(f"用-连接：{joined_text}")


# 程序入口
if __name__ == "__main__":
    main()

7.3 容易扣分点

• 忘记 input() 返回字符串。
• strip() 不会修改原字符串，而是返回新字符串。
• 字符串不可变，不能通过 text[0] = "A" 修改。
• split() 返回列表，join() 是字符串方法。
• text[::-1] 才是字符串反转。

---

8. 程序设计题八：动物园音乐会程序（面向对象）

8.1 考点

• 定义父类 Animal。
• 子类 Dog、Cat、Duck 继承父类。
• 子类重写 speak() 方法。
• 多态：同样调用 animal.speak()，不同对象表现不同。
• 列表保存多个对象并遍历。

8.2 必背核心代码

# 动物园音乐会程序
# 重点：继承、方法重写、多态


class Animal:
    def __init__(self, name):
        # self.name 是每个动物对象自己的名字
        self.name = name

    def speak(self):
        # 父类提供默认实现，子类可以重写这个方法
        print(f"{self.name}发出某种声音")


class Dog(Animal):
    def speak(self):
        # Dog 子类重写 speak 方法
        print(f"{self.name}说: 汪汪汪!")


class Cat(Animal):
    def speak(self):
        # Cat 子类重写 speak 方法
        print(f"{self.name}说: 喵喵喵!")


class Duck(Animal):
    def speak(self):
        # Duck 子类重写 speak 方法
        print(f"{self.name}说: 嘎嘎嘎!")


def animal_concert(animals):
    # 同一个函数可以处理不同类型的动物对象
    print("=== 动物音乐会开始 ===")

    for animal in animals:
        # 多态：同样调用 speak，不同对象执行不同版本
        animal.speak()

    print("=== 动物音乐会结束 ===")


def main():
    # 创建动物对象列表
    zoo = [Dog("大黄"), Cat("咪咪"), Duck("唐老鸭")]

    # 把列表传入函数，开始音乐会
    animal_concert(zoo)


# 程序入口
if __name__ == "__main__":
    main()

8.3 容易扣分点

• 子类继承写法是 class Dog(Animal):。
• 方法第一个参数不要忘记 self。
• 子类重写方法时方法名必须仍然叫 speak。
• 多态不是写很多 if，而是统一调用 animal.speak()。
• 创建对象时写 Dog("大黄")，不是直接调用 Dog.__init__()。

---

9. 读代码题高频陷阱

5.1 输入类型

age = input("年龄：")
print(age + "1")

如果输入 20，输出是 201，不是 21。因为 input() 返回字符串。

正确计算：

age = int(input("年龄："))
print(age + 1)

5.2 除法、整除、取余

print(17 / 5)   # 3.4
print(17 // 5)  # 3
print(17 % 5)   # 2

5.3 字符串索引和切片

s = "Python"
print(s[0])      # P
print(s[-1])     # n
print(s[1:4])    # yth
print(s[::-1])   # nohtyP

5.4 循环和 range

for i in range(1, 5):
    print(i)

输出：

1
2
3
4

不输出 5。

5.5 break 和 continue

for i in range(1, 6):
    if i == 3:
        continue
    print(i)

输出：1, 2, 4, 5，跳过 3。

for i in range(1, 6):
    if i == 3:
        break
    print(i)

输出：1, 2，遇到 3 直接结束循环。

5.6 函数 return

def add(a, b):
    return a + b
    print("结束")

print(add(2, 3))

输出 5，return 后面的 print("结束") 不执行。

5.7 变量作用域

PI = 3.14159

def area(radius):
    result = PI * radius * radius
    return result

print(area(2))

PI 是全局变量，函数内部可以读取。result 是局部变量，函数外不能直接使用。

5.8 类属性和实例属性

class Student:
    school = "信息工程学院"

    def __init__(self, name):
        self.name = name


s1 = Student("张三")
s2 = Student("李四")
print(s1.school)
print(s2.name)

• school 是类属性，所有对象共享。
• name 是实例属性，每个对象自己的。

---

10. 判断题高频句

下面这些句子要能判断对错：

• Python 使用缩进表示代码块。对。
• Python 中 input() 返回的是字符串。对。
• Python 变量使用前不需要声明类型。对。
• = 表示赋值，== 表示比较。对。
• 4 / 2 的结果是整数 2。错，结果是浮点数 2.0。
• range(1, 5) 包含 5。错。
• 字符串可以通过索引访问。对。
• 字符串是可变对象。错。
• 函数必须有 return。错，没有 return 默认返回 None。
• 类中的实例方法第一个参数通常是 self。对。
• break 是跳出整个循环。对。
• continue 是结束整个循环。错，它只是跳过本次循环。
• if __name__ == "__main__": 常用于设置程序入口。对。
• with open(...) as f: 可以自动关闭文件。对。
• append() 可以向列表末尾添加元素。对。

---

11. 考前 4 天安排

周一：过基础和读代码

• 看第 4 到第 8 周：命名、变量、数据类型、输入输出、运算符、条件、循环。
• 重点刷 input()、//、%、range()、切片、break/continue。

周二：默写基础计算类程序题

• 秒数转换器。
• 圆的几何计算程序。
• 学生成绩等级评定程序。
• 九九乘法表打印程序（while）。
• 每个程序至少手写一遍，不看答案再敲一遍。

周三：默写字符串、审计和面向对象程序题

• 看第 11、12 周：类、对象、self、__init__、实例属性、类属性、继承、多态。
• 密码安全审计工具。
• 文本字符串处理程序。
• 学生信息管理系统。
• 动物园音乐会程序。

周四：模拟考试

• 限时 100 分钟。
• 先做选择和判断，不纠结难题。
• 程序题先写最有把握的秒数转换、圆计算、成绩等级和九九乘法表，再写字符串处理、密码审计和面向对象题。
• 最后检查：冒号、缩进、变量名、类型转换、self、return。

---

12. 程序题检查清单

交卷前按这个顺序检查：

1. if、for、while、def、class 后面有没有冒号。
2. 缩进是否统一。
3. input() 后需要计算的地方有没有 int() 或 float()。
4. 函数有没有必要的 return。
5. 类方法有没有写 self。
6. 创建对象是不是 Student(...)。
7. 文件操作有没有写 encoding="utf-8"。
8. 圆计算有没有 import math。
9. 秒数转换有没有用 // 和 %。
10. 密码检测有没有遍历整个字符串。
11. 九九乘法表有没有 row += 1 和 col += 1。
12. 面向对象题有没有通过对象调用方法，例如 animal.speak() 或 student.show_info()。