发布于 2016-12-08 03:28:20 | 217 次阅读 | 评论: 0 | 来源: 网友投递
Python编程语言
Python 是一种面向对象、解释型计算机程序设计语言，由Guido van Rossum于1989年底发明，第一个公开发行版发行于1991年。Python语法简洁而清晰，具有丰富和强大的类库。它常被昵称为胶水语言，它能够把用其他语言制作的各种模块（尤其是C/C++）很轻松地联结在一起。
一、算法
1、算法的主要思想就是将一个中缀表达式(Infix expression)转换成便于处理的后缀表达式(Postfix expression)，然后借助于栈这个简单的数据结构，计算出表达式的结果。
2、关于如何讲普通的表达式转换成后缀表达式，以及如何处理后缀表达式并计算出结果的具体算法描述不在此叙述了，书上有详细的说明。
二、简易计算器
使用说明
使用该计算器类的简单示例如下：
# usage
c = Calculator()
print('result: {:f}'.formart(c.get_result('1.11+2.22-3.33*4.44/5.55')))
# output:
result: 0.666000测试案例
为了对这个计算器进行有效地检验，设计了几组测试案例，测试结果如下：
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代码实现的简单的栈：
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计算器类的实现
在计算器类中，我们将表达式的合法性验证单独放在一个函数中完成，但是实际上如果需要，也可以直接放在中缀表达式转后缀表达式的函数中实现，这样只需要一次遍历表达式即可同时完成验证和转换工作。但是为了保持结构清晰，还是分开来实现比较好，每个函数尽可能最好一件事情才是比较实在的。
在该计算器类中，有很多种极端的情况没有被考虑进去，因为那样的话整个实现的代码会更多。不过，可以在后期为整个类继续扩展，添加新的功能也是可以的。目前实现的就是主要框架，包括基本的错误检测和运算，重点时学习运用栈这个看似简单却强大的数据结构解决问题。
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语言)》上相关章节算法描述