python实现简易四则运算

一、需求分析

    设计一个不重复的100以内的无括号非分数四则运算生成器，符合加减乘除四则运算     可以选择自动生成题目数量、负数输出、非整数输出、限制大小、运算符的个数(>=1, 记为：num_opt)。

二、设计思路

1. 题目避免重复：随机产生 num_opt+1 个数，通过列表存储产生的数，使用题库字典判断是否重复，如果与前面的题目不重复就继续操作，否则 continue

2. 整数输出：对除法运算，先进行模运算判断是否有余数，如果有余数则重新生成

3. 四则运算结果计算：使用两个栈进行实现，先消除算式中的乘除法，再通过两个栈中的对应关系进行计算

三、代码

from random import randint

operators = ['+', '-', '*', '/']
ti_kus = []  # 防止重复
questions = []
answers = []


def generate_express(nums_opt):
    if nums_opt <= 0:
        return 0

    ti_ku = []

    a = randint(1, 100)

    ti_ku.append(a)

    express = [a]

    for loc in range(nums_opt):
        num = randint(1, 100)
        opt = operators[randint(0, 3)]

        ti_ku.append(num)
        express.append(opt)
        express.append(num)

    if ti_ku in ti_kus:
        return 0
    else:
        ti_kus.append(ti_ku)

    return express


def cal(number1, number2, operator, need_integer):
    if operator == '+':
        return number1 + number2
    if operator == '-':
        return number1 - number2
    if operator == '*':
        return number1 * number2
    if operator == '/':
        if need_integer:
            if number1 % number2:
                return None
            else:
                return int(number1 / number2)
        return number1 / number2


def get_res(expression, need_integer):
    opt_stack = list()
    num_stack = list()

    index = 0
    while index < len(expression):
        element = expression[index]
        if element in operators:
            if element == '+' or element == '-':
                opt_stack.append(element)
            else:  # 消除乘除法
                a = num_stack.pop()
                b = expression[index + 1]
                res = cal(a, b, element, need_integer)
                if res is None:
                    return None
                num_stack.append(res)
                index += 2
                continue
        else:
            num_stack.append(int(element))
        index += 1

    index_num = 0
    index_opt = 0

    while index_opt < len(opt_stack) and index_num < len(num_stack):  # 一个运算符对应两个数
        res = cal(num_stack[0], num_stack[index_num + 1], opt_stack[index_opt], need_integer)
        num_stack[0] = res
        index_num += 1
        index_opt += 1

    return num_stack[0]


def run(nums_iter, nums_opt, max_value=None, need_integer=True, need_negative_num=False):
    count = 0
    while count < nums_iter:
        express = generate_express(nums_opt)
        if express == 0:
            continue

        answer = get_res(express, need_integer)
        if answer is None:
            continue
        if answer < 0 and not need_negative_num:
            continue

        if max_value is not None:
            if answer > max_value:
                continue

        expression = ''
        for index in range(len(express)):
            if express[index] not in operators:
                expression += str(express[index])
            else:
                expression += express[index]

        questions.append("{}=".format(expression))
        answers.append(answer)

        count += 1


if __name__ == '__main__':
    # run(200, 1)
    run(300, 2, max_value=100)
    # run(200, 3, max_value=1000)
    # run(200, 2, max_value=1000, need_integer=False)
    # run(100, 2, max_value=100, need_negative_num=True)

    # 仅输出问题
    # for i in range(len(questions)):
    #     print(questions[i])

    # 输出问题与答案
    for i in range(len(questions)):
        print("{}{}".format(questions[i], answers[i]))

四、运行结果

run(200, 1)

　　

run(300, 2, max_value=100)

　　

run(200, 3, max_value=1000)

　　

run(200, 2, max_value=1000, need_integer=False)

　　

run(100, 2, max_value=100, need_negative_num=True)