python高數計算器開發

A. 如何用python編程製作計算器

def cal():
numA = float(raw_input('Please enter a number: '))
op = raw_input('Please enter a operator: ')
numB = float(raw_input('Please enter another number: '))
if op == '+':
print "result: ",numA+numB
elif op == '-':
print "result: ",numA-numB
elif op == '*':
print "result: ",numA*numB
elif op == '/':
print "result: ",numA/numB
else:
print "Unknown operator ",op
cal()

B. 如果只會Python能不能找到工作

具體能不能得看自己學得如何，如果學的很好的話，很容易找到工作。

學python的同時一定會接觸到其他技術，畢竟光會python這門語言是不夠的，要看用它來做什麼。比如說用 python做爬蟲，就必須接觸到html, http等知識。

python是現在最火的數據分析工具語言python的進階的路線是數據清洗，爬蟲，數據容器，之後是卷積，線性分析，和機器學習，區塊連，金融方面的量化等高端進階。

python是現在需求做多的數據程序工程師的語言。移動互聯網的前端紅利時代已經過去了。現在需要的是跨界的數據工程師，語言會python就可以了，但是高等數學要學好，對其他行業要有認知，英語要好，能看懂國外社區的內容。

(2)python高數計算器開發擴展閱讀：

Python的設計哲學是「優雅」、「明確」、「簡單」。因此，Perl語言中「總是有多種方法來做同一件事」的理念在Python開發者中通常是難以忍受的。Python開發者的哲學是「用一種方法，最好是只有一種方法來做一件事」。

在設計Python語言時，如果面臨多種選擇，Python開發者一般會拒絕花俏的語法，而選擇明確的沒有或者很少有歧義的語法。

由於這種設計觀念的差異，Python源代碼通常被認為比Perl具備更好的可讀性，並且能夠支撐大規模的軟體開發。這些准則被稱為Python格言。在Python解釋器內運行import this可以獲得完整的列表。

C. 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()

D. 如何用python編寫計算器

我想你的需求應該是一個圖形界面的程序，而不是簡單的在命令行上輸入。
那麼，要做的第一件事就是選擇一個圖形界面套件。可以使用原生的TK，也可以用跨平台性能很好的wxPython,或者是整體結構很像MFC的PyWin32。至於pyGTK，pyQT，都是可選的，但是相對來說文檔比較少，學習不便。
選定圖形庫之後，就可以看文檔範例了。計算器總體是比較簡單的。我記得WxPython的demo里直接就有一個簡單計算器，您可以直接取來用。

E. 如何使用python編程寫一個加法計算器

1、打開idle。點擊file，然後點擊new file.這是創建一個新的文件。
新建一個文件之後，我們輸入第一行代碼，使用print函數，在屏幕上列印一句話，其中字元串要使用雙引號，輸入法要使用英文輸入法，如果符號使用中文輸入法輸入，就會出現錯誤。print("我們做一個兩個整數相加的計算題！")
同理，在屏幕上列印第二句話，與用戶交互，提醒用戶輸入第一個數。
第三行調用input函數，將用戶輸入的內容賦值給a,這時候a收到的是字元串信息，所以需要下一步把字元串轉換為整型。這輸入計算機處理數據指令。
然後依照以上的步驟寫第二個加數，和最後輸出的和，注意最後一句列印結果時，引號內部是字元串形式，x+y是數值形式，所以需要在中間加上一個逗號。如果不加逗號就會提示錯誤信息，以上就是所有的程序編寫完成，下一步就開始保存，命名，運行。如圖所示
運行結果如下：
更多Python相關技術文章，請訪問Python教程欄目進行學習！以上就是小編分享的關於如何使用python編程寫一個加法計算器的詳細內容希望對大家有所幫助，更多有關python教程請關注環球青藤其它相關文章！

F. 如何用python編寫的計算器

python內置計算器 ， 直接在控制台或CMD窗口輸式子回車就會給出答案

G. 求用Python寫一個簡單的計算器!

def cal():
    numA = float(raw_input('Please enter a number: '))
    op = raw_input('Please enter a operator: ')
    numB = float(raw_input('Please enter another number: '))
    if op == '+':
        print "result: ",numA+numB
    elif op == '-':
        print "result: ",numA-numB
    elif op == '*':
        print "result: ",numA*numB
    elif op == '/':
        print "result: ",numA/numB
    else:
        print "Unknown operator ",op
cal()

H. python編寫計算器

其實有個函數叫eval()的，至於怎麼用，看你的了。

I. 如何使用 50 行 Python 代碼製作一個計算器

簡介
在這篇文章中，我將向大家演示怎樣向一個通用計算器一樣解析並計算一個四則運算表達式。當我們結束的時候，我們將得到一個可以處理諸如 1+2*-(-3+2)/5.6+3樣式的表達式的計算器了。當然，你也可以將它拓展的更為強大。
我本意是想提供一個簡單有趣的課程來講解 語法分析 和 正規語法（編譯原理內容）。同時，介紹一下 PlyPlus,這是一個我斷斷續續改進了好幾年的語法解析 介面。作為這個課程的附加產物，我們最後會得到完全可替代eval（）的一個安全的四則運算器。
如果你想在自家的電腦上試試本文中給的例子的話，你應該先安裝 PlyPlus ,使用命令pip install plyplus 。（譯者註：pip是一個包管理系統，用來安裝用python寫的軟體包，具體使用方法大家可以網路之或是google之，就不贅述了。）
本篇文章需要對python的繼承使用有所了解。

穎鷹
翻譯於 2年前
2人頂
頂 翻譯的不錯哦!

其它翻譯版本(1)

語法
對於那些不懂的如何解析和正式語法工作的人而言，這里有一個快速的概覽：正式語法是用來解析文本的一些不同層面的規則。每一個規則都描述了相對應的那部分輸入的文本是如何組成的。
這里是一個用來展示如何解析1+2+3+4的例子：
?

1
2

Rule #1 - add IS MADE OF add + number
OR number + number

或者用 EBNF:
?

1
2
3

add: add'+'number
| number'+'number
;

解析器每次都會尋找add+number或者number+number，找到一個之後就會將其轉換成add。基本上而言，每一個解析器的目標都在於盡可能的找到最高層次的表達式抽象。
以下是解析器的每個步驟：
number + number + number + number
第一次轉換將所有的Number變成「number」規則
[number + number] + number + number
解析器找到了它的第一個匹配模式！
[add + number] + number
在轉換成一個模式之後，它開始尋找下一個
[add + number]
add

ShaoFantasy
翻譯於 2年前
0人頂
頂 翻譯的不錯哦!

這些有次序的符號變成了一個層次上的兩個簡單規則: number+number和add+number。這樣，只需要告訴計算機如果解決這兩個問題，它就能解析整個表達式。事實上，無論多長的加法序列，它都能解決! 這就是形式文法的力量。
運算符優先順序
算數表達式並不僅僅是符號的線性增長，運算符創造了一個隱式的層次結構，這非常適合用形式文法來表示:
1 + 2 * 3 / 4 - 5 + 6
這相當於:
1 + (2 * 3 / 4) - 5 + 6
我們可以通過嵌套規則表示此語法中的結構:

?

1
2
3
4
5
6

add: add+mul
| mul'+'mul
;
mul: mul '*; number
| number'*'number
;

通過將add設為操作mul而不是number，我們就得到了乘法優先的規則。

禿頭代表奔放
翻譯於 2年前
0人頂
頂 翻譯的不錯哦!

讓我們在腦海中模擬一下使用這個神奇的解析器來分析1+2*3*4的過程：
number + number * number * number
number + [number * number] * number
解析器不知道number+number的結果，所以這是它（解析器）的另一個選擇
number + [mul * number]
number + mul
???
現在我們遇到了一點困難! 解析器不知道如何處理number+mul。我們可以區分這種情況，但是如果我們繼續探索下去，就會發現有很多不同的沒有考慮到得可能，比如mul+number, add+number, add+add, 等等。
那麼我們應該怎麼做呢？
幸運的是，我們可以做一點小「把戲」：我們可以認為一個number本身是一個乘積，並且一個乘積本身是一個和！
這種思路一開始看起來有點古怪，不過它的確是有意義的：
?

1
2
3
4
5
6
7
8

add: add'+'mul
| mul'+'mul
| mul
;
mul: mul'*'number
| number'*'number
| number
;

但是如果 mul能夠變成 add, 且 number能夠變成 mul ， 有些行的內容就變得多餘了。丟棄它們，我們就得到了：

?

1
2
3
4
5
6

add: add'+'mul
| mul
;
mul: mul'*'number
| number
;

讓我們來使用這種新的語法來模擬運行一下1+2*3*4：
number + number * number * number
現在沒有一個規則是對應number*number的了，但是解析器可以「變得有創造性」
number + [number] * number * number
number + [mul * number] * number
number + [mul * number]
[number] + mul
[mul] + mul
[add + mul]
add
成功了！！！
如果你覺得這個很奇妙，那麼嘗試著去用另一種算數表達式來模擬運行一下，然後看看錶達式是如何用正確的方式來一步步解決問題的。或者等著閱讀下一節中的內容，看看計算機是如何一步步運行出來的！

ShaoFantasy
翻譯於 2年前
0人頂
頂 翻譯的不錯哦!

運行解析器

現在我們對於如何讓我們的語法運作起來已經有了非常不錯的想法了，那就寫一個實際的語法來應用一下吧:
?

1
2
3
4
5
6

start: add; // 這是最高層
add: add add_symbol mul | mul;
mul: mul mul_symbol number | number;
number:'[d.]+'; // 十進制數的正則表達式
mul_symbol:'*'|'/';// Match * or /
add_symbol:'+'|'-';// Match + or -

你可能想要復習一下正則表達式，但不管怎樣，這個語法都非常直截了當。讓我們用一個表達式來測試一下吧:
?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

>>>fromplyplusimportGrammar
>>> g=Grammar("""...""")
>>>printg.parse('1+2*3-5').pretty()
start
add
add
add
mul
number
1
add_symbol
+
mul
mul
number
2
mul_symbol
*
number
3
add_symbol
-
mul
number
5

幹得漂亮!
仔細研究一下這棵樹，看看解析器選擇了什麼層次。
如果你希望親自運行這個解析器，並使用你自己的表達式，你只需有Python即可。安裝Pip和PlyPlus之後，將上面的命令粘貼到Python內(記得將'...'替換為實際的語法哦~)。

禿頭代表奔放
翻譯於 2年前
0人頂
頂 翻譯的不錯哦!

使樹成形
Plyplus會自動創建一棵樹，但它並不一定是最優的。將number放入到mul和將mul放入到add非常有利於創建一個階層，現在我們已經有了一個階層那它們反而會成為一個負擔。我們告訴Plyplus對它們加前綴去「展開」（i.e.刪除）規則。
碰到一個@常常會展開一個規則，一個#則會壓平它，一個?會在它有一個子結點時展開。在這種情況下，?就是我們所需要的。
?

1
2
3
4
5
6

start: add;
?add: add add_symbol mul | mul; // Expand add if it's just a mul
?mul: mul mul_symbol number | number;// Expand mul if it's just a number
number:'[d.]+';
mul_symbol:'*'|'/';
add_symbol:'+'|'-';

在新語法下樹是這樣的：
?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

>>> g=Grammar("""...""")
>>>printg.parse('1+2*3-5').pretty()
start
add
add
number
1
add_symbol
+
mul
number
2
mul_symbol
*
number
3
add_symbol
-
number
5

哦，這樣變得簡潔多了，我敢說，它是非常好的。

showme
翻譯於 2年前
0人頂
頂 翻譯的不錯哦!

括弧的處理及其它特性
目前為止，我們還明顯缺少一些必須的特性：括弧，單元運算符(-(1+2))，及表達式中間允許存在空字元。其實這些特性都很容易就能實現，下面我們來嘗試一下。
需要先引入一個重要的概念：原子。在一個原子裡面（括弧中及單元運算）發生的所有操作都優先於所有加法或乘法運算（包括位操作）。由於原子只是一個優先順序的構造器，並無語法意義，幫我們加上"@"符號以確保在編譯時它被能展開。
允許空格出現在表達式內最簡單的方法就是使用這種解釋方式：add SPACE add_symbol SPACE mul | mul; 但個解釋結果啰嗦且可讀性差。所有，我們需要令Plyplus總是忽略空格。
下面是完整的語法，包容了以上所述特性：
?

1
2
3
4
5
6
7
8
9

start: add;
?add: (add add_symbol)? mul;
?mul: (mul mul_symbol)? atom;
@atom: neg | number |'('add')';
neg:'-'atom;
number:'[d.]+';
mul_symbol:'*'|'/';
add_symbol:'+'|'-';
WHITESPACE:'[ t]+'(%ignore);

請確保理解這個語法再進入下一步：計算！

霹靂小金剛
翻譯於 2年前
0人頂
頂 翻譯的不錯哦!

運算
現在，我們已經可以將一個表達式轉化成一棵分層樹了，只需要逐分支地掃描這棵樹，便可得到最終結果。
我們現在要開始編寫代碼了，在此之前，我需要對這棵樹做兩點解釋：
1.每個分支都是包含如下兩個屬性的實例：
頭(head)：規則的名字(例如add或者number);
尾(tail)：包含所有與其匹配的子規則的列表。
2.Plyplus默認會刪除不必要的標記。在本例中，'( ' ，')' 和 '-' 會被刪除。但add和mul會有自己的規則，Plyplus會知道它們是必須的，從而不會被刪除它們。如果你需要保留這些標記，可以手動關掉這項功能，但從我的經驗來看，最好不要這樣做，而是手動修改相關語法效果更佳。

禿頭代表奔放
翻譯於 2年前
0人頂
頂 翻譯的不錯哦!

言歸正傳，現在我們開始編寫代碼。我們將用一個非常簡單的轉換器來掃描這棵樹。它會從最外面的分支開始掃描，直到到達根節點為止，而我們的工作是告訴它如何掃描。如果一切順利的話，它將總會從最外層開始掃描!讓我們看看具體的實現吧。
?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

>>>importoperator as op
>>>fromplyplusimportSTransformer

classCalc(STransformer):

def_bin_operator(self, exp):
arg1, operator_symbol, arg2=exp.tail

operator_func={'+': op.add,
'-': op.sub,
'*': op.mul,
'/': op.div }[operator_symbol]

returnoperator_func(arg1, arg2)

number =lambdaself, exp:float(exp.tail[0])
neg =lambdaself, exp:-exp.tail[0]
__default__=lambdaself, exp: exp.tail[0]

add=_bin_operator
mul=_bin_operator

每個方法都對應一個規則。如果方法不存在的話，將調用__default__方法。我們在其中省略了start,add_symbol和mul_symbol，因為它們只會返回自己的分支。
我使用了float()來解析數字，這是個懶方法，但我也可以用解析器來實現。
為了使語句整潔，我使用了運算符模塊。例如add基本上是 'lambda x,y: x+y'之類的。
OK，現在我們運行這段代碼來檢查一下結果。
?

1
2

>>> Calc().transform( g.parse('1 + 2 * -(-3+2) / 5.6 + 30'))
31.357142857142858

那麼eval()呢？7
?

1
2

>>>eval('1 + 2 * -(-3+2) / 5.6 + 30')
31.357142857142858

成功了:)

禿頭代表奔放
翻譯於 2年前
0人頂
頂 翻譯的不錯哦!

最後一步：REPL
為了美觀，我們把它封裝到一個不錯的計算器 REPL：
?

1
2
3
4
5
6
7
8
9
10
11

defmain():
calc=Calc()
whileTrue:
try:
s=raw_input('> ')
exceptEOFError:
break
ifs=='':
break
tree=calc_grammar.parse(s)
printcalc.transform(tree)

本答案來自於互聯網，僅供參考學習作用
如果您對我的回答有不滿意的地方，還請您繼續追問；
答題不易，互相理解，互相幫助！

J. 如何運用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("您輸入的內容有錯誤")