小学生四则运算300题-python实现

题目要求：给小学生出的100以内四则运算，有两个运算符，保证每个步骤运算结果都能整除，并且在100以内。

第一次作业代码实现：

import random
oper = ['+','-','*','/']
i = 0
while i<300:
    a = random.randint(1,99)
    b = random.randint(1,99)
    c = random.randint(1,99)
    num = random.randint(0,3)
    a = str(a)
    b = str(b)
    c = str(c)
    res = a + oper[num] + b + oper[num] + c
    m = eval(res)
    res1 = a + oper[num] + b
    n = eval(res1)
    if (m<100) & (m>0) & isinstance(m,int) & (n>0) & isinstance(n,int):
        print(res,'=',m)
        i+=1

选择python就是因为字符转数字，并且算出结果很方便，但是以上的代码存在问题：16行只保证了运算结果和前两位运算在100以内，像5+1/4这样的式子也能出现。

第二次作业基本要求：在上一次作业的基础之上，开发一个图形界面的出题程序，给用户提供以下选项：运算符个数，每一页打印的行数和列数，题目总数。

首先要实现图形化界面，python图形化界面设计←在此链接学了一下怎么用tkinter模块做出一个python图形化界面。

其次题目总数由用户输入这一操作也很容易实现，代码如下。（暂未修改第一次代码的问题）

#1.0
import random
import string
from tkinter import *

def run(num):
    print("输出算式个数为："+ num)
    num = int(num)
    num_ = num + 0
    oper = ['+','-','*','/']
    i = 0
    while i<num_:
        a = random.randint(1,99)
        b = random.randint(1,99)
        c = random.randint(1,99)
        onum = random.randint(0,3)
        a = str(a)
        b = str(b)
        c = str(c)
        res = a + oper[onum] + b
        res = a + oper[onum] + b + oper[onum] + c #两个运算符
        m = eval(res)
        res1 = a + oper[onum] + b
        n = eval(res1)
        if (m<100) & (m>0) & isinstance(m,int) & (n>0) & isinstance(n,int):
            print(res,'=',m)
            i+=1
            txt.insert(END, res + '=' + '\n')   # 追加显示运算结果
    
    inp1.delete(0, END)  # 清空输入
            
root = Tk()
root.geometry('460x240')
root.title('简单四则运算')

lb1 = Label(root, text='请输入四则运算算式数量')
lb1.place(relx=0.1, rely=0.1, relwidth=0.8, relheight=0.1)
#relx 0.1 0.6
inp1 = Entry(root)
inp1.place(relx=0.3, rely=0.2, relwidth=0.3, relheight=0.1)

# 直接调用 run()
btn1 = Button(root, text='计算', command=lambda:run(inp1.get()))
btn1.place(relx=0.3, rely=0.4, relwidth=0.3, relheight=0.1)

# 在窗体垂直自上而下位置60%处起，布局相对窗体高度40%高的文本框
txt = Text(root)
txt.place(rely=0.6, relheight=0.4)

root.mainloop()

界面如下：

在jupyter notebook上输出带得数的式子，图形界面输出不带得数的。

接下来实现运算符的用户输入，我的第一个思路是设置复选框，选择可以有1个、2个、3个……有限个的运算符，然后调用if条件语句，分别实现。看起来很容易实现，但是很容易发现，像下面这种给运算数取随机值的操作，如果需要更多的运算符，不断地写条件只会增加重复代码。于是想要改用列表，把操作数和操作符都放在随机生成的列表中。

        a = random.randint(1,99)
        b = random.randint(1,99)
        c = random.randint(1,99)

首先生成一个随机列表，要求范围在1-99间，将变量start，stop设置成1，99即可。 

#生成随机数组 
import random
def random_list(start,stop,length):
    if length>=0:
        length=int(length)
    start, stop = (int(start), int(stop)) if start <= stop else (int(stop), int(start))
    random_list = []
    for i in range(length):
        random_list.append(random.randint(start, stop))
    return random_list

random_list(0,99,6)

接下来生成操作符列表。

#生成随机数组，数字范围为1-3，生成随机的运算符
import random
def random_operator(number):
    operator = ['+','-','*','/']
    if number>=0:
        number=int(number)
    random_operator = []
    for i in range(number):
        random_operator.append(operator[random.randint(0, 3)])
    return random_operator

a=random_operator(2)
print(a)

在作业一的基础上调用这两个函数发现可以运行，然后就考虑每一部分运算结果都在100以内。

    i = 0
    while i<10:
        operations=random_list(2)
        operator=random_operator(1)
        res1 = str(operations[0]) + operator[0] + str(operations[1])#一个运算符
        m = eval(res1)
        if (m<100) & (m>0) & isinstance(m,int):
            print(res1,'=',m)
            i+=1

像这样一个式子：1*5+6*7-9/3*2=？

我的思路是从第一个操作数开始，测试 [操作数1（操作符1）操作数2] 的运算结果是否在100内且为正整数，然后测试 [操作数2（操作符2）操作数3] 的运算结果是否在100内且为正整数，套入一个循环，不断地测试，这些测试可以写在一个函数里面，用flag的值表示真假。

#x个运算符
#判断是否符合各个位运算都不超过100且为整数
def flag(x,operations, operator):
    flag = 0
    for i in range(0,x):
        m = str(operations[i]) + operator[i] + str(operations[i+1])
        m = eval(m)
        if (0<m<100) & isinstance(m,int):
            flag=1
    
    return flag

现在大体实现了四则运算控制题目数、操作符数量的要求了，运行效果如下。

考虑到（用户需求）需要把符号 *、/ 换成小学生认识的×、÷，在输出函数中加入如下代码。

    #*/转变成×÷
    res_left = str(operations[0])
    for i in range(0,x):
        if operator[i]=='*':
            operator[i]='×'
        if operator[i]=='/':
            operator[i]='÷'
        res_left = res_left + operator[i] + str(operations[i+1])

最后控制输出的行列数，由于算式的数量并不确定，用不能准确的输入需要的行数、列数，所有我只提供了一个输入列数的输入框。设循环次数为i，列数为col，i除col的余数不为0就不换行。

作业二全部的代码就这样了。(╹ڡ╹ )

#四则运算2.4
#改进：1.增加图形化界面 2.用户可以指定题目个数和运算符个数 3.用户可以指定算式打印的列数 
######4.输出结果将*/符号转化为×÷ 5.控制台输出运算，图形界面不打印结果
import random
import string
from tkinter import *

#生成随机数组，数字范围为1-99。参数length：操作数数量（即操作符数量+1）
def random_list(length):
    if length>=0:
        length=int(length)
    random_list = []
    for i in range(length):
        random_list.append(random.randint(1, 99))
    return random_list

#生成随机的运算符，数字范围为0-3。参数length：操作符数量
def random_operator(length):
    operator = ['+','-','*','/']
    if length>=0:
        length=int(length)
    random_operator = []
    for i in range(length):
        random_operator.append(operator[random.randint(0, 3)])
    return random_operator

#参数：x个运算符，操作数列表，操作符列表
#设置flag检测不超过100且为正整数的约束条件
def flag(x,operations, operator):
    flag1= 0
    flag2= 0
    #判断是否符合各个位运算都不超过100且为正整数，循环检测
    for i in range(0,x):
        m = str(operations[i]) + operator[i] + str(operations[i+1])
        m = eval(m)
        if (0<m<100) & isinstance(m,int):
            flag1=1
        else:
            flag1=0
            break#!!!!!不能只写flag1=0,不然下一次的flag1就会覆盖上次的
    #判断运算结果在100以内且为正整数
    res = str(operations[0])
    for i in range(0,x):
        res = res + operator[i] + str(operations[i+1])
    res_right = eval(res)
    if (0<res_right<100) & isinstance(res_right,int):
        flag2=1
    flag=flag1+flag2
    return flag

#参数：x个运算符，操作数列表，操作符列表，i（打印算式个数的计数）
#打印算式及结果，累计算式数量
def print_result(x,operations, operator,loop):
    res = str(operations[0])
    for i in range(0,x):
        res = res + operator[i] + str(operations[i+1])
    res_right = eval(res)
    
    #*/转变成×÷
    res_left = str(operations[0])
    for i in range(0,x):
        if operator[i]=='*':
            operator[i]='×'
        if operator[i]=='/':
            operator[i]='÷'
        res_left = res_left + operator[i] + str(operations[i+1])
        
    print(res_left,'=',res_right)
    loop+=1
    txt.insert(END, res_left+'\t'+'=' + '\t')   # 追加显示运算结果
    return loop

#四则运算主函数。参数：num1为需打印算式个数，num2为操作符数量，col为列数。
def run(num1,num2,col):
    print("输出算式个数为："+ num1)
    num1 = int(num1)
    num1_ = num1 + 0 #字符串转换为整数
    num2 = int(num2)
    num2_ = num2 + 0 #字符串转换为整数
    col = int(col)
    col_ = col + 0 #字符串转换为整数
    i = 0
    while i<num1_:
        operations=random_list(num2_+1)
        operator=random_operator(num2_)
        if 2==flag(num2_,operations, operator): #判断flag
            i=print_result(num2_,operations, operator,i)
            if i % col_ ==0: #输出的列数
                txt.insert(END,'\n')
    
    #inp1.delete(0, END)  # 清空输入

root = Tk()
root.geometry('460x240')
root.title('简单四则运算')

lb1 = Label(root, text='输出算式个数：')
lb1.place(relx=-0.1, rely=0.1, relwidth=0.8, relheight=0.1)
lb2 = Label(root, text='运算符个数：')
lb2.place(relx=-0.1, rely=0.25, relwidth=0.8, relheight=0.1)
lb3 = Label(root, text='输出列数为：')
lb3.place(relx=-0.1, rely=0.4, relwidth=0.8, relheight=0.1)

# 输入框
inp1 = Entry(root)
inp1.place(relx=0.6, rely=0.1, relwidth=0.3, relheight=0.1)
inp2 = Entry(root)
inp2.place(relx=0.6, rely=0.25, relwidth=0.3, relheight=0.1)
inp3 = Entry(root)
inp3.place(relx=0.6, rely=0.4, relwidth=0.3, relheight=0.1)

# lambda调用 run()
btn1 = Button(root, text='打印', command=lambda:run(inp1.get(),inp2.get(),inp3.get()))
btn1.place(relx=0.3, rely=0.55, relwidth=0.3, relheight=0.1)

# 在窗体垂直自上而下位置70%处起，布局相对窗体高度40%高的文本框
txt = Text(root)
txt.place(rely=0.7, relheight=0.4)

root.mainloop()