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)