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


Posted in Python onNovember 02, 2016

一、算法

     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语言)》上相关章节算法描述

Python 相关文章推荐
python每次处理固定个数的字符的方法总结
Jan 29 Python
Python socket编程实例详解
May 27 Python
Python中的super用法详解
May 28 Python
Django中模型Model添加JSON类型字段的方法
Jun 17 Python
八大排序算法的Python实现
Jan 28 Python
Python实现七彩蟒蛇绘制实例代码
Jan 16 Python
pygame游戏之旅 游戏中添加显示文字
Nov 20 Python
Python3.5运算符操作实例详解
Apr 25 Python
PYTHON如何读取和写入EXCEL里面的数据
Oct 28 Python
详解Django3中直接添加Websockets方式
Feb 12 Python
python中的unittest框架实例详解
Feb 05 Python
python glom模块的使用简介
Apr 13 Python
利用Python命令行传递实例化对象的方法
Nov 02 #Python
Python 性能优化技巧总结
Nov 01 #Python
python字典多键值及重复键值的使用方法(详解)
Oct 31 #Python
浅谈django中的认证与登录
Oct 31 #Python
python 把数据 json格式输出的实例代码
Oct 31 #Python
python中json格式数据输出的简单实现方法
Oct 31 #Python
python并发编程之多进程、多线程、异步和协程详解
Oct 28 #Python
You might like
php页面缓存ob系列函数介绍
2012/10/18 PHP
微信红包随机生成算法php版
2016/07/21 PHP
Laravel 创建指定表 migrate的例子
2019/10/09 PHP
jquery $.fn $.fx是什么意思有什么用
2013/11/04 Javascript
jquery动态改变onclick属性导致失效的问题解决方法
2013/12/04 Javascript
获取3个数组不重复的值的具体实现
2013/12/30 Javascript
JQuery教学之性能优化
2014/05/14 Javascript
JavaScript中的函数模式详解
2015/02/11 Javascript
使用javaScript动态加载Js文件和Css文件
2015/10/24 Javascript
微信小程序 教程之小程序配置
2016/10/17 Javascript
JavaScript中省略元素对数组长度的影响
2016/10/26 Javascript
EasyUI Datebox 日期验证之开始日期小于结束时间
2017/05/19 Javascript
创建简单的node服务器实例(分享)
2017/06/23 Javascript
jquery实现弹窗(系统提示框)效果
2019/12/10 jQuery
bootstrapValidator表单校验、更改状态、新增、移除校验字段的实例代码
2020/05/19 Javascript
浅谈vue在html中出现{{}}的原因及解决方式
2020/11/16 Javascript
Python中使用语句导入模块或包的机制研究
2015/03/30 Python
Python记录详细调用堆栈日志的方法
2015/05/05 Python
python实现应用程序在右键菜单中添加打开方式功能
2017/01/09 Python
PyQt5每天必学之工具提示功能
2018/04/19 Python
Python爬虫 urllib2的使用方法详解
2019/09/23 Python
nginx+uwsgi+django环境搭建的方法步骤
2019/11/25 Python
Python Numpy数组扩展repeat和tile使用实例解析
2019/12/09 Python
python3.7.3版本和django2.2.3版本是否可以兼容
2020/09/01 Python
H&M旗下高端女装品牌:& Other Stories
2018/05/07 全球购物
Spongelle官网:美国的创意护肤洗护品牌
2019/05/15 全球购物
运动鞋、足球鞋和慕尼黑球衣:Sport Münzinger
2019/08/26 全球购物
意大利消费电子产品购物网站:SLG Store
2019/12/26 全球购物
巴西葡萄酒商店:Divvino
2020/02/22 全球购物
什么是.net的Remoting技术
2016/07/08 面试题
编程用JAVA解析XML的方式
2013/07/07 面试题
学生实习介绍信
2014/01/15 职场文书
新学期班主任寄语
2014/01/18 职场文书
《泉水》教学反思
2014/04/11 职场文书
公益广告标语
2014/06/19 职场文书
《中国梦我的梦》小学生演讲稿
2014/08/20 职场文书