个人中心
gpt4 book ai didi

Python实现简单的四则运算计算器

转载 作者：qq735679552 更新时间：2022-09-27 22:32:09 25 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章Python实现简单的四则运算计算器由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

1、算法 。

     1、算法的主要思想就是将一个中缀表达式(Infix expression)转换成便于处理的后缀表达式(Postfix expression)，然后借助于栈这个简单的数据结构，计算出表达式的结果.

     2、关于如何讲普通的表达式转换成后缀表达式，以及如何处理后缀表达式并计算出结果的具体算法描述不在此叙述了，书上有详细的说明.

2、简易计算器 。

使用说明 。

使用该计算器类的简单示例如下:

?
1
2
3
4
5
# usage
c = Calculator()
print ( 'result: {:f}' .formart(c.get_result( '1.11+2.22-3.33*4.44/5.55' )))
# output:
result: 0.666000

测试案例 。

为了对这个计算器进行有效地检验，设计了几组测试案例，测试结果如下:

?
1
2
3
4
5
6
7
8
9
10
Test No. 1 : ( 1.11 ) = 1.110000
Test No. 2 : 1.11 + 2.22 - 3.33 * 4.44 / 5.55 = 0.666000
Test No. 3 : 1.11 + ( 2.22 - 3.33 ) * 4.44 / 5.55 = 0.222000
Test No. 4 : 1.11 + ( 2.22 - 3.33 ) * ( 4.44 + 5.55 ) / 6.66 = - 0.555000
Test No. 5 : 1.11 * (( 2.22 - 3.33 ) * ( 4.44 + 5.55 )) / ( 6.66 + 7.77 ) = - 0.852992
Test No. 6 : ( 1.11 + 2.22 ) * ( 3.33 + 4.44 ) / 5.55 * 6.66 = 31.048920
Test No. 7 : ( 1.11 - 2.22 ) / ( 3.33 + 4.44 ) / 5.55 * ( 6.66 + 7.77 ) / ( 8.88 ) = - 0.041828
Test No. 8 : Error: ( 1.11 + 2.22 ) * ( 3.33 + 4.44 : missing ")" , please check your expression
Test No. 9 : Error: ( 1.11 + 2.22 ) * 3.33 / 0 + ( 34 - 45 ): divisor cannot be zero
Test No. 10 : Error: 12 + 89 ^ 7 : invalid character: ^

实现代码 。

栈的实现 。

栈实际上就是一个被限制操作的表，所有的操作只能在栈的顶端（入栈、出栈等），以下是使用Python代码实现的简单的栈:

?
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
class Stack( object ):
   """
   The structure of a Stack.
   The user don't have to know the definition.
   """
   def __init__( self ):
     self .__container = list ()
   def __is_empty( self ):
     """
     Test if the stack is empty or not
     :return: True or False
     """
     return len ( self .__container) = = 0
   def push( self , element):
     """
     Add a new element to the stack
     :param element: the element you want to add
     :return: None
     """
     self .__container.append(element)
   def top( self ):
     """
     Get the top element of the stack
     :return: top element
     """
     if self .__is_empty():
       return None
     return self .__container[ - 1 ]
   def pop( self ):
     """
     Remove the top element of the stack
     :return: None or the top element of the stack
     """
     return None if self .__is_empty() else self .__container.pop()
   def clear( self ):
     """
     We'll make an empty stack
     :return: self
     """
     self .__container.clear()
     return self

计算器类的实现 。

在计算器类中，我们将表达式的合法性验证单独放在一个函数中完成，但是实际上如果需要，也可以直接放在中缀表达式转后缀表达式的函数中实现，这样只需要一次遍历表达式即可同时完成验证和转换工作。但是为了保持结构清晰，还是分开来实现比较好，每个函数尽可能最好一件事情才是比较实在的.

在该计算器类中，有很多种极端的情况没有被考虑进去，因为那样的话整个实现的代码会更多。不过，可以在后期为整个类继续扩展，添加新的功能也是可以的。目前实现的就是主要框架，包括基本的错误检测和运算，重点时学习运用栈这个看似简单却强大的数据结构解决问题.

?
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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
class Calculator( object ):
   """
   A simple calculator, just for fun
   """
   def __init__( self ):
     self .__exp = ''
   def __validate( self ):
     """
     We have to make sure the expression is legal.
     1. We only accept the `()` to specify the priority of a sub-expression. Notes: `[ {` and `] }` will be
     replaced by `(` and `)` respectively.
     2. Valid characters should be `+`, `-`, `*`, `/`, `(`, `)` and numbers(int, float)
     - Invalid expression examples, but we can only handle the 4th case. The implementation will
     be much more sophisticated if we want to handle all the possible cases.:
       1. `a+b-+c`
       2. `a+b+-`
       3. `a+(b+c`
       4. `a+(+b-)`
       5. etc
     :return: True or False
     """
     if not isinstance ( self .__exp, str ):
       print ( 'Error: {}: expression should be a string' . format ( self .__exp))
       return False
     # Save the non-space expression
     val_exp = ''
     s = Stack()
     for x in self .__exp:
       # We should ignore the space characters
       if x = = ' ' :
         continue
       if self .__is_bracket(x) or self .__is_digit(x) or self .__is_operators(x) \
           or x = = '.' :
         if x = = '(' :
           s.push(x)
         elif x = = ')' :
           s.pop()
         val_exp + = x
       else :
         print ( 'Error: {}: invalid character: {}' . format ( self .__exp, x))
         return False
     if s.top():
       print ( 'Error: {}: missing ")", please check your expression' . format ( self .__exp))
       return False
     self .__exp = val_exp
     return True
   def __convert2postfix_exp( self ):
     """
     Convert the infix expression to a postfix expression
     :return: the converted expression
     """
     # highest priority: ()
     # middle: * /
     # lowest: + -
     converted_exp = ''
     stk = Stack()
     for x in self .__exp:
       if self .__is_digit(x) or x = = '.' :
         converted_exp + = x
       elif self .__is_operators(x):
         converted_exp + = ' '
         tp = stk.top()
         if tp:
           if tp = = '(' :
             stk.push(x)
             continue
           x_pri = self .__get_priority(x)
           tp_pri = self .__get_priority(tp)
           if x_pri > tp_pri:
             stk.push(x)
           elif x_pri = = tp_pri:
             converted_exp + = stk.pop() + ' '
             stk.push(x)
           else :
             while stk.top():
               if self .__get_priority(stk.top()) ! = x_pri:
                 converted_exp + = stk.pop() + ' '
               else :
                 break
             stk.push(x)
         else :
           stk.push(x)
       elif self .__is_bracket(x):
         converted_exp + = ' '
         if x = = '(' :
           stk.push(x)
         else :
           while stk.top() and stk.top() ! = '(' :
             converted_exp + = stk.pop() + ' '
           stk.pop()
     # pop all the operators
     while stk.top():
       converted_exp + = ' ' + stk.pop() + ' '
     return converted_exp
   def __get_result( self , operand_2, operand_1, operator):
     if operator = = '+' :
       return operand_1 + operand_2
     elif operator = = '-' :
       return operand_1 - operand_2
     elif operator = = '*' :
       return operand_1 * operand_2
     elif operator = = '/' :
       if operand_2 ! = 0 :
         return operand_1 / operand_2
       else :
         print ( 'Error: {}: divisor cannot be zero' . format ( self .__exp))
         return None
   def __calc_postfix_exp( self , exp):
     """
     Get the result from a converted postfix expression
     e.g. 6 5 2 3 + 8 * + 3 + *
     :return: result
     """
     assert isinstance (exp, str )
     stk = Stack()
     exp_split = exp.strip().split()
     for x in exp_split:
       if self .__is_operators(x):
         # pop two top numbers in the stack
         r = self .__get_result(stk.pop(), stk.pop(), x)
         if r is None :
           return None
         else :
           stk.push(r)
       else :
         # push the converted number to the stack
         stk.push( float (x))
     return stk.pop()
   def __calc( self ):
     """
     Try to get the result of the expression
     :return: None or result
     """
     # Validate
     if self .__validate():
       # Convert, then run the algorithm to get the result
       return self .__calc_postfix_exp( self .__convert2postfix_exp())
     else :
       return None
   def get_result( self , expression):
     """
     Get the result of an expression
     Suppose we have got a valid expression
     :return: None or result
     """
     self .__exp = expression.strip()
     return self .__calc()
   """
   Utilities
   """
   @staticmethod
   def __is_operators(x):
     return x in [ '+' , '-' , '*' , '/' ]
   @staticmethod
   def __is_bracket(x):
     return x in [ '(' , ')' ]
   @staticmethod
   def __is_digit(x):
     return x.isdigit()
   @staticmethod
   def __get_priority(op):
     if op in [ '+' , '-' ]:
       return 0
     elif op in [ '*' , '/' ]:
       return 1

总结 。

以上就是利用Python实现简单四则运算计算器的全部内容，希望本文的内容对大家的学习或者工作能有所帮助，如果有疑问大家可以留言交流.

参考 。

《数据结构与算法(C语言)》上相关章节算法描述 。

原文链接：http://blog.chriscabin.com/coding-life/python/python-in-real-world/1101.html 。

最后此篇关于Python实现简单的四则运算计算器的文章就讲到这里了,如果你想了解更多关于Python实现简单的四则运算计算器的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

25 4 0
文章推荐： 用Python将动态GIF图片倒放播放的方法
文章推荐： 各种Python库安装包下载地址与安装过程详细介绍(Windows版)
文章推荐： 利用Python命令行传递实例化对象的方法
文章推荐： Python 性能优化技巧总结
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com