结对编程作业（python实现）

一、Github项目地址：https://github.com/asswecanfat/git_place/tree/master/oper_make

二、PSP2.1表格:

PSP2.1	Personal Software Process Stages	预估耗时（分钟）	实际耗时（分钟）
Planning	计划	150	150
· Estimate	· 估计这个任务需要多少时间	150	150
Development	开发	1340	1720
· Analysis	· 需求分析	50	60
· Design Spec	· 生成设计文档	40	60
· Design Review	· 设计复审	30	30
· Coding Standard	· 代码规范	20	20
· Design	· 具体设计	100	120
· Coding	· 具体编码	1000	1250
· Code Review	· 代码复审	60	80
· Test	· 测试（自我测试，修改代码，提交修改）	40	100
Reporting	报告	90	130
· Test Report	· 测试报告	50	80
· Size Measurement	· 计算工作量	20	20
· Postmortem & Process Improvement Plan	· 事后总结, 并提出过程改进计划	20	30
合计		1580	2000

三、效能分析

1.使用了自己写的上下文管理器来记录时间和比较性能（因为click模块的原因导致内置的timeit模块不太好用）

2. 优化过程：

a.在之前的write_file文件中，里面的write_in_file方法是每调用一次就打开一次文件，生成一万道题要16.3秒（忘记截图了）

b.通过将math_op中的迭代器和字典--列表结构当做参数传进去，在write_in_file方法里进行迭代，时间变为2~3秒

四、设计实现过程

　　1.在看了题目后，我们两个人就在晚上进行了讨论，先是对数学表达式的查重的数据结构进行了探索，一开始想用字典，O(1)的查询时间，但由于键值可能重复就放弃了，最后我想到了用+-*/列表链接子在一起的方法，但在实现的过程中，我们还是改成了构建统一的二叉树，以便于查重。在生成数学表达式中，我用了分层递归，就是一个函数，随机选取层数，最大为3，最小为1，进行n=层数的2次递归，实现了完全随机的数学表达式。

　　2.思路是先接收-n和-r参数来控制运算式的数量和数值的范围，通过层数递归和随机数类（该类可以生成分数（无论真假）和整数）和括号随机生成方法生成数学表达式字符串，难点是如何构造统一二叉树。

　　3.数学表达式字符串我们使用了逆波兰表达式，也就是后缀表达式，将数学表达式传递给AnalyOp.check_math_opj静态方法进行处理，决定是否报错还是返回子式列表，逆波兰表达式和答案。我们借鉴了网上的源码，后来发现里面的源码有缺陷，自己动手修改了源码，解决了没有括号时产生的BUG，生成了有优先级的，只有两个数进行运算的子式列表和逆波兰表达式，还有答案。

　　4.然后将子式列表和逆波兰表达式传递给查重的模块并决定写入，难点在于如何构建统一的二叉树，后面我使用了一个标识符——最小位解决了该问题，并构建了字典--列表的数据结构进行O(1+m)的查询，其中键为答案，同一个答案先比较列表中的二叉树是否一样再决定插入。

　　5.由于click的特殊性，其中-n或-r后必须都加参数。

　　6.用Fraction类来构建整数和分数，该类很好的实现了__add__()等两数之间的运算的魔法方法

代码结构功能说明：

data_sturct.py：定义了字典--列表和树节点的数据结构（DataSave类和Node类）

duplicate_check.py：定义了二叉树的构建和查重（creat_tree方法和is_equal方法）

main.py：用于运行的run方法

math_op.py：定义了Creat类，里面有构建单个数学表达式的creator方法和构建多个的creat_more的生成器

math_op_analysis.py:定义了AnalyOp类，使用栈实现逆波兰和计算，还有静态方法check_math_op检查math_op合法性

num_creat.py：定义了NumCreat类，随机生成分数（无论真分数假分数），还有假分数转真分数的静态方法

op_error.py：继承父类ValueError，子类ReduceError和ExceptError

wirte_file.py：定义了处理数学表达式math_op， answer含有的假分数，写入文件的方法

五、代码说明

1.创造数学表达式类

class Creat(object):
    def __init__(self, max_num: int, formula_num: int):
        self.max_num = max_num  # 最大范围
        self.formula_num = formula_num  # 公式最大条数
        self.level = random.randint(2, 4)  # 递归层数
        self.start_level = 0  # 递归开始层
        self.first_level = random.randint(1, self.level - 1)  # 第一个子式递归次数
        self.second_level = self.level - self.first_level  # 第二个子式递归次数
        self.operator = {
            1: '+',
            2: '-',
            3: '*',
            4: '÷',
        }

    def creator(self) -> str:
        math_op = '{}{}{}{}{}'.format(
            self.__creat_math_op(self.first_level),  # 第一个子式
            ' ',
            self.operator[random.randint(1, 4)],  # 随机选取运算符
            ' ',
            self.__creat_math_op(self.second_level),  # 第二个子式
        )
        return math_op

    def __creat_math_op(self, level_choice: int) -> str:
        random_num = random.randint(0, 1)
        self.start_level += 1
        if self.start_level == level_choice:
            self.start_level = 0
            return random.randint(0, self.max_num)
        math_op = '{}{}{}{}{}{}{}'.format(
            self.__brackets(random_num, 0),  # '('
            NumCreat(self.max_num).choices_num(),  # 随机数
            ' ',
            self.operator[random.randint(1, 4)],  # 随机选取运算符
            ' ',
            self.__creat_math_op(level_choice),  # 'xx +|-|*|/ xx'
            self.__brackets(random_num, 1),  # ')'
        )
        self.start_level = 0
        return math_op

    def __brackets(self, random_num: int, choice: int) -> str:  # 决定括号是否填入
        if random_num:
            if choice:
                return ')'
            else:
                return '('
        return ''

    def creat_more(self, data_save):  # 迭代器
        op_num = 0
        while op_num < self.formula_num:
            math_op = self.creator()
            try:
                postfix, answer = AnalyOp.check_math_op(math_op)
                math_op = deal_math_op(math_op, list(postfix), answer, data_save)
                if math_op:
                    yield (math_op, answer)
                    op_num += 1
            except (ExceptError, ReduceError, ZeroDivisionError):
                pass
            self.__init_variable()

    def __init_variable(self):  # 初始化以下值
        self.start_level = 0
        self.level = random.randint(2, 4)
        self.first_level = random.randint(1, self.level - 1)
        self.second_level = self.level - self.first_level

2.构建逆波兰表达式

class AnalyOp(object):  # 使用逆波兰表达式解析
    OPERATOR = ('+', '-', '*', '÷', '(', ')')  # 运算符常量

    def __init__(self, math_op):
        self.math_op = math_op.replace('(', '( ').replace(')', ' )')
        self.math_op = self.math_op.split()
        self.postfix_deque = deque()  # 后缀表达式栈
        self.operators_deque = deque()  # 运算符栈
        self.operators_priority = {  # 运算符优先级
            '+': 1,
            '-': 1,
            '*': 2,
            '÷': 2,
        }

    def __clear_deque(self):  # 用于清空栈
        self.postfix_deque.clear()
        self.operators_deque.clear()

    def mathop_to_postfix(self):
        """将中缀表达式转换为后缀表达式。"""
        for i in self.math_op:
            if self.is_num(i):
                self.postfix_deque.append(i)
            elif i in self.OPERATOR:
                if i == '(':
                    self.operators_deque.append(i)
                elif i == ')':
                    self.__pop_to_left_bracket()
                else:
                    self.__compare_and_pop(i)
        self.__pop_rest()
        return self.postfix_deque

    @staticmethod
    def is_num(text):  # 判断是否为数字
        if '/' in text:
            return True
        return text.isdigit()

    def __pop_to_left_bracket(self):
        """依次弹栈并追加到后缀表达式，直到遇到左括号为止。"""
        while self.operators_deque:
            operator = self.operators_deque.pop()
            if operator == '(':
                break
            self.postfix_deque.append(operator)

    def __compare_and_pop(self, text):
        """比较优先级并进行相应操作。"""
        if not self.operators_deque:
            self.operators_deque.append(text)
            return
        while self.operators_deque:
            operator = self.operators_deque.pop()
            if operator == '(':
                self.operators_deque.append('(')
                self.operators_deque.append(text)
                return
            elif self.operators_priority[text] > self.operators_priority[operator]:
                self.operators_deque.append(operator)
                self.operators_deque.append(text)
                return
            elif text == operator:
                self.postfix_deque.append(operator)
            else:
                self.postfix_deque.append(operator)
        self.operators_deque.append(text)

    def __pop_rest(self):
        """弹出所有剩余的运算符，追加到后缀表达式。"""
        while self.operators_deque:
            self.postfix_deque.append(self.operators_deque.pop())

    def parse_out_son(self):
        """只解析出有优先级的子式"""
        postfix = deepcopy(self.mathop_to_postfix())
        num_deque = deque()
        son_op_list = []
        answer = None
        for i in self.postfix_deque:
            if self.is_num(i):
                num_deque.append(i)
            else:
                right_num = num_deque.pop()
                left_num = num_deque.pop()
                son_op = f'{left_num}{i}{right_num}'
                son_op_list.append(son_op)
                answer = self.operation_func(i)(left_num, right_num)
                num_deque.append(answer)
        self.__clear_deque()
        return son_op_list, postfix, str(answer)

    @staticmethod
    def operation_func(operator):  # 选择运算方法
        operation_dict = {
            '+': lambda x, y: Fraction(x) + Fraction(y),
            '-': lambda x, y: Fraction(x) - Fraction(y),
            '*': lambda x, y: Fraction(x) * Fraction(y),
            '÷': lambda x, y: Fraction(x) / Fraction(y),
        }
        return operation_dict[operator]

3.统一二叉树构建

def creat_tree(postfix_deque):  # 创建统一的二叉树
    """_min为树结点的最小标志位，左子树小，右子树大"""
    node = deque()
    for i in postfix_deque:
        if AnalyOp.is_num(i):
            node.append(Node(num=i, answer=i, _min=i))
        else:
            max_num, min_num = node.pop(), node.pop()
            if i != '÷' and i != '-':
                if max_num.answer == min_num.answer:
                    max_num, min_num = (max_num, min_num) \
                        if Fraction(max_num._min) >= Fraction(min_num._min) \
                        else (min_num, max_num)
                else:
                    max_num, min_num = (max_num, min_num) \
                        if Fraction(max_num.answer) > Fraction(min_num.answer) \
                        else (min_num, max_num)
            op = Node(operator=i,
                      right_child=max_num,
                      left_child=min_num,
                      answer=AnalyOp.operation_func(i)(min_num.answer, max_num.answer),
                      _min=min_num._min,)
            node.append(op)
    return node.pop()

4.题目/答案文件生成

def write_in_file(creat, data_save):  # 写入文件
    with open(r'./Exercises.txt', 'a', encoding='utf-8') as q:
        with open(r'./Answers.txt', 'a', encoding='utf-8') as a:
            for num, (math_op, answer) in enumerate(creat.creat_more(data_save)):
                answer = deal_answer(answer)
                q.write('{}.{} = {}'.format(num + 1,
                                            math_op,
                                            '\n', ))
                a.write('{}.{}{}'.format(num + 1,
                                         answer,
                                         '\n'))
                print('{}{}{}'.format('\r', num + 1, '条题目已生成！！'), sep='', end='', flush=True)

5.文件之间的比较

def compare_2_file(f1, f2):  # f1是题目文件，f2是答案文件
    coding1 = _get_coding(f1)
    coding2 = _get_coding(f2)
    if coding1 is not None and coding2 is not None:
        with open(f1, 'r', encoding=coding1) as f1:
            with open(f2, 'r', encoding=coding2) as f2:
                with open(r'.\Grade.txt', 'w', encoding='utf-8') as g:
                    right_num = 0
                    right_answer = []
                    wrong_num = 0
                    wrong_answer = []
                    f1_dict = _deal_lsit(f1)
                    f2_dict = _deal_lsit(f2)
                    for i in f1_dict.keys():
                        if f1_dict[i] == f2_dict[i]:
                            right_num += 1
                            right_answer.append(i)
                        else:
                            if f1_dict[i] != '':
                                wrong_num += 1
                                wrong_answer.append(i)
                    g.write(f'Correct: {right_num} ({right_answer[0]}')
                    for i in right_answer[1:]:
                        g.write(f', {i}')
                    g.write('){}Wrong: {} ({}'.format('\n', wrong_num, wrong_answer[0]))
                    for i in wrong_answer[1:]:
                        g.write(f', {i}')
                    g.write('){}'.format('\n'))


def _deal_lsit(f) -> dict:
    f_list = list(map(lambda x: re.split(r'\.(.+= ?)?', x), f.readlines()))  # 用于分开题目序号和答案
    return {i[0]: i[2].rstrip('\n') for i in f_list}


def _get_coding(f):  # 处理文件的编码，以防报错
    text = open(f, 'rb').read()
    return chardet.detect(text)['encoding']

六、测试运行

1. 测试-n -r 功能：

　　　　a. 单道题目生成和结果正确