HNU个人项目互评

东城西笑

一、前言

这篇博客是对软件工程导论的个人项目进行互评，项目要求实现一个简单的中小学数学卷子自动生成程序。我的搭档谢先衍同学使用Python完成了项目，而我则是使用java。尽管语言不同增加了一定的阅读成本，但是接触到另一种新语言并体会编程者发挥语言特性独特的心得，确实是拓展了眼界。一个项目，最终归结到不同问题，无论用什么语言，面临的问题都是一致的，但是语言的特性和编程者的思想却是和而不同，由此给人以启发

二、要求

用户：

小学、初中和高中数学老师。
功能：

1、命令行输入用户名和密码，两者之间用空格隔开（程序预设小学、初中和高中各三个账号，具体见附表），如果用户名和密码都正确，将根据账户类型显示“当前选择为XX出题”，XX为小学、初中和高中三个选项中的一个。否则提示“请输入正确的用户名、密码”，重新输入用户名、密码；
2、登录后，系统提示“准备生成XX数学题目，请输入生成题目数量（输入-1将退出当前用户，重新登录）：”，XX为小学、初中和高中三个选项中的一个，用户输入所需出的卷子的题目数量，系统默认将根据账号类型进行出题。每道题目的操作数在1-5个之间，操作数取值范围为1-100；
3、题目数量的有效输入范围是“10-30”（含10,30，或-1退出登录），程序根据输入的题目数量生成符合小学、初中和高中难度的题目的卷子（具体要求见附表）。同一个老师的卷子中的题目不能与以前的已生成的卷子中的题目重复（以指定文件夹下存在的文件为准，见5）；
4、在登录状态下，如果用户需要切换类型选项，命令行输入“切换为XX”，XX为小学、初中和高中三个选项中的一个，输入项不符合要求时，程序控制台提示“请输入小学、初中和高中三个选项中的一个”；输入正确后，显示“”系统提示“准备生成XX数学题目，请输入生成题目数量”，用户输入所需出的卷子的题目数量，系统新设置的类型进行出题；
5、生成的题目将以“年-月-日-时-分-秒.txt”的形式保存，每个账号一个文件夹。每道题目有题号，每题之间空一行；
个人项目9月17日晚上10点以前提交至创新课程管理系统。提交方式：工程文件打包，压缩包名为“几班+姓名.rar”。迟交2天及以内者扣分，每天扣20%。迟交2天及以上者0分。
附表-1：账号密码

账户类型账户密码备注小学张三1123张三2123张三3123初中李四1123李四2123李四3123高中王五1123王五2123王五3123附表-2：小学、初中、高中题目难度要求

小学初中高中难度要求+,-,*./平方，开根号sin,cos,tan备注只能有+,-,*./和()题目中至少有一个平方或开根号的运算符题目中至少有一个sin,cos或tan的运算符‍
三、功能检查

背景

环境：Python 3.11.5
软件：VScode
登录

命令行输入用户名和密码，两者之间用空格隔开（程序预设小学、初中和高中各三个账号，具体见附表），如果用户名和密码都正确，将根据账户类型显示“当前选择为XX出题”，XX为小学、初中和高中三个选项中的一个。否则提示“请输入正确的用户名、密码”，重新输入用户名、密码

成功登录的情况

测试：错误的账号密码

​

在错误的情况下，提示“请输入正确的用户名、密码”
测试：不符合格式的账号密码

在输入含多个空格的输入后，判断格式错误
出题

登录后，系统提示“准备生成XX数学题目，请输入生成题目数量（输入-1将退出当前用户，重新登录）：”，XX为小学、初中和高中三个选项中的一个，用户输入所需出的卷子的题目数量，系统默认将根据账号类型进行出题。每道题目的操作数在1-5个之间，操作数取值范围为1-100；
题目数量的有效输入范围是“10-30”（含10,30，或-1退出登录），程序根据输入的题目数量生成符合小学、初中和高中难度的题目的卷子（具体要求见附表）。同一个老师的卷子中的题目不能与以前的已生成的卷子中的题目重复
生成的题目将以“年-月-日-时-分-秒.txt”的形式保存，每个账号一个文件夹。每道题目有题号，每题之间空一行；

成功出题

​

​

成功按指定数目出题，并且附带题号，题与题之间空有一行，在对应的用户文件夹之下生成以时间为名的题目文件
退出

成功退出到上一页面
测试：不在范围内的输入

​

不在范围内的输入会提示范围
测试：不规范的输入

​

不和规范的输入会被认为是字符串，进而判断是否是切换选项
测试：间隔少于1s的快速输入

存放生成题目的文件是按时间命名的，最低单位是秒。如果快速输入，1秒中输入多次呢？

​

结果是生成了第一次的文件
‍
切换

成功切换

​

​

生成了不同类型的题目，并成功存入对应的目录之下
测试：错误输入

匹配的字符串只有三种，此外的字符串都会触发提示
‍
总结

功能的测试完备，符合文档的需求，可以说作者在编写代码的时候非常娴熟精准，落实到了文档的每一个功能实现之中。虽然在一个测试中出现了点小问题，但考虑到并非文档指明的需求，无伤大雅。
‍
四、代码分析

代码

account.py

1. #!/usr/bin/env python3.10.9
2. # -*- coding: utf-8 -*-
4. import json
7. class Account(object):
8.     """Account class.
9.   
10.     Attributes:
11.         account: The account, such as '张三1'.
12.         password: The password of the account.
13.         grade: The corresponding grade of the account, to generate exam with
14.             different difficuty.
15.     """
17.     def __init__(self, account, password, grade) -> None:
18.         """Init the account."""
19.         self.account = account
20.         self.password = password
21.         self.grade = grade
24. class Accounts(object):
25.     """Accounts class, to manage accounts.
26.   
27.     Attributes:
28.         accounts: The accounts list, read from accounts.json.
29.     """
31.     def __init__(self) -> None:
32.         """Read accounts from accounts.json to init the accounts list."""
33.         self.accounts = []
34.         with open("accounts.json", "r", encoding="utf-8") as f:
35.             accounts_dir = json.loads(f.read())
36.         for key in accounts_dir.keys():
37.             for account in accounts_dir[key]:
38.                 self.accounts.append(
39.                     Account(account["account"], account["password"], key))
41.     def check_account(self, account, password) -> str:
42.         for acc in self.accounts:
43.             if acc.account == account and acc.password == password:
44.                 return acc.grade
45.         return None
47.     def login(self) -> (str, str):
48.         """Login to the system.
49.       
50.         Returns:
51.             account: The account try to login in.
52.             grade: The corresponding grade of the account.
53.         """
54.         while True:
55.             account_passwd = input("请输入用户名和密码，两者之间用空格隔开: ")
56.             try:
57.                 account, passwd = account_passwd.split(" ")
58.             except:
59.                 print("格式错误!")
60.                 continue
61.             grade = self.check_account(account, passwd)
62.             if grade is None:
63.                 print("请输入正确的用户名、密码!")
64.             else:
65.                 return account, grade

复制代码

优点

• 清晰的代码结构： 代码使用了面向对象的方法，使用类来组织数据和功能，使代码具有良好的结构。
  
• 良好的注释和文档字符串： 代码中有注释和文档字符串，解释了类和方法的功能，这有助于其他开发人员理解代码。
  
• 封装性： 帐户数据和操作被封装在 Account​ 和 Accounts​ 类中，提高了代码的可维护性和可扩展性。
  

缺点

• 代码耦合度高： Accounts​ 类直接依赖于文件 I/O 和 JSON 解析，这导致了代码的耦合度较高。最好将这些依赖项解耦，以便更容易进行单元测试和扩展。
  

examgenerator.py

1. #!/usr/bin/env python3.10.9
2. # -*- coding: utf-8 -*-
4. from abc import ABC
5. from abc import abstractmethod
6. import os
7. import random
8. import re
9. import time
12. class ExamGenerator(ABC):
13.     """Abstract class for exam generator.
14.   
15.     Attributes:
16.         operators: The operators to use.
17.     """
19.     def __init__(self) -> None:
20.         self.operators = ["+", "-", "*", "/"]
22.     @abstractmethod
23.     def generate(self, num_range: tuple) -> str:
24.         """
25.         Generate a math problem.
26.         """
28.     def unary_op(self, op: str, obj: str) -> str:
29.         """Unary operator such as ^2, sqrt, sin, cos, tan.
31.         If the operator is ^2, then the operator is behind the object, if the
32.         operator is sqrt, sin, cos or tan, then the operator is before the
33.         object. Otherwise, the operator is not used.
34.               
35.         Arguments:
36.             op: The unary operator to use.
37.             obj: The object to use the unary operator.
38.          
39.         Returns:
40.             the result str of the object with the unary operator.
41.         """
42.         if op == "^2":
43.             return f"({obj})^2"
44.         elif op in ["sqrt", "sin", "cos", "tan"]:
45.             return f"{op}({obj})"
46.         else:
47.             return obj
48.       
49.     def reverse(self, prob: str) -> str:
50.         """Reverse the prob str if it's operators number is 2.
51.       
52.         Arguments:
53.             prob: The prob str to reverse.
54.          
55.         Returns:
56.             the reversed prob str.
57.         """
58.         pattern = r'\d+'  # Match the number using regular expression
59.         prob = prob.replace("^2", "^")  # To avoid the ^2 operator being matched
60.         matches = re.findall(pattern, prob)
61.         if len(matches) == 2:
62.             prob = prob.replace(matches[1], matches[0])
63.             prob = prob.replace(matches[0], matches[1], 1)
64.         prob = prob.replace("^", "^2")
65.         return prob
67.     def check_repeat(self, account: str, prob: str) -> bool:
68.         """Check if the prob is repeated.
69.       
70.         Arguments:
71.             account: The account using the program.
72.             prob: The prob str to check.
73.          
74.         Returns:
75.             True if the prob is repeated, otherwise False.
76.         """
77.         if os.path.exists(f"exams/{account}"):
78.             for file in os.listdir(f"exams/{account}"):
79.                 with open(f"exams/{account}/{file}", "r") as f:
80.                     lines = f.readlines()[:-1:2]  # Remove the '\n'
81.                     for line in lines:
82.                         if (prob == line[4:-1] or  # Remove the prob index and space and '\n'
83.                             self.reverse(prob) == line[4:-1]):
84.                             return True
85.         return False
87.     def save_probs(self, account: str, probs_num: int) -> None:
88.         """Save the probs to the file.
89.       
90.         Arguments:
91.             account: The account using the program.
92.             probs_num: The number of probs to generate.
93.          
94.         Returns:
95.             None.
96.         """
97.         probs = []
98.         for i in range(probs_num):
99.             while True:
100.                 prob = f"{self.generate()}="
101.                 if ((prob not in probs) and
102.                     (not self.check_repeat(account, prob))):
103.                     break
104.             probs.append(prob)
105.         if not os.path.exists(f"exams/{account}"):
106.             os.mkdir(f"exams/{account}")
107.         # filename: 年-月-日-时-分-秒.txt
108.         filename = f"{time.strftime('%Y-%m-%d-%H-%M-%S', time.localtime())}.txt"
109.         with open(f"exams/{account}/{filename}", "w") as f:
110.             index = 1
111.             for prob in probs:
112.                 space = "  " if index < 10 else " "  # Add space to align the index
113.                 f.write(f"{index}.{space}{prob}\n\n")
114.                 index += 1
117. class ExamGenerator1(ExamGenerator):
118.     """Exam generator for primary school."""
120.     def __init__(self) -> None:
121.         super().__init__()
123.     def generate(self, nums_range=(1, 5)) -> str:
124.         op_num = random.randint(nums_range[0], nums_range[1])
125.         op = random.choice(self.operators)
126.         if op_num == 1:
127.             if nums_range[1] == 5:
128.                 return self.generate((1, 5))  # If the result is only 1 number, generate again
129.             else:
130.                 return str(random.randint(1, 100))
131.         elif op_num == 2:
132.             left_op = self.generate((1, 1))
133.             right_op = self.generate((1, 1))
134.             if random.random() < 0.45 and nums_range[1] != 5:
135.                 return f"({left_op}{op}{right_op})"  # 45% to add brackets
136.             else:
137.                 return f"{left_op}{op}{right_op}"
138.         else:
139.             left_op = self.generate((1, op_num // 2))
140.             right_op = self.generate((1, op_num - op_num // 2))
141.             if random.random() < 0.45 and nums_range[1] != 5:
142.                 return f"({left_op}{op}{right_op})"
143.             else:
144.                 return f"{left_op}{op}{right_op}"
147. class ExamGenerator2(ExamGenerator):
148.     """Exam generator for junior high school."""
150.     def __init__(self) -> None:
151.         super().__init__()
152.         self.operators.extend(["^2", "sqrt"])
154.     def generate(self, nums_range=(1, 5)) -> str:
155.         op_num = random.randint(nums_range[0], nums_range[1])
156.         op = random.choice(self.operators)
157.         op1 = random.choice(self.operators[:4])
158.         if op_num == 1:
159.             if op in self.operators[4:] and random.random() < 0.66:
160.                 result = self.unary_op(op, str(random.randint(1, 100)))
161.             else:
162.                 result = str(random.randint(1, 100))
163.         elif op_num == 2:
164.             left_op = self.generate((1, 1))
165.             right_op = self.generate((1, 1))
166.             if op in ["^2", "sqrt"]:
167.                 return self.unary_op(op, f"{left_op}{op1}{right_op}")
168.             else:
169.                 result = f"{left_op}{op}{right_op}"
170.         else:
171.             left_op = self.generate((1, op_num // 2))
172.             right_op = self.generate((1, op_num - op_num // 2))
173.             if op in ["^2", "sqrt"]:
174.                 result = self.unary_op(op, f"{left_op}{op1}{right_op}")
175.             else:
176.                 result = f"{left_op}{op}{right_op}"
177.         if (nums_range[1] == 5 and result.find("sqrt") == -1 and
178.             result.find("^2") == -1):  # If the result don't contain sqrt or ^2, generate again
179.             return self.generate((1, 5))
180.         return result
183. class ExamGenerator3(ExamGenerator):
184.     """Exam generator for senior high school."""
186.     def __init__(self) -> None:
187.         super().__init__()
188.         self.operators.extend(["^2", "sqrt", "sin", "cos", "tan"])
190.     def generate(self, nums_range=(1, 5)) -> str:
191.         op_num = random.randint(nums_range[0], nums_range[1])
192.         op = random.choice(self.operators)
193.         op1 = random.choice(self.operators[:4])
194.         if op_num == 1:
195.             if op in self.operators[4:] and random.random() < 0.66:
196.                 result = self.unary_op(op, str(random.randint(1, 100)))
197.             else:
198.                 result = str(random.randint(1, 100))
199.         elif op_num == 2:
200.             left_op = self.generate((1, 1))
201.             right_op = self.generate((1, 1))
202.             if op in self.operators[4:]:
203.                 result = self.unary_op(op, f"{left_op}{op1}{right_op}")
204.             else:
205.                 result = f"{left_op}{op}{right_op}"
206.         else:
207.             left_op = self.generate((1, op_num // 2))
208.             right_op = self.generate((1, op_num - op_num // 2))
209.             if op in self.operators[4:]:
210.                 result = self.unary_op(op, f"{left_op}{op1}{right_op}")
211.             else:
212.                 result = f"{left_op}{op}{right_op}"
213.         if (nums_range[1] == 5 and result.find("sin") == -1 and
214.             result.find("cos") == -1 and result.find("tan") == -1):  # If the result don't contain sin, cos or tan, generate again
215.             return self.generate((1, 5))
216.         return result

复制代码

优点

1 抽象类和多态： ExamGenerator​ 是一个抽象基类，定义了一个抽象方法 generate​，并且在子类中进行了实现。这利用了Python的多态性，允许不同子类提供不同的实现
缺点

• 部分魔法数值： 代码中出现了一些魔法数值，如 0.45、0.66 等，这些值没有明确的解释和注释，可能会导致代码的可读性和可维护性降低。最好将这些数值提取为常量，并提供相关注释。
  
• 文件操作错误处理不足： 代码中的文件操作没有足够的错误处理机制，如果文件无法创建或写入，代码会引发异常而无法处理。
  
• 生成题目的方法命名不一致： 不同级别的生成器子类中的 generate​ 方法签名不一致，这可能会导致混淆和错误。最好统一方法名。
  
• 未考虑边界情况： 代码中未考虑一些边界情况，如生成的数值范围、一元运算符的频率等，这可能导致生成的题目不够多样化或有问题。
  

main.py

1. #!/usr/bin/env python3.10.9
2. # -*- coding: utf-8 -*-
4. from account import Accounts
5. from examgenerator import ExamGenerator
6. from examgenerator import ExamGenerator1
7. from examgenerator import ExamGenerator2
8. from examgenerator import ExamGenerator3
11. def Exam_generator(grade: str) -> ExamGenerator:
12.     """Return the corresponding ExamGenerator according to the grade.
13.   
14.     Arguments:
15.         grade: The grade of the account.
16.       
17.     Returns:
18.         The corresponding ExamGenerator.
19.     """
20.     if grade == "小学":
21.         return ExamGenerator1()
22.     elif grade == "初中":
23.         return ExamGenerator2()
24.     elif grade == "高中":
25.         return ExamGenerator3()
26.     else:
27.         return ExamGenerator()
30. def main():
31.     """Main function of the program."""
32.     accounts = Accounts()
33.     account, grade = accounts.login()
35.     exam_generator = Exam_generator(grade)
37.     prob_num = 0
38.     while True:
39.         try:
40.             prob_num = input(
41.                 f"准备生成{grade}数学题目，请输入生成题目数量（输入-1将退出当前用户重新登录，输入切换为XX可以切换身份）: ")
42.             if prob_num.startswith("切换为"):
43.                 if prob_num[3:] in ["小学", "初中", "高中"]:
44.                     grade = prob_num[3:]
45.                     exam_generator = Exam_generator(grade)
46.                 else:
47.                     print("请输入小学、初中和高中三个选项中的一个!")
48.             elif int(prob_num) >= 10 and int(prob_num) <= 30:
49.                 exam_generator.save_probs(account, int(prob_num))
50.                 print(f"{grade}数学题目生成完毕，已保存到exams/{account}目录下!")
51.             elif int(prob_num) == -1:
52.                 account, grade = accounts.login()
53.                 exam_generator = Exam_generator(grade)
54.             else:
55.                 print("请输入10-30之间的数字")
56.         except ValueError:
57.             print("请输入10-30之间的数字或切换为小学、初中和高中三个选项中的一个!")
60. if __name__ == '__main__':
61.     main()

复制代码

3. 异常处理

码中有一些异常处理，这是符合Google代码规范的一项实践。异常处理有助于处理潜在的错误情况。

1. {
2.     "小学": [
3.         {
4.             "account": "张三1",
5.             "password": "123"
6.         },
7.         {
8.             "account": "张三2",
9.             "password": "123"
10.         },
11.         {
12.             "account": "张三3",
13.             "password": "123"
14.         }
15.     ],
16.     "初中": [
17.         {
18.             "account": "李四1",
19.             "password": "123"
20.         },
21.         {
22.             "account": "李四2",
23.             "password": "123"
24.         },
25.         {
26.             "account": "李四3",
27.             "password": "123"
28.         }
29.     ],
30.     "高中": [
31.         {
32.             "account": "王五1",
33.             "password": "123"
34.         },
35.         {
36.             "account": "王五2",
37.             "password": "123"
38.         },
39.         {
40.             "account": "王五3",
41.             "password": "123"
42.         }
43.     ]
44. }

复制代码

也有值得改进的地方：
文档字符串（Docstrings）

代码中缺少文档字符串（Docstrings）。文档字符串是对模块、类、函数和方法功能的详细描述，以及参数和返回值的说明。这是Google代码规范强烈鼓励的一项实践，有助于提高代码的可读性和可维护性。

1. def generate(self, num_range: tuple) -> str:
2.     """
3.     Generate a math problem.
4.     """
5.     ...
7. def check_repeat(self, account: str, prob: str) -> bool:
8.     """Check if the prob is repeated.
9.   
10.     Arguments:
11.         account: The account using the program.
12.         prob: The prob str to check.
13.    
14.     Returns:
15.         True if the prob is repeated, otherwise False.
16.     """
17.     ...

复制代码

五、总结

第一次写博客评价他人的项目，我深切感受到了写代码还得是一个团队活动，人和人之间交流彼此的意见和经验，以求共同进步，这样的学习方式更加高效。搭档的项目写得很好，相比我写的java而言，代码更简练优美，希望大家有所启发。

来源:https://www.cnblogs.com/meaning-of-fragrance/p/17718734.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！