四则运算4最终版

队友：http://home.cnblogs.com/u/Megau/

一、设计思路

主要是将四则运算设计成图形界面，因为我们一直用的是Python语言，所以继续使用python语言进行编写。由于python web以及脚本语言的连接近期没有学会，所以只能用图形界面。

运用python的自身空间GUI，Tkinter编程图形界面

整个图形界面基于上次的实验，先制图形界面，然后在对其进行完善

因为环境问题浪费了很多时间，最终没有用python 的web开发框架开发。

选择了GUI。

具体思路：定义函数，制作运算式的函数，运算运算式的结果的函数，然后制作可视化界面要用到的函数

即事件，确定事件发生时用于获取答案，计算结果，

判断结果正误功能组成.下一题事件是由制作运算式，显示运算式组成

结束函数是由统计结果显示结果组成

其他用来显示信息

二、代码

#encoding=utf-8
# -*- coding: cp936 -*-
from Tkinter import *
from fractions import Fraction#分数
from random import randint#随机数

str_timu="3+2/6*4+4/7="
ans=1
global ans
yici=0
tihao=1

def replace(line):
line=line.replace('+',' + ')
line=line.replace('-',' - ')
line=line.replace('*',' * ')
line=line.replace('/',' / ')
line=line.replace('(',' ( ')
line=line.replace(')',' ) ')
line=line.replace('  ',' ')
line=line.replace('=',' = ')
return line

def calculate(operator_cal,operator_num1,operator_num2):
answer=0
if(operator_cal=="+"):
answer=operator_num1+operator_num2
if(operator_cal=="-"):
answer=operator_num1-operator_num2
if(operator_cal=="*"):
answer=operator_num1*operator_num2
if(operator_cal=="/"):
answer=operator_num1/operator_num2
#print"####结果",answer
return answer

def result_get(str1):
operator_anw=[""]*100#存取运算符的数组
operator_ord=0#指针，计算运算符位置，统计运算符的个数

figure_anw=[0]*100#存取运算数的数组
figure_ord=0#指针，计算运算数位置，统计运算数的个数

line=replace(str1)
#print line
line = line.split()
for word in line:
#print "word:",word
if(word=="+"):
operator_anw[operator_ord]="+"
operator_ord=operator_ord+1
elif(word=="-"):
operator_anw[operator_ord]="-"
operator_ord=operator_ord+1
elif(word=="*"):
operator_anw[operator_ord]="*"
operator_ord=operator_ord+1
elif(word=="/"):
operator_anw[operator_ord]="/"
operator_ord=operator_ord+1
elif(word=="("):
operator_anw[operator_ord]="("
operator_ord=operator_ord+1
elif(word==")"):
operator_anw[operator_ord]=")"
operator_ord=operator_ord+1
elif(word=="="):
if(operator_ord==2):#如果出现运算符剩两个的情况，运算第二个运算符
figure_anw[1]=calculate(operator_anw[1],figure_anw[1],figure_anw[2])
figure_anw[0]=calculate(operator_anw[0],figure_anw[0],figure_anw[1])
#print figure_anw[0],"end"
return figure_anw[0]

else:
word=int(word)
word=Fraction(word,1)
figure_anw[figure_ord]=word
figure_ord=figure_ord+1
#print "已存入数字",word
#print "下一个数字位置",figure_ord
#print "下一个运算符位置",operator_ord
#print operator_anw
#print figure_anw
#判断并进行运算，进栈出栈

#优先级进行判断，是否入栈是否运算（+—同一类，*/同一类）

#*+问题
if((word=="+"or word=="-")and operator_ord>1 and (operator_anw[operator_ord-1]=="*" or operator_anw[operator_ord-1]=="/")):
figure_anw[figure_ord-2]=calculate(operator_anw[operator_ord-2],figure_anw[figure_ord-2],figure_anw[figure_ord-1])
operator_anw[operator_ord-1]=""
figure_anw[figure_ord-1]=0
operator_ord=operator_ord-1
operator_anw[operator_ord-1]=word
figure_ord=figure_ord-1
#print operator_anw
#print figure_anw

if(word==")"):#1判断是否出现右括号
#运算函数
#if 如果出现+*两层运算问题，这个if解决第一层*/
if(operator_anw[operator_ord-3]=="+" or operator_anw[operator_ord-3]=="-"):
figure_anw[figure_ord-2]=calculate(operator_anw[operator_ord-2],figure_anw[figure_ord-2],figure_anw[figure_ord-1])
figure_anw[figure_ord-1]=0
operator_anw[operator_ord-1]=""
operator_anw[operator_ord-2]=")"
figure_anw[figure_ord-1]=0
operator_ord=operator_ord-1
figure_ord=figure_ord-1

#这段是将括号中残存的唯一运算符进行运算并消掉括号和运算符
figure_anw[figure_ord-2]=calculate(operator_anw[operator_ord-2],figure_anw[figure_ord-2],figure_anw[figure_ord-1])
figure_anw[figure_ord-1]=0
operator_anw[operator_ord-3]=""
operator_anw[operator_ord-2]=""
operator_anw[operator_ord-1]=""
operator_ord=operator_ord-3
figure_ord=figure_ord-1

#+*+问题 解决
if((word=="+"or word=="-")and (operator_anw[operator_ord-2]=="*" or operator_anw[operator_ord-2]=="/")and operator_ord>1):
figure_anw[figure_ord-2]=calculate(operator_anw[operator_ord-2],figure_anw[figure_ord-2],figure_anw[figure_ord-1])
operator_anw[operator_ord-2]=word
operator_anw[operator_ord-1]=""
figure_anw[figure_ord-1]=0
figure_ord=figure_ord-1
operator_ord=operator_ord-1
#print"*+"

#++问题
if((word=="+"or word=="-")and operator_ord>1):
#print "************************************************",operator_anw[operator_ord-2]
#print operator_anw[operator_ord-2]
if(operator_anw[operator_ord-2]=="+"or operator_anw[operator_ord-2]=="-"):
figure_anw[figure_ord-2]=calculate(operator_anw[operator_ord-2],figure_anw[figure_ord-2],figure_anw[figure_ord-1])
operator_anw[operator_ord-1]=""
figure_anw[figure_ord-1]=0
operator_ord=operator_ord-1
operator_anw[operator_ord-1]=word
figure_ord=figure_ord-1
#print operator_anw
#print figure_anw

def layer(layer_accual2,operat_number2,brackets2,layer_amount2):#递归程序
global operator
if(layer_accual2>0):#对第一层开始计算，将形成3个以上的数字，层数暂时为设定的3。
#选择数字标号
#print"layer_accual2",layer_accual2
opreation_radom=randint(0,layer_accual2-1)#第一层加1，抽取号码，进行替换
find_operat_number=operat_number[opreation_radom]
#即两个数中选择一个数进行替换成为一个简单的四则二元运算
#print "operater_num",operater_num
#将选中的数字从第二层开始，用一个简单的二元运算式替换选中的数字，并插入数组
#插入时依据数字编号判断是否加入括号，依据此数字所在的周围是否有*\符号
#判断是否有添加括号
if((operator[opreation_radom]=="-")or operator[opreation_radom+1]=="-")or operator[opreation_radom]=="/"or(operator[opreation_radom]=="*")or(operator[opreation_radom+1]=="/")or(operator[opreation_radom+1]=="*"):#判断选中数字周围的符号
brackets[layer_accual2]=1
if(multiplication_and_division==2):
brackets[layer_accual2]=0

operater_num=randint(1,multiplication_and_division)  #将运算符入数组
operator_one="?"
#operater_num=2
if(operater_num==1):
operator_one="+"
if(operater_num==2):
operator_one="-"
if(operater_num==3):
operator_one="*"
if(operater_num==4):
operator_one="/"
if(layer_accual2==0):
operator[1]=operator_one
else:

mov_amount=layer_accual2+2-opreation_radom
for i in range(0,mov_amount):
operator[layer_accual2+2-i]=operator[layer_accual2+2-i-1]
operator[opreation_radom+1]=operator_one

zhen_zheng=randint(1,2)  #是真分数或者整数，随机
if(fraction_exist==0):
zhen_zheng=1
if(zhen_zheng==1):          #产生第一个数字
first_num=randint(1,number_range)
first_num=str(first_num)
else:
first_num1=2
first_num2=1
while (first_num1>=first_num2):
first_num1=randint(1,number_range)
first_num2=randint(1,number_range)
first_num=Fraction(first_num1,first_num2)
if(first_num!=0):
first_num="("+str(first_num)+")"
first_num=str(first_num)
zhen_zheng=randint(1,2)  #是真分数或者整数，随机
if(fraction_exist==0):
zhen_zheng=1
if(zhen_zheng==1):          #产生第二个数字
second_num=randint(1,10)
second_num=str(second_num)
else:
second_num1=2
second_num2=1
while (second_num1>=second_num2):
second_num1=randint(1,number_range)
second_num2=randint(1,number_range)
second_num=Fraction(second_num1,second_num2)
if(second_num!=0):
second_num="("+str(second_num)+")"

if(layer_accual2==0):#第0层，将最开始的两个数字存入数组
operat_number[0]=first_num
operat_number[1]=second_num
if(negative_exit==0):#(如果不存在负数)
if(second_num>first_num and operator_one==2):
while(second_num>=first_num):
second_num=randint(1,number_range)

if(remainder==0):#(如果不存在余数)
if(operator_one==4):
while(second_num%first_num!=0):
second_num=randint(1,number_range)

#从第一层开始存入两个数字
if(layer_accual2>0):
mov_amount=layer_accual2+2-opreation_radom
for i in range(0,mov_amount):
operat_number[layer_accual2+1-i]=operat_number[layer_accual2+1-i-1]
operat_number[opreation_radom]=first_num
operat_number[opreation_radom+1]=second_num

#整理算式
if(layer_accual2<1):
expressions=""

if(layer_accual2==1):
tempperate1=str(operat_number[0])
tempperate2=str(operat_number[1])
expressions=operat_number[0]+operator[1]+operat_number[1]

if(layer_accual2>1):
#先找到替换数字，然后产生表达式2，用2替换表达式1
global expressions
kk=str(operat_number[opreation_radom])
expressions2=first_num+operator_one+second_num
if ( brackets[layer_accual2]==1):
expressions2="("+first_num+operator_one+second_num+")"

#创建一个查找机制，寻找不同的数字将其替换？
#while(same_amount>0):
#print"上一层句子",expressions
#print"替换句子",expressions2
#print"用于替换的的数字",find_operat_number
expressions=expressions.replace(find_operat_number," "+find_operat_number+" ")
expressions3=""
recording_1=0
line=expressions.split()
for word2 in line:
if (word2==find_operat_number and recording_1==0):

word2=expressions2
recording_1=1
expressions3=expressions3+word2
expressions3=expressions3.replace(" ","")
expressions=expressions3

layer_accual2=layer_accual2+1
if(layer_accual2<layer_amount2+1):
layer(layer_accual2,operat_number2,brackets2,layer_amount2)

#if(layer_accual==layer_amount2):
#return expressions

def queding_event():#确定事件，将输入框里的字符转化成为答案，并判断是否正确

if(yici==0):
#判断结果
global yici
tishi_panduan=Label(root,text="        ")
tishi_panduan.grid(row=4,column=1)
global ans
global expressions
answer_calculate=result_get(expressions)
answer_user=cin.get()
if(answer_user==""):
tishi_panduan=Label(root,text="输入错误，请重新输入")
tishi_panduan.grid(row=0,column=1)
return
find_chu=0
tishi_panduan=Label(root,text="                                      ")
tishi_panduan.grid(row=4,column=1)
for i in answer_user:
if(i=="/"):
find_chu=1
answer_user=answer_user.split("/")
answer_user_matrix_momentary=[0]*2
i=0
for answer_user_i in answer_user:
answer_user_matrix_momentary[i]=int(answer_user_i)
i=i+1
answer_user=Fraction(answer_user_matrix_momentary[0],answer_user_matrix_momentary[1])
if(find_chu==0):
answer_user=Fraction(int(answer_user),1)
ans=answer_user

if(ans==answer_calculate):
tishi_panduan=Label(root,text="√",bg="green")
tishi_panduan.grid(row=1,column=4)
global right_amount
right_amount=right_amount+1
else:
tishi_panduan=Label(root,text="×",bg="red")
tishi_panduan.grid(row=1,column=4)
zhuanhua=str(answer_calculate)
zhuanhua="正确答案为"+zhuanhua
tishi_cuowu=Label(root,text=zhuanhua,bg="red")
tishi_cuowu.grid(row=3,column=1)
yici=1

def xiayiti_event():
if(counter1>expressions_amount):
tishi3=Label(root,text="题已做完，请提交",bg="red")
tishi3.grid(row=3,column=0)
return 0

expressions=""
tishi_cuowu=Label(root,text='                                      ')
tishi_cuowu.grid(row=3,column=1)
cin.delete('0', 'end')#输入框清除其中内容
layer_accual=0#层数
operator=['k']*(layer_amount+3)#记录运算符的记录
operat_number=["?"]*(layer_amount+2)#记录运算数的记录器
brackets=[0]*(layer_amount+1)#记录括号的存在标志
operator[0]="?"
operator[2]="?"
global ounter1
global layer_amount
global operator
global layer_accual
global operat_number
global brackets
global expressions
layer(layer_accual,operat_number,brackets,layer_amount)
expressions=expressions+"="
timu=Label(root,text="                                     ")
timu.grid(row=1,column=0)
tishi_panduan=Label(root,text="               ")
tishi_panduan.grid(row=1,column=4)

timu=Label(root,text=expressions)
timu.grid(row=1,column=0)
global yici
global ans
global counter1
yici=0
ans=11
counter1=counter1+1
tishi1=Label(root,text="  ")
tishi1.grid(row=0,column=0)

tishi1=Label(root,text="              ")
tishi1.grid(row=0,column=0)
num=str(counter1)
str_tihao="第"+num+"题："
tishi1=Label(root,text=str_tihao)
tishi1.grid(row=0,column=0)

def jieshu():
global counter1
global right_amount
counter1=str(counter1)
counter1="做题数目："+counter1
tishu=Label(root,text=counter1)
tishu.grid(row=7,column=0)

right_amount=str(right_amount)
right_amount="答对数目："+right_amount
dadui=Label(root,text=right_amount)
dadui.grid(row=8,column=0)

##############程序开始
expressions_amount=99999#算式数量
layer_amount=3  #层数，即数的个数
number_range=20#整数数值的大小范围
fraction_exist=0#是否有分数
multiplication_and_division=4#是否有乘除，有则为4
negative_exit=1#负数是否存在，1存在
remainder=1#余数是否存在，1存在
pritenr=1#打印机模式
quit_num=1#退出的标志
#print "expressions_amount",expressions_amount
counter1=0
right_amount=0
global counter1
global right_amount

right_amount=0
answer_matrix=[0]*expressions_amount
answer_matrix_human=[0]*expressions_amount

root=Tk()
root.geometry('450x300+0+0')

num=0
num=str(num)
str_tihao="     "

#显示题号
tishi1=Label(root,text=str_tihao)
tishi1.grid(row=0,column=0)

#显示题目
timu=Label(root,text='请点击开始按钮，开始答题')
timu.grid(row=1,column=0)

#输入框
cin=Entry(root)
cin.grid(row=1,column=1)

#确定按钮
queding=Button(root,text='确定',command=queding_event)
queding.grid(row=1,column=3)
#答案正误判断

#提交
tijiao=Button(root,text='提交',command=queding_event)
tijiao.grid(row=3,column=3)
global tijiao
#下一题
next_ti=Button(root,text='下一题',command=xiayiti_event)
next_ti.grid(row=3,column=3)

#确定按钮
queding=Button(root,text='开始',command=xiayiti_event)
queding.grid(row=6,column=0)

#结束按钮
queding=Button(root,text='结束',command=jieshu)
queding.grid(row=6,column=1)

#k=Message(root,text = 'hello Message')
#k.grid(row=1,column=0)
root.mainloop()

3、截图