结对项目：用Python实现四则运算

团队成员

1.PSP表格

2.设计要求文档

• 一：设计目的：设计一个四则运算程序，使得能生产1-10以内的加减乘除题目以及结果，并能进行结果判断。
• 二：设计要求：使得设计的题目不重复，并能生成任意量的题目，能进行异常检测。
• 三：算法设计：二叉树，判断树是否同构使得满足要求。能检测出用户操作异常，并将模块异常部分告知用户让其重新填写。
• 四：进行性能分析，并尝试提出更优新能方案。
• 五：环境配置：Python3.11/3.10

3.效能分析

耗时检测情况：

-函数generate_num生成10次题目所花的时间

函数generate_num生成10次题目所花的时间为0.0010001659393310547s


-整个程序的执行所花的时间为：

生成10道题目整个程序所花的时间为：0.0010001659393310547s


可以发现，生成10道题的整个过程里，generate_num函数所花的时间和整个程序所花的时间几乎相同，可以认为花费时间的算法部分只有generate_num函数
从数值上看，平均每道题生成的时间约为0.0001s。换而言之，生成一万道题目差不多花费1s就能完成，效率可以说是很高的

内存占用检测

由于generate_num函数和isOmorphic函数是在repeat()函数钟一齐被调用的，所以通过监测repeat函数的执行情况即可监测generate_num和isOmorphic这两个核心算法的情况：



由结果可知，生成1000个问题的过程中，generate_num占用了约0.7MiB的内存，isOmorphic占用了约0.1MiB的内存
即平均生成每道题generate_num函数占用的内存为0.0007MiB，isOmorphic占用了约0.0001MiB的内存，对于一个程序来说几乎可以忽略不计

内存泄漏检测

整个程序运行得内存泄漏情况如下：



从结果可知，该程序的内存泄漏情况是比较严重的，原因是程序执行过程钟占用的内存没有及时释放

总结

优点：整个程序在时间效率上是很高的，足以应对普通的商业需求。同时，程序在执行的过程中内存占用也几乎可以忽略不计，对运行的硬件的要求极低。
不足：本程序的内存泄漏情况严重，可以在释放内存的功能上做一些完善。

4.代码设计

• 整体代码设计思路流程图如下图所示：
  
  以下是程序所定义的函数以及类
• 1)定义一个数字结构体生成随机产生的分数

class N_S:  # 数字结构体
    def __init__(self):
        self.number_sign = 0  # 数的类型
        self.numerator = 0  # 分子
        self.denominator = 1  # 分母

    def generate_number_sign(self):  # 随机生成数的类型，类型值为1时分母默认为1
        self.number_sign = random.randint(1, 2)

    def generate_numerator(self, min, max):  # 随机生成分子的大小
        self.numerator = random.randint(min, max)

    def generate_denominator(self, min, max):  # 随机生成分母的大小
        self.denominator = random.randint(min, max)

• 2)定义一个二叉树,并定义相关算法，进行中序遍历

class B_T:  # 二叉树结构体,以及相关
    def __init__(self, rootObj):
        self.key = rootObj  # 将运算符作为根节点
        self.leftChild = None
        self.rightChild = None

    def insert_left(self, newRoot):  # 插入左子树
        if (self.leftChild == None):
            self.leftChild = B_T(newRoot)
        else:
            t = B_T(newRoot)
            t.leftChild = self.leftChild
            self.leftChild = t

    def insert_right(self, newRoot):  # 插入右子树
        if (self.rightChild == None):
            self.rightChild = B_T(newRoot)
        else:
            t = B_T(newRoot)
            t.rightChild = self.rightChild
            self.rightChild = t

    def get_leftChild(self):  # 返回左孩子
        return self.leftChild

    def get_rightChild(self):  # 返回右孩子
        return self.rightChild

    def set_root(self, Obj):  # 修改当前结点的内容
        self.key = Obj

    def get_Root(self):  # 返回当前结点的内容
        return self.key

    def inorder(self):  # 中序遍历
        if self.leftChild:
            self.leftChild.inorder()
        if self.key:
            num.append(self.key)
        if self.rightChild:
            self.rightChild.inorder()

• 3）主要函数算法解析
• 3.1）isOmorphic(t1, t2)：
  
  

算法设计过程：
 函数isOmorphic接受两个参数t1和t2，分别表示两棵树的根节点。首先判断t1和t2是否都为None，如果是则返回True，表示两棵树都为空树，结构相同。如果t1和t2中有一个为空树而另一个不为空树，则返回False，表示两棵树结构不同。
接下来判断t1和t2的根节点的值是否相同，如果不同则返回False，表示两棵树结构不同。如果根节点的值相同，则分三种情况进行判断：
  一、如果t1和t2的左子树都为空，则递归判断t1和t2的右子树是否同构。
  二、如果t1和t2的左子树都不为空，且左子树的根节点的值相同，则递归判断t1和t2的左子树和右子树是否同构。
  三、如果t1和t2的左子树不同时为空，且左子树的根节点的值不同，则递归判断t1的左子树和t2的右子树是否同构，以及t1的右子树和t2的左子树是否同构。
  最终返回True或False，表示两棵树是否同构。

• 3.2) generate_num(min, max)：
  

算法设计过程：
参数：生成题目的上max下min限
1. 首先调用 `num_size()` 函数生成题目长度 `size`。
2. 如果题目长度为2，随机生成一个运算符号 `operator`，并将其插入二叉树 `t` 的根节点。
3. 生成两个参与运算的数 `a` 和 `b`，并随机生成它们的类型（正数或分数）和大小（分子和分母）。
4. 将数 `a` 插入二叉树 `t` 的左子树，将数 `b` 插入右子树。
5. 如果题目长度为1或3，随机生成一个运算符号 `operator`，并将其插入二叉树 `t` 的根节点。
6. 如果题目长度为1，再随机生成一个运算符号 `operator`，并将其插入二叉树 `t` 的左子树。
7. 生成三个参与运算的数 `a`、`b` 和 `c`，并随机生成它们的类型和大小。
8. 将数 `c` 插入二叉树 `t` 的右子树。
9. 将数 `a` 插入二叉树 `t` 的左子树。
10. 将数 `b` 插入二叉树 `t` 的左子树的右子树。
11. 如果题目长度为3，再随机生成一个运算符号 `operator`，并将其插入二叉树 `t` 的右子树。
12. 将数 `b` 插入二叉树 `t` 的右子树的左子树。
13. 将数 `c` 插入二叉树 `t` 的右子树的右子树。
14. 返回生成的二叉树 `t`。

• 3.3）str_num(t)：
  

参数：生成题目的树t的中序遍历结果
1. 定义一个空列表 `num`，用于存储生成的题目字符及计算数字。
2. 如果列表 `num` 的长度为5，即已经生成了3个数字和2个运算符，取出根节点在列表中的位置。
3. 如果第二个字符是乘除，第一个字符是加减，则在加减的部分加上括号。
4. 如果第一个字符和第三个字符不相同，则在第二个运算符的两侧加上括号。
5. 根据列表 `num` 的长度，生成题目的显示结果 `result1` 和电脑进行运算的结果 `result2`。
6. 将 `result1` 和 `result2` 作为元组返回。

• 3.4）repeat(n, min, max)：
  

参数：生成题目的数量n，下限min，上限max
1. 定义一个循环，当 `n` 不等于0时，执行循环体。
2. 调用 `generate_num` 函数生成一个随机数 `t`，该随机数的范围在 `min` 和 `max` 之间。
3. 如果 `title` 列表的长度为0，说明是第一次生成题目，将 `t` 添加到 `title` 列表中，并将 `n` 减1。
4. 如果 `title` 列表的长度不为0，说明已经生成过题目，需要判断新生成的 `t` 是否与之前的题目重复。
5. 遍历 `title` 列表，对于每个已经生成的题目，调用 `isOmorphic` 函数判断新生成的 `t` 是否同构于该题目。
6. 如果新生成的 `t` 与某个已经生成的题目同构，则继续循环，生成新的随机数。
7. 如果新生成的 `t` 与所有已经生成的题目都不同构，则将 `t` 添加到 `title` 列表中，并将 `n` 减1。
8. 循环结束后，函数执行完毕。

• 3.5）main()：
  

算法过程如下
1. 定义 `main` 函数，该函数是程序的主要逻辑。
2. 通过 `input` 函数获取用户输入的功能选项，如果输入不是1或2，则提示用户重新输入。
3. 如果用户选择生成题目，则删除之前已有的文件，避免出现文本重叠的情况。
4. 通过 `input` 函数获取用户输入的题目数量 `n`，数值下限 `min` 和数值上限 `max`。
5. 进行模块异常检验，如果输入不符合要求，则提示用户重新输入。
6. 打开 `Exercises.txt` 和 `Answers.txt` 文件，以追加模式写入题目和答案。
7. 调用 `repeat` 函数生成题目，并将题目和答案写入文件。
8. 遍历 `title` 列表，对于每个题目，将其转换为字符串形式，并将其写入 `Exercises.txt` 文件。
9. 将答案字符串转换为表达式，通过 `eval` 函数计算表达式的值，并将其写入 `Answers.txt` 文件。
10. 如果用户选择自动查答案，则删除之前已有的文件，避免出现文本重叠的情况。
11. 打开 `Exercises.txt` 和 `Answers.txt` 文件，以读取模式读取题目和答案。
12. 逐行读取题目和答案，对于每个题目，将其转换为表达式，并通过 `eval` 函数计算表达式的值。
13. 如果计算结果与答案的差小于 `LIMIT`，则将该题目的编号添加到 `Correct` 列表中，否则将其添加到 `Wrong` 列表中。
14. 将 `Correct` 和 `Wrong` 列表转换为字符串形式，并将其写入 `Grade.txt` 文件。
15. 程序执行完毕。 

4.测试结果

• 1.上下限1-9，生成10道题目：
  
  生成题目结果Exercises.txt：

1. 3/4 - 1/5
2. ( 7÷3 + 1 ) ÷ 3
3. 9/5 - ( 1÷2 * 1 )
4. 5/2 ÷ ( 9 - 1÷3 )
5. 1 * ( 4 + 2 )
6. 3 * ( 7 / 9 )
7. 7 * 2
8. 2 * ( 7÷3 / 1÷4 )
9. 4/5 ÷ 5 ÷ 5
10. ( 8 + 3 ) ÷ 5

题目对应结果Answer.txt：

1. 11/20
2. 10/9
3. 13/10
4. 15/52
5. 6
6. 7/3
7. 14
8. 56/3
9. 4/125
10. 11/5

输入结果：（第三题和第七题答案出错）

1. 11/20
2. 10/9
3. -13/10
4. 15/52
5. 6
6. 7/3
7. 10
8. 56/3
9. 4/125
10. 11/5

检查结果：Grade.txt内容：

Correct: 8(1,2,4,5,6,8,9,10)
Wrong: 2(3,7)

• 2.上下限1-9，生成100道题目：
  
  生成题目结果Exercises.txt：

1. 3 - 9 - 9
2. ( 4÷9 + 2 ) ÷ 5
3. 6 ÷ ( 5÷9 - 4 )
4. 1 * 3/2
5. 8 - 1/2
6. 7 ÷ ( 3 + 3 )
7. 7 * ( 8 + 9 )
8. 6 + ( 7 / 1÷5 )
9. ( 4 + 7÷2 ) * 9
10. 2/5 - ( 2 + 5 )
11. 1 + 2
12. 4 - 1
13. 7/5 + ( 2 - 8÷3 )
14. 5/9 ÷ ( 5 + 1 )
15. 2 * 3/2 * 1
16. 2/7 * 1 * 1
17. 1 + 9
18. 4 * 4
19. 2/9 ÷ 4 ÷ 8
20. 8 - ( 8 + 7÷4 )
21. 1 * 5/7
22. ( 1÷7 - 2 ) ÷ 5/7
23. 3 ÷ 4
24. 1/9 * 1/2 * 1
25. 7/6 * ( 2÷3 / 7÷9 )
26. 6 ÷ ( 9 - 7÷4 )
27. 3/4 - 5
28. 3 ÷ ( 1 + 1÷2 )
29. 3 ÷ 9 ÷ 9
30. 5/3 - 9/4 - 7/6
31. 2 + ( 9÷8 / 5÷2 )
32. 1 ÷ 5 ÷ 4
33. ( 4 + 4÷7 ) ÷ 2
34. 2 - 7
35. 5/9 ÷ 1 ÷ 2/3
36. 7 - ( 1 + 4÷9 )
37. 2 ÷ 3
38. 9 + ( 5÷8 * 9÷7 )
39. 9 - 2
40. 4/9 + ( 5 / 6 )
41. 7/8 - 3 - 6
42. 8/3 - 7
43. 1/3 * 8
44. 5 * 8
45. 2/7 * 7
46. 6/5 ÷ 7/2
47. 7 + ( 2÷9 - 3÷2 )
48. 1 * 9/5
49. 1 * 9
50. 1/2 * ( 1÷5 + 7 )
51. 5/4 ÷ 1 ÷ 6
52. 2 ÷ ( 3÷4 * 4÷5 )
53. 3/4 * 8/5
54. 9/2 + ( 7 - 9 )
55. 2 + 7/6 + 4/3
56. 1/4 ÷ 9 ÷ 5
57. 2/7 + 3 + 2
58. 7/4 + 8/5
59. 4/3 - 2 - 6
60. 7 * 9
61. 3/8 ÷ 5/2
62. 9/5 ÷ 8
63. 8 - 8
64. 5 ÷ 7 ÷ 9
65. 3/2 - 8
66. 5/9 * 9
67. 2 ÷ ( 8 * 3 )
68. ( 8÷9 - 5 ) ÷ 5
69. 4 - 5 - 2
70. 3 - 6
71. 6 - 8
72. 9 ÷ 6 ÷ 7
73. 3 ÷ ( 5 * 9 )
74. 4 + 9
75. 8/9 + 5/7
76. 1 + 5
77. 8/3 + 4 + 1/5
78. 1 * ( 5÷4 + 3÷8 )
79. ( 6 - 2 ) * 5
80. 2/3 - ( 3 * 1 )
81. 5/9 ÷ ( 9÷2 * 6 )
82. 2/9 - 3
83. ( 3 - 5÷7 ) * 4
84. 4 + 3 + 3/5
85. 1 - 2
86. 2/5 * ( 2 / 1 )
87. 5 - ( 6÷7 / 3 )
88. ( 3÷8 - 6 ) * 2
89. 4/5 - ( 9÷5 / 3÷2 )
90. 5 - 7/9 - 8/3
91. 3/5 - 4
92. 1 + 2/3 + 1/5
93. 2/3 - 6
94. 7/8 * 8
95. 7/3 - ( 1÷3 + 1÷2 )
96. 1 ÷ 2/3
97. 9/4 * ( 6 - 5 )
98. 5 ÷ ( 1÷6 * 6 )
99. 1 * 3 * 9
100. 3/2 + 4

题目对应结果Answer.txt：

1. -15
2. 22/45
3. -54/31
4. 3/2
5. 15/2
6. 7/6
7. 119
8. 41
9. 135/2
10. -33/5
11. 3
12. 3
13. 11/15
14. 5/54
15. 3
16. 2/7
17. 10
18. 16
19. 1/144
20. -7/4
21. 5/7
22. -13/5
23. 3/4
24. 1/18
25. 1
26. 24/29
27. -17/4
28. 2
29. 1/27
30. -7/4
31. 49/20
32. 1/20
33. 16/7
34. -5
35. 5/6
36. 50/9
37. 2/3
38. 549/56
39. 7
40. 23/18
41. -65/8
42. -13/3
43. 8/3
44. 40
45. 2
46. 12/35
47. 103/18
48. 9/5
49. 9
50. 18/5
51. 5/24
52. 10/3
53. 6/5
54. 5/2
55. 9/2
56. 1/180
57. 37/7
58. 67/20
59. -20/3
60. 63
61. 3/20
62. 9/40
63. 0
64. 5/63
65. -13/2
66. 5
67. 1/12
68. -37/45
69. -3
70. -3
71. -2
72. 3/14
73. 1/15
74. 13
75. 101/63
76. 6
77. 103/15
78. 13/8
79. 20
80. -7/3
81. 5/243
82. -25/9
83. 64/7
84. 38/5
85. -1
86. 4/5
87. 33/7
88. -45/4
89. -2/5
90. 14/9
91. -17/5
92. 28/15
93. -16/3
94. 7
95. 3/2
96. 3/2
97. 9/4
98. 5
99. 27
100. 11/2

输入结果：（修改15、21题结果）

1. -15
2. 22/45
3. -54/31
4. 3/2
5. 15/2
6. 7/6
7. 119
8. 41
9. 135/2
10. -33/5
11. 3
12. 3
13. 11/15
14. 5/54
15. -3
16. 2/7
17. 10
18. 16
19. 1/144
20. -7/4
21. -5/7
22. -13/5
23. 3/4
24. 1/18
25. 1
26. 24/29
27. -17/4
28. 2
29. 1/27
30. -7/4
31. 49/20
32. 1/20
33. 16/7
34. -5
35. 5/6
36. 50/9
37. 2/3
38. 549/56
39. 7
40. 23/18
41. -65/8
42. -13/3
43. 8/3
44. 40
45. 2
46. 12/35
47. 103/18
48. 9/5
49. 9
50. 18/5
51. 5/24
52. 10/3
53. 6/5
54. 5/2
55. 9/2
56. 1/180
57. 37/7
58. 167/20
59. -20/3
60. 63
61. 3/20
62. 9/40
63. 0
64. 5/63
65. -13/2
66. 5
67. 1/12
68. -37/45
69. -3
70. -3
71. -2
72. 3/14
73. 1/15
74. 13
75. 101/63
76. 6
77. 103/15
78. 13/8
79. 20
80. -7/3
81. 5/243
82. -25/9
83. 64/7
84. 38/5
85. -1
86. 4/5
87. 33/7
88. -45/4
89. -2/5
90. 14/9
91. -17/5
92. 28/15
93. -16/3
94. 7
95. 3/2
96. 3/2
97. 9/4
98. 5
99. 27
100. 11/2

检查结果：Grade.txt内容：

Correct: 98(1,2,3,4,5,6,7,8,9,10,11,12,13,14,16,17,18,19,20,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100)
Wrong: 2(15,21)

• 3.测试上限1-2，生成20道题目
  
  生成题目结果Exercises.txt：

1. 1/2 - 2
2. 2 + ( 2 / 1 )
3. 2 * ( 1 + 1 )
4. 2 - 2
5. 2 - ( 2 / 1 )
6. 2 * 1 * 1/2
7. 1 - ( 1 + 1 )
8. ( 2 - 2 ) ÷ 1
9. 2 ÷ 1
10. 2 - 2 - 2
11. 2 + 2
12. 2 ÷ ( 2 + 1 )
13. 1 * ( 2 / 1 )
14. 1/2 - 1
15. 2 + ( 2 * 2 )
16. 2 * 1 * 1
17. 1 * 1
18. 2 ÷ ( 2 * 2 )
19. 2 * ( 1 - 2 )
20. 2 * ( 1 / 1÷2 )

题目对应结果Answer.txt：

1. -3/2
2. 4
3. 4
4. 0
5. 0
6. 1
7. -1
8. 0
9. 2
10. -2
11. 4
12. 2/3
13. 2
14. -1/2
15. 6
16. 2
17. 1
18. 1/2
19. -2
20. 4

输入结果：（9,15,20题修改）

1. -3/2
2. 4
3. 4
4. 0
5. 0
6. 1
7. -1
8. 0
9. 1
10. -2
11. 4
12. 2/3
13. 2
14. -1/2
15. 4
16. 2
17. 1
18. 1/2
19. -2
20. 0

检查结果：Grade.txt内容：

Correct: 17(1,2,3,4,5,6,7,8,10,11,12,13,14,16,17,18,19)
Wrong: 3(9,15,20)

• 受篇幅影响本文只显示出三次测试结果：我们发现测试结果均无误且程序性能良好，能正确生成题目以及结果，并对二次做题后的结果进行批改。因此程序无误。

5.模块异常分析

• 1）当出现非法访问操作时：
  
  需要重新输入操作。
• 2）输入上下限错误时：
  一、下限输入错误（超过10）：
  
  二、上限输入错误（超过10）：
  
  三、下限大于上限：
  
  四、下限小于0：
  
  当出现以上操作时会提示用户重新输入上下限。

6.Code Quality Analysis

根据分析结果可知，以上都是弱警告，对于程序的运行不会有影响，但是对于代码的可读性可能有一定困难，但由于笔者已经对关键部分的算法和变量进行了注释，因此影响不大。

7.需要优化的部分

• 1.当需要出现大量的数据时，例如生成100000000条题目，回产生程序无法正常运行，长期处于运作状态。

• 2.当运算长度为3且出现括号时，生成的题目/号无法正常显示，而直接显示为÷。对于做题人无影响，但会降低程序效率。

• 3.代码过长，部分代码出现冗余，造成可读性上的困难。

• 解决方案的提出：优化算法，减少所需的运行内存，避免出现题目量过大时出现死循环。对于出现÷的部分优化用replace进行替代。把冗余和相同的部分写为一个新的函数，提高代码的可读性。

8.附录

from fractions import Fraction
import os
import glob
import random
from fractions import Fraction
import time
from memory_profiler import profile
from pympler import muppy
from pympler import summary
import pstats
import cProfile

9.项目小结：

1.团队分工：

2.团队设计流程：

• 1）团队两人共同对于项目的要求进行解读，对相关算法进行寻找，并制定项目文档要求。
• 2）苏建澎完成相关项目的算法设计编写，使得程序能完成基本要求和模块异常处理，以及简易的用户交互界面。
• 3）一名成员对于已有的程序代码进行测试训练，对于相关的bug或者优化部分及时告知另一名设计人员进行修改完善。
• 4）黎灿宇对已有的算法进行性能分析，对性能分析结果进行整理，尝试优化代码。
• 5）二人测试极限数据，测试程序在极端情况的结果，及时发现程序的bug。
• 6）二人共同编写博客园博文。

3.项目团队经验：

• 1）首先团队两人能及时进行沟通，进度最好实时同步，防止一人修改了代码，另一人无法收到实时的结果，造成工作量无故增加。
• 2）测试代码需要认真细致，编程人员有时候无法及时的关注到作为用户的使用情况，此时需要另一名成员进行测试并及时反馈情况。
• 3）团队中一人进行前一步骤的时候，另外一人可以帮助该成员进行搜索，从不同角度尝试各团队成员提供更高效的算法和结果。
• 4）团队中的成员能及时采纳其他成员的正确建议，并实时沟通分析。
• 5）每一个成员都是项目中不可缺少的一环，都有需要自己主要承担的部分，碰到无法解决的问题时能及时告知其他成员寻求帮助。
• 6）每一个成员都从非自己主要负责的板块中进行学习，提高个人能力。
• 7）不摆烂，不躺平，分工明确，及时沟通才能完成一个团队项目。

4.团队成员的闪光点：

• 黎灿宇同学：对于不熟悉的算法能及时学习了解，对于项目中的发现的异常能及时告知另一名成员。不断汲取不同的知识要点，认真细致，从不同角度给另一名成员帮助，例如：测试代码的bug，极限数据，从不同角度给团队成员提供便利，给全部代码补充注释等。
• 苏建澎同学：编程水平熟练，对于需求分析准确，并能够将需求转变为模块化的函数。在工作上积极主动承担，对工作有详细的安排和时间规划，工作效率高，积极交流跟进进度以及代码问题，促进团队氛围融洽。善于学习新知识,例如：利用二叉树实现查重算法、使用markdown语言编写流程图等等。

本栏目推荐文章
• Python学习笔记
• python字典的使用
• python字符串方法
• python列表和元组使用介绍
• python | 小游戏 开局托儿所 自动化脚本 pyautogui
• python中的Map和Filter
• 基于VueCli自定义创建项目
• python-爬元气桌面壁纸
• IDEA项目名称后面出现中括号，模块Modules的名子和文件夹名称不同，可以右键修改名称也可以在File->Project Structure 修改Modules的Name(快捷键ctrl+Shift+Alt+s)
• python中的*args**和**kwargs

四则 项目 Python四则 项目python 四则 程序 项目python 四则 项目 四则 小学 项目 个人 四则 自动生成 项目 四则 自动生成 题目 项目 四则 自动生成 简易 项目 四则 生成器 题目 项目 四则 命令 程序 项目 四则 小学 项目python