s表达式计算器实验python

‘壹’ 用python正则表达式替换字符串问题 我用python写一个计算器，想用正则表达式将字符串中的一些内容替换，

先用正则表达式 sin((d+(.d+)?)) 取第一捕获组的数据

把sin(45)中的角度值angle匹配出来,然后计算出sin(angle)的值value,

最后用正则表达式 "sin("+angle+")" 替换成String.valueOf(value) //value的字符串形式

我给你一个完整的java语言的例子,你看看吧.

importjava.util.regex.Matcher;
importjava.util.regex.Pattern;
publicclassAA{
publicstaticvoidmain(String[]args){
Strings="1+2*3-(5/6)+sin(45)-ln(100)";
Stringregex="sin\((\d+(\.\d+)?)\)";
Patternp=Pattern.compile(regex);
Matcherm=p.matcher(s);
while(m.find()){
Stringangle=m.group(1);//取出sin函数的角度值
doubled=Double.parseDouble(angle);//把角度值转换成double型
doublevalue=Math.sin(d/180*Math.PI);//把角度值转换成弧度值然后计算sin函数值
s=s.replaceAll("sin\("+angle+"\)",String.valueOf(value));//把相应的sin(45)字符串替换成sin函数值
System.out.println(s);//输出结果,你也可以在程序最后输出结果,也就是在while循环完成后输出结果
}
}
}

运行结果

1+2*3-(5/6)+0.7071067811865475-ln(100)

‘贰’ 如何使用python编程写一个加法计算器

1、打开idle。点击file，然后点击new file.这是创建一个新的文件。
新建一个文件之后，我们输入第一行代码，使用print函数，在屏幕上打印一句话，其中字符串要使用双引号，输入法要使用英文输入法，如果符号使用中文输入法输入，就会出现错误。print("我们做一个两个整数相加的计算题！")
同理，在屏幕上打印第二句话，与用户交互，提醒用户输入第一个数。
第三行调用input函数，将用户输入的内容赋值给a,这时候a收到的是字符串信息，所以需要下一步把字符串转换为整型。这输入计算机处理数据指令。
然后依照以上的步骤写第二个加数，和最后输出的和，注意最后一句打印结果时，引号内部是字符串形式，x+y是数值形式，所以需要在中间加上一个逗号。如果不加逗号就会提示错误信息，以上就是所有的程序编写完成，下一步就开始保存，命名，运行。如图所示
运行结果如下：
更多Python相关技术文章，请访问Python教程栏目进行学习！以上就是小编分享的关于如何使用python编程写一个加法计算器的详细内容希望对大家有所帮助，更多有关python教程请关注环球青藤其它相关文章！

‘叁’ 用PYTHON2做个计算器，只要加减乘除

# encoding: UTF-8
from Tkinter import *
class App:
def __init__(self,master):
frame=Frame(master)
frame.pack()

self.v = StringVar()
self.v.set(" ")
self.entry1=Entry(frame,text="")
self.entry1.grid(row=0,columnspan=2)
self.label0=Label(frame,text="Answer:").grid(row=1,column=0)
self.label1=Label(frame,textvariable=self.v).grid(row=1,column=1)

self.button1=Button(frame,text=" = ",command=self.inputnumber).grid(row=2)

#self.hi_there.pack(side=LEFT)
def inputnumber(self):
self.v.set(eval(self.entry1.get()))

root=Tk()
app=App(root)
root.mainloop()

以上代码拷贝下来保存为一个py文件，然后运行就好。
注意没有任何错误检查的。

‘肆’ python计算器

python计算器实现：

wx.TextCtrl（文本输入控件），这个作为计算器的显示屏，点击数字时用AppendText方法将数字添加至文本末尾，要取出数字时用GetValue方法，点击运算符时要将文本框中的数字清空（先存储）用Clear方法然后还有将操作符保存，点击等号后要将第二个操作数存储，然后用int方法将字符串转换为数字，计算后用SetValue方法将结果送入文本框，具体代码如下：

importwx
#beginwxGlade:extracode
#endwxGlade
classMyFrame(wx.Frame):
def__init__(self,*args,**kwds):
#beginwxGlade:MyFrame.__init__
kwds["style"]=wx.DEFAULT_FRAME_STYLE
wx.Frame.__init__(self,*args,**kwds)
self.text_ctrl_1=wx.TextCtrl(self,-1,"",style=wx.TE_READONLY)
self.button_37=wx.Button(self,-1,"1")
self.button_38=wx.Button(self,-1,"2")
self.button_39=wx.Button(self,-1,"3")
self.button_40=wx.Button(self,-1,"+")
self.button_41=wx.Button(self,-1,"4")
self.button_42=wx.Button(self,-1,"5")
self.button_43=wx.Button(self,-1,"6")
self.button_44=wx.Button(self,-1,"-")
self.button_46=wx.Button(self,-1,"7")
self.button_45=wx.Button(self,-1,"8")
self.button_47=wx.Button(self,-1,"9")
self.button_48=wx.Button(self,-1,"x")
self.button_49=wx.Button(self,-1,"C")
self.button_50=wx.Button(self,-1,"0")
self.button_51=wx.Button(self,-1,"=")
self.button_52=wx.Button(self,-1,"/")
self.__set_properties()
self.__do_layout()
self.Bind(wx.EVT_BUTTON,self.bu1,self.button_37)
self.Bind(wx.EVT_BUTTON,self.bu2,self.button_38)
self.Bind(wx.EVT_BUTTON,self.bu3,self.button_39)
self.Bind(wx.EVT_BUTTON,self.bu_plus,self.button_40)
self.Bind(wx.EVT_BUTTON,self.bu4,self.button_41)
self.Bind(wx.EVT_BUTTON,self.bu5,self.button_42)
self.Bind(wx.EVT_BUTTON,self.bu6,self.button_43)
self.Bind(wx.EVT_BUTTON,self.bu_min,self.button_44)
self.Bind(wx.EVT_BUTTON,self.bu7,self.button_46)
self.Bind(wx.EVT_BUTTON,self.bu8,self.button_45)
self.Bind(wx.EVT_BUTTON,self.bu9,self.button_47)
self.Bind(wx.EVT_BUTTON,self.bu_mul,self.button_48)
self.Bind(wx.EVT_BUTTON,self.bu_clear,self.button_49)
self.Bind(wx.EVT_BUTTON,self.bu0,self.button_50)
self.Bind(wx.EVT_BUTTON,self.bu_result,self.button_51)
self.Bind(wx.EVT_BUTTON,self.bu_chu,self.button_52)
#endwxGlade
self.Show(True)
def__set_properties(self):
#beginwxGlade:MyFrame.__set_properties
self.SetTitle("PythonCalculaterbyCYG")
self.text_ctrl_1.SetMinSize((400,50))
self.button_37.SetMinSize((100,50))
self.button_38.SetMinSize((100,50))
self.button_39.SetMinSize((100,50))
self.button_40.SetMinSize((100,50))
self.button_41.SetMinSize((100,50))
self.button_42.SetMinSize((100,50))
self.button_43.SetMinSize((100,50))
self.button_44.SetMinSize((100,50))
self.button_46.SetMinSize((100,50))
self.button_45.SetMinSize((100,50))
self.button_47.SetMinSize((100,50))
self.button_48.SetMinSize((100,50))
self.button_49.SetMinSize((100,50))
self.button_50.SetMinSize((100,50))
self.button_51.SetMinSize((100,50))
self.button_52.SetMinSize((100,50))
#endwxGlade
def__do_layout(self):
#beginwxGlade:MyFrame.__do_layout
sizer_2=wx.BoxSizer(wx.VERTICAL)
sizer_3=wx.BoxSizer(wx.VERTICAL)
grid_sizer_1=wx.GridSizer(4,4,0,0)
sizer_3.Add(self.text_ctrl_1,0,0,0)
grid_sizer_1.Add(self.button_37,0,0,0)
grid_sizer_1.Add(self.button_38,0,0,0)
grid_sizer_1.Add(self.button_39,0,0,0)
grid_sizer_1.Add(self.button_40,0,0,0)
grid_sizer_1.Add(self.button_41,0,0,0)
grid_sizer_1.Add(self.button_42,0,0,0)
grid_sizer_1.Add(self.button_43,0,0,0)
grid_sizer_1.Add(self.button_44,0,0,0)
grid_sizer_1.Add(self.button_46,0,0,0)
grid_sizer_1.Add(self.button_45,0,0,0)
grid_sizer_1.Add(self.button_47,0,0,0)
grid_sizer_1.Add(self.button_48,0,0,0)
grid_sizer_1.Add(self.button_49,0,0,0)
grid_sizer_1.Add(self.button_50,0,0,0)
grid_sizer_1.Add(self.button_51,0,0,0)
grid_sizer_1.Add(self.button_52,0,0,0)
sizer_3.Add(grid_sizer_1,1,wx.EXPAND,0)
sizer_2.Add(sizer_3,1,wx.EXPAND,0)
self.SetSizer(sizer_2)
sizer_2.Fit(self)
self.Layout()
#endwxGlade
defbu1(self,event):#wxGlade:MyFrame.<event_handler>
self.text_ctrl_1.AppendText("1")
event.Skip()
defbu2(self,event):#wxGlade:MyFrame.<event_handler>
self.text_ctrl_1.AppendText("2")
event.Skip()
defbu3(self,event):#wxGlade:MyFrame.<event_handler>
self.text_ctrl_1.AppendText("3")
event.Skip()
defbu_plus(self,event):#wxGlade:MyFrame.<event_handler>
self.num1=self.text_ctrl_1.GetValue()
self.op="+"
self.text_ctrl_1.Clear()
event.Skip()
defbu4(self,event):#wxGlade:MyFrame.<event_handler>
self.text_ctrl_1.AppendText("4")
event.Skip()
defbu5(self,event):#wxGlade:MyFrame.<event_handler>
self.text_ctrl_1.AppendText("5")
event.Skip()
defbu6(self,event):#wxGlade:MyFrame.<event_handler>
self.text_ctrl_1.AppendText("6")
event.Skip()
defbu_min(self,event):#wxGlade:MyFrame.<event_handler>
self.num1=self.text_ctrl_1.GetValue()
self.op="-"
self.text_ctrl_1.Clear()
event.Skip()
defbu7(self,event):#wxGlade:MyFrame.<event_handler>
self.text_ctrl_1.AppendText("7")
event.Skip()
defbu8(self,event):#wxGlade:MyFrame.<event_handler>
self.text_ctrl_1.AppendText("8")
event.Skip()
defbu9(self,event):#wxGlade:MyFrame.<event_handler>
self.text_ctrl_1.AppendText("9")
event.Skip()
defbu_mul(self,event):#wxGlade:MyFrame.<event_handler>
self.num1=self.text_ctrl_1.GetValue()
self.op="x"
self.text_ctrl_1.Clear()
event.Skip()
defbu_clear(self,event):#wxGlade:MyFrame.<event_handler>
self.text_ctrl_1.Clear()
event.Skip()
defbu0(self,event):#wxGlade:MyFrame.<event_handler>
self.text_ctrl_1.AppendText("0")
event.Skip()
defbu_chu(self,event):#wxGlade:MyFrame.<event_handler>
self.num1=self.text_ctrl_1.GetValue()
self.op="/"
self.text_ctrl_1.Clear()
event.Skip()
defbu_result(self,event):#wxGlade:MyFrame.<event_handler>
self.num2=self.text_ctrl_1.GetValue()
num1=int(self.num1)
num2=int(self.num2)
ifself.op=="+":
self.text_ctrl_1.SetValue(str(num1+num2))
elifself.op=="-":
self.text_ctrl_1.SetValue(str(num1-num2))
elifself.op=="x":
self.text_ctrl_1.SetValue(str(num1*num2))
elifself.op=="/":
self.text_ctrl_1.SetValue(str(num1/num2))
event.Skip()
#endofclassMyFrame
if__name__=="__main__":
app=wx.App(False)
myframe=MyFrame(None)
app.MainLoop()

‘伍’ 用Python3实现表达式求值

include <malloc.h> #include <stdio.h> #include <ctype.h>//判断是否为字符的函数的头文件 #define maxsize 100 typedef int elemtype; typedef struct sqstack sqstack;//由于sqstack不是一个类型 而struct sqstack才是 char ch[7]=;//把符号转换成一个字符数组 int f1[7]=;//栈内元素优先级 int f2[7]=;//栈外的元素优先级 struct sqstack { elemtype stack[maxsize]; int top; }; void Initstack(sqstack *s) { s->top=0; } void Push(sqstack *s,elemtype x) { if(s->top==maxsize-1) printf("Overflow\n"); else { s->top++; s->stack[s->top]=x; } } void Pop(sqstack *s,elemtype *x) { if(s->top==0) printf("underflow\n"); else { *x=s->stack[s->top]; s->top--; } } elemtype Gettop(sqstack s) { if(s.top==0) { printf("underflow\n"); return 0; } else return s.stack[s.top]; } elemtype f(char c) { switch(c) { case '+': return 0; case '-': return 1; case '*': return 2; case '/': return 3; case '(': return 4; case ')': return 5; default: return 6; } } char precede(char c1,char c2) { int i1=f(c1); int i2=f(c2);//把字符变成数字 if(f1[i1]>f2[i2])//通过原来设定找到优先级 return '>'; else if(f1[i1]<f2[i2]) return '<'; else return '='; } int Operate(elemtype a,elemtype theta,elemtype b) { int sum; switch(theta) { case 0: sum=a+b; break; case 1: sum=a-b; break; case 2: sum=a*b; break; default: sum=a/b; } return sum; } EvaluateExpression() { char c; int i=0,sum=0; int k=1,j=1;//设置了开关变量 elemtype x,theta,a,b; sqstack OPTR,OPND; Initstack(&OPTR); Push(&OPTR,f('#'));//0压入栈 Initstack(&OPND); c=getchar(); if(c==ch[2]||c==ch[3]||c==ch[5]||c==ch[6])//先对＋和-的情况忽略和左括号的情况 { printf("错误1 \n"); k=0; return 0; } if(c==ch[0]) c=getchar();//如果是＋，把它覆盖 if(c==ch[1]) { j=0; c=getchar();//也把－号覆盖 } while(c!='#'||ch[Gettop(OPTR)]!='#') { if(isdigit(c)) { sum=0; while(isdigit(c)) { if(!j) { sum=sum*10-(c-'0');//实现了数字串前面有负号（之前是：sum=-(sum*10)-(c-'0')结果是－12＋13＝21） } else sum=sum*10+(c-'0'); c=getchar(); } Push(&OPND,sum);//如果还是数字先不压栈，把数字串转化成十进制数字再压栈 j=1; } else if(k) { switch(precede(ch[Gettop(OPTR)],c)) { case'<': Push(&OPTR,f(c));//把它们整型化 c=getchar(); if(c==ch[0]||c==ch[1]||c==ch[2]||c==ch[3]||c==ch[5]||c=='\n')//要除去下个是‘（’的情况 也把以运算符归到这里来 { printf("出错2\n"); k=0; return 0;//加了开关变量和返回0的值使程序更以操作 } break; case'=': Pop(&OPTR,&x); c=getchar(); if(c==ch[0]||c==ch[1]||c==ch[2]||c==ch[3]||c==ch[5]||c=='\n')//把ch[6]的情况也忽略了但此时并没有注意到右括号后面右运算符的情况 { printf("出错2\n"); k=0; return 0; } break; case'>': Pop(&OPTR,&theta); Pop(&OPND,&b); Pop(&OPND,&a);//注意这里是谁先出栈 Push(&OPND,Operate(a,theta,b)); break; } } }//在这里判断是否以运算符结束是不对的 return(Gettop(OPND)); } main() { int result; printf("输入你的算术表达式：\n"); result=EvaluateExpression(); printf("结果是 :%d\n",result); return 0; } : 本计算器利用堆栈来实现。 1、定义后缀式计算器的堆栈结构 因为需要存储的单元不多，这里使用顺序栈，即用一维数组来模拟堆栈： #define MAX 100 int stack[MAX]; int top=0; 因此程序中定义了长度为MAX的一维数组，这里MAX用宏定义为常数100，我们可以修改宏定义而重新定义堆栈的大小。 整型数据top为栈顶指示，由于程序开始时堆栈中并无任何数据元素，因此top被初始化为0。 2、存储后缀式计算器的运算数 我们定义了堆栈stack[MAX]后，就可以利用入栈操作存储先后输入的两个运算数。 下面看一下是如何实现的： int push(int i) /*存储运算数，入栈操作*/ { if(top<MAX) { stack[++top]=i; /*堆栈仍有空间，栈顶指示上移一个位置*/ return 0; } else /*堆栈已满，给出错误信息，返回出错指示*/ { printf("The stack is full"); return ERR; } } 我们在调用函数push时，如果它的返回值为0，说明入栈操作成功；否则，若返回值为ERR(在程序中说明为-1)，说明入栈操作失败。 3、从堆栈中取出运算数 当程序中读完了四则运算符后，我们就可以从堆栈中取出已经存入的两个运算数，构成表达式，计算出结果。取出运算数的函数采用的正是出栈算法。在本例中，实现该算法的函数 为pop(): int pop(); /*取出运算数，出栈操作*/ { int var; /*定义待返回的栈顶元素*/ if(top!=NULL) /*堆栈中仍有数据元素*/ { var=stack[top--]; /*堆栈指示下移一个位置*/ return var; } else /*堆栈为空，给出错误信息，并返回出错返回值*/ printf("The stack is cmpty!\n"); return ERR; } 同样，如果堆栈不为空，pop()函数返回堆栈顶端的数据元素，否则，给出栈空提示，并返回错误返回值ERR。 4、设计完整的后缀式计算器 有了堆栈存储运算数，后缀式计算器的设计就很简单了。程序首先提示用户输入第一个运算数，调用push()函数存入堆栈中；而后提示用户输入第二个运算数，同样调用push()函数存入堆栈中。接下来，程序提示用户输入+,-,*,/四种运算符的一种，程序通过switch_case结构判断输入运算符的种类，转而执行不同的处理代码。以除法为例，说明程序的执行流程： case '/': b=pop(); a=pop(); c=a/b; printf("\n\nThe result is %d\n",c); printf("\n"); break; 程序判断用户输入的是除号后，就执行上述代码。首先接连两次调用pop()函数从堆栈中读出先前输入的运算数，存入整型数a和b中；然后执行除法运算，结果存入单元c中。这时需要考虑究竟谁是被除数，谁是除数。由于开始我们先将被除数入栈，根据堆栈“先进后出”的原则，被除数应该是第二次调用pop()函数得到的返回值。而除数则是第一次调用pop()函数得到的返回值。 最后程序打印出运算结果，并示提示用户是否继续运行程序： printf("\t Continue?(y/n):"); l=getche(); if(l=='n') exit(0); 如果用户回答是"n"，那么结束程序，否则继续循环。 完整的程序代码如下： #include<stdio.h> #include<conio.h> #include<stdlib.h> #define ERR -1 #define MAX 100 /*定义堆栈的大小*/ int stack[MAX]; /*用一维数组定义堆栈*/ int top=0; /*定义堆栈指示*/ int push(int i) /*存储运算数,入栈操作*/ { if(top<MAX) { stack[++top]=i; /*堆栈仍有空间，栈顶指示上移一个位置*/ return 0; } else { printf("The stack is full"); return ERR; } } int pop() /*取出运算数，出栈操作*/ { int var; /*定义待返回的栈顶元素*/ if(top!=NULL) /*堆栈中仍有元素*/ { var=stack[top--]; /*堆栈指示下移一个位置*/ return var; /*返回栈顶元素*/ } else printf("The stack is empty!\n"); return ERR; } void main() { int m,n; char l; int a,b,c; int k; do{ printf("\tAriothmatic Operate simulator\n"); /*给出提示信息*/ printf("\n\tPlease input first number:"); /*输入第一个运算数*/ scanf("%d",&m); push(m); /*第一个运算数入栈*/ printf("\n\tPlease input second number:"); /*输入第二个运算数*/ scanf("%d",&n); push(n); /*第二个运算数入栈*/ printf("\n\tChoose operator(+/-/*//):"); l=getche(); /*输入运算符*/ switch(l) /*判断运算符，转而执行相应代码*/ { case '+': b=pop(); a=pop(); c=a+b; printf("\n\n\tThe result is %d\n",c); printf("\n"); break; case '-': b=pop(); a=pop(); c=a-b; printf("\n\n\tThe result is %d\n",c); printf("\n"); break; case '*': b=pop(); a=pop(); c=a*b; printf("\n\n\tThe result is %d\n",c); printf("\n"); break; case '/': b=pop(); a=pop(); c=a/b; printf("\n\n\tThe result is %d\n",c); printf("\n"); break; } printf("\tContinue?(y/n):"); /*提示用户是否结束程序*/ l=getche(); if(l=='n') exit(0); }while(1); } : #include <stdio.h> #include <conio.h> #include <malloc.h> #include <stdlib.h> #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 typedef int Status; #define STACK_INIT_SIZE 100 //初始分配量 #define STACKINCREMENT 10 //存储空间的分配增量 typedef char ElemType; typedef ElemType OperandType; //操作数 typedef char OperatorType; typedef struct { ElemType *base; ElemType *top; int stacksize; }SqStack; Status InitStack(SqStack &S) { //构造一个空栈S S.base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType)); if(!S.base) exit (OVERFLOW); S.top = S.base; S.stacksize = STACK_INIT_SIZE; return OK; } Status GetTop(SqStack S){ ElemType e; if (S.top == S.base) return ERROR; e = *(S.top-1); return e; } Status Push (SqStack &S,ElemType e) { //插入元素e为新的栈顶元素 if (S.top - S.base >= S.stacksize){ S.base = (ElemType *) realloc ( S.base, (S.stacksize + STACKINCREMENT) * sizeof(ElemType)); if(!S.base) exit (OVERFLOW); S.top = S.base + S.stacksize; S.stacksize += STACKINCREMENT; } *S.top++ = e; return OK; } Status Pop (SqStack &S,ElemType &e){ //若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR if(S.top == S.base) return ERROR; e = * --S.top; return OK; } char In(char c,char OP[]) { if(c>=35 && c<=47) return 1; else return 0; } char OP[8]=; int m[7][7]={1,1,2,2,2,1,1, 1,1,2,2,2,1,1, 1,1,1,1,2,1,1, 1,1,1,1,2,1,1, 2,2,2,2,2,0,-1, 1,1,1,1,-1,1,1, 2,2,2,2,2,-1,0};//1 > 2 < 0 = -1 不存在 char Precede(char i,char j) { int a,b; char *p; for(p=OP,a=0;*p!='\0';p++,a++) if(*p==i) break; for(p=OP,b=0;*p!='\0';p++,b++) if(*p==j) break; if(m[a][b]==1) return '>'; else if(m[a][b]==2) return '<'; else if(m[a][b]==0) return '='; else return 'O'; } char Operate(char a,char theta,char b) { if(a>47) a=atoi(&a); if(b>47) b=atoi(&b); switch(theta) { case '+': return a+b; break; case '-': return a-b; break; case '*': return a*b; break; case '/': return a/b; break; } } OperandType EvaluateExpression() { SqStack OPTR,OPND; OperandType a,b,c; OperatorType theta; InitStack(OPTR); Push(OPTR,'#'); InitStack(OPND); c=getchar(); while (c!='#' || GetTop(OPTR)!='#') { if (!In(c,OP)) else switch(Precede(GetTop(OPTR),c)) { case '<' : Push(OPTR,c); c = getchar(); break; case '=' : Pop(OPTR,c); c = getchar(); break; case '>' : Pop(OPTR,theta); Pop(OPND,b); Pop(OPND,a); Push(OPND,Operate(a,theta,b)); break; } } return GetTop(OPND); } void main() { printf("(以#为结束符)\n"); printf("请输入：\n"); int a; a=(int)EvaluateExpression(); printf("%d",a); getch(); } : ls都正确 : C++ In Action这本书里面有表达式求值的详细项目分析. : 数据结构的书里面都有的,仔细看一下 : studyall123的只能对0到9的数字运算才有效,对于10以上的数字就不行!不知道有没有更好的方法! : 现在的人，连google一下都懒啊 : 实际上是按照逆波兰式的顺序让输入的表达式入栈，再根据运算符优先级来计算。 : lenrning!

‘陆’ 将 Python 当做计算器使用方法

我们来尝试一些简单的 Python 命令。启动解释器然后等待主提示符 >>> 出现（不需要很久）。
3.1.1. 数字
解释器表现得就像一个简单的计算器：可以向其录入一些表达式，它会给出返回值。表达式语法很直白：运算符 +，-，* 和 / 与其它语言一样(例如：Pascal 或 C)；括号 (()) 用于分组。
整数(例如，2， 4， 20 )的类型是 int，带有小数部分的数字(例如，5.0， 1.6)的类型是 float。在本教程的后面我们会看到更多关于数字类型的内容。
除法(/)永远返回一个浮点数。如要使用 floor 除法 并且得到整数结果（丢掉任何小数部分），你可以使用 // 运算符；要计算余数你可以使用 %
此变量对于用户是只读的。不要尝试给它赋值 —— 你只会创建一个独立的同名局部变量，它屏蔽了系统内置变量的魔术效果。
除了 int 和 float，Python 还支持其它数字类型，例如 Decimal 和 Fraction。Python 还内建支持 复数 ，使用后缀 j 或 J 表示虚数部分

‘柒’ 求助，用python编写一个模拟个人所得税计算器程序，数据看图

sal=float(input('请输入当月税前工资:'))
S=sal-3500
if 0<S<=1500:
L=S*0.03
print('应纳枝察租税%.2f元'%L)
elif 1500<S<=4500:
L=1500*0.03+(S-1500)*0.1
print('应纳税%.2f元'%L)
elif 4500<S<=9000:
L=1500*0.03+3000*0.1+(S-4500)*0.2
print('应纳税%.2f元'%L)
elif 9000<S<=35000:
L=1500*0.03+3000*0.1+4500*0.2+(S-9000)*0.25
print('应纳没尺税%.2f元'%L)
elif 35000<S<=55000:
L=1500*0.03+3000*0.1+4500*0.2+26000*0.25+(S-35000)*0.3
print('应纳税%.2f元'%L)
elif 55000<S<猛兆=80000:
L=1500*0.03+3000*0.1+4500*0.2+26000*0.25+20000*0.3+(S-55000)*0.35
print('应纳税%.2f元'%L)
elif S>80000:
L=1500*0.03+3000*0.1+4500*0.2+26000*0.25+20000*0.3+25000*0.35+(S-80000)*0.45
print('应纳税%.2f元'%L)
else:
print('未到起征点，不用交税')

‘捌’ 如何运用Python编写简易计算器

import time
print("计算器")
print("+等于加法模式 -等于减法模式 *等于乘法模式 /等于除法模式")
while 2 > 1:
try:
print("请输入+，-，*或/")
a = input()
if a == "+":
print("请输入第1个加数")
b = input()
print("请输入第2个加数")
c = input()
print("计算中")
time.sleep(0.3)
j = float(b) + float(c)
print("等于"+str(j))
elif a == "-":
print("请输入被减数")
b = input()
print("请输入减数")
c = input()
print("计算中")
time.sleep(0.3)
j = float(b) - float(c)
print("等于"+str(j))
elif a == "*":
print("请输入第1个因数")
b = input()
print("请输入第2个因数")
c = input()
print("计算中")
time.sleep(0.3)
j = float(b) * float(c)
print("等于"+str(j))
elif a == "/":
print("……等于余数模式 .等于小数模式")
print("请输入……或.")
a = input()
if a == ".":
print("请输入被除数")
b = input()
print("请输入除数")
c = input()
print("计算中")
time.sleep(0.3)
j = float(b) / float(c)
print("等于"+str(j))
if c == "0":
print("除数不能为0！")
elif a == "……":
print("请输入被除数")
b = input()
print("请输入除数")
c = input()
j = float(b) // float(c)
e = float(b) % float(c)
print("等于"+str(j)+"……"+str(e))
if c == "0":
print("除数不能为0！")
except Exception as e:
print("您输入的内容有错误")