50行Python代码制作一个计算器

简介

创新互联公司是一家集网站建设,正安企业网站建设,正安品牌网站建设,网站定制,正安网站建设报价,网络营销,网络优化,正安网站推广为一体的创新建站企业，帮助传统企业提升企业形象加强企业竞争力。可充分满足这一群体相比中小企业更为丰富、高端、多元的互联网需求。同时我们时刻保持专业、时尚、前沿，时刻以成就客户成长自我，坚持不断学习、思考、沉淀、净化自己，让我们为更多的企业打造出实用型网站。

在这篇文章中，我将向大家演示怎样向一个通用计算器一样解析并计算一个四则运算表达式。当我们结束的时候，我们将得到一个可以处理诸如 1+2*-(-3+2)/5.6+3样式的表达式的计算器了。当然，你也可以将它拓展的更为强大。

我本意是想提供一个简单有趣的课程来讲解 语法分析 和 正规语法（编译原理内容）。同时，介绍一下 PlyPlus,这是一个我断断续续改进了好几年的语法解析 接口。作为这个课程的附加产物，我们最后会得到完全可替代eval（）的一个安全的四则运算器。

如果你想在自家的电脑上试试本文中给的例子的话，你应该先安装 PlyPlus ,使用命令pip install plyplus  。（译者注：pip是一个包管理系统，用来安装用python写的软件包，具体使用方法大家可以百度之或是google之，就不赘述了。）

本篇文章需要对python的继承使用有所了解。

语法

对于那些不懂的如何解析和正式语法工作的人而言，这里有一个快速的概览：正式语法是用来解析文本的一些不同层面的规则。每一个规则都描述了相对应的那部分输入的文本是如何组成的。

这里是一个用来展示如何解析1+2+3+4的例子：

 
 
 
    
  
  
  
  1. Rule #1 - add  IS MADE OF  add + number   
    2. 
  
  
  
  2.                        OR  number + number 
    3.

或者用 EBNF:

 
 
 
    
  
  
  
  1. add: add'+'number  
    2. 
  
  
  
  2.    | number'+'number  
    3. 
  
  
  
  3.    ; 
    4.

解析器每次都会寻找add+number或者number+number，找到一个之后就会将其转换成add。基本上而言，每一个解析器的目标都在于尽可能的找到最高层次的表达式抽象。

以下是解析器的每个步骤：

1.number + number + number + number第一次转换将所有的Number变成“number”规则

2.[number + number] + number + number解析器找到了它的第一个匹配模式！

3.[add + number] + number在转换成一个模式之后，它开始寻找下一个

4.[add + number]

5.add

这些有次序的符号变成了一个层次上的两个简单规则: number+number和add+number。这样，只需要告诉计算机如果解决这两个问题，它就能解析整个表达式。事实上，无论多长的加法序列，它都能解决! 这就是形式文法的力量。

运算符优先级

算数表达式并不仅仅是符号的线性增长，运算符创造了一个隐式的层次结构，这非常适合用形式文法来表示:

1 + 2 * 3 / 4 - 5 + 6

这相当于:

1 + (2 * 3 / 4) - 5 + 6

我们可以通过嵌套规则表示此语法中的结构:

 
 
 
    
  
  
  
  1. add: add+mul  
    2. 
  
  
  
  2.    | mul'+'mul  
    3. 
  
  
  
  3.    ;  
    4. 
  
  
  
  4. mul: mul '*; number  
    5. 
  
  
  
  5.    | number'*'number  
    6. 
  
  
  
  6.    ; 
    7.

通过将add设为操作mul而不是number，我们就得到了乘法优先的规则。 让我们在脑海中模拟一下使用这个神奇的解析器来分析1+2*3*4的过程：

1.number + number * number * number

2.number + [number * number] * number解析器不知道number+number的结果，所以这是它（解析器）的另一个选择

3.number + [mul * number]

4.number + mul

5.???

现在我们遇到了一点困难! 解析器不知道如何处理number+mul。我们可以区分这种情况，但是如果我们继续探索下去，就会发现有很多不同的没有考虑到得可能，比如mul+number, add+number, add+add, 等等。

那么我们应该怎么做呢？

幸运的是，我们可以做一点小“把戏”：我们可以认为一个number本身是一个乘积，并且一个乘积本身是一个和！

这种思路一开始看起来有点古怪，不过它的确是有意义的：

 
 
 
    
  
  
  
  1. add: add'+'mul  
    2. 
  
  
  
  2.    | mul'+'mul  
    3. 
  
  
  
  3.    | mul  
    4. 
  
  
  
  4.    ;  
    5. 
  
  
  
  5. mul: mul'*'number  
    6. 
  
  
  
  6.    | number'*'number  
    7. 
  
  
  
  7.    | number  
    8. 
  
  
  
  8.    ; 
    9.

但是如果 mul能够变成 add, 且 number能够变成 mul ， 有些行的内容就变得多余了。丢弃它们，我们就得到了：

 
 
 
    
  
  
  
  1. add: add'+'mul  
    2. 
  
  
  
  2.    | mul  
    3. 
  
  
  
  3.    ;  
    4. 
  
  
  
  4. mul: mul'*'number  
    5. 
  
  
  
  5.    | number  
    6. 
  
  
  
  6.    ; 
    7.

让我们来使用这种新的语法来模拟运行一下1+2*3*4：

1.number + number * number * number现在没有一个规则是对应number*number的了，但是解析器可以“变得有创造性”

2.number + [number] * number * number

3.number + [mul * number] * number

4.number + [mul * number]

5.[number] + mul

6.[mul] + mul

7.[add + mul]

8.add

成功了！！！

如果你觉得这个很奇妙，那么尝试着去用另一种算数表达式来模拟运行一下，然后看看表达式是如何用正确的方式来一步步解决问题的。或者等着阅读下一节中的内容，看看计算机是如何一步步运行出来的！

运行解析器

现在我们对于如何让我们的语法运作起来已经有了非常不错的想法了，那就写一个实际的语法来应用一下吧:

 
 
 
    
  
  
  
  1. start: add;            // 这是最高层  
    2. 
  
  
  
  2. add: add add_symbol mul | mul;  
    3. 
  
  
  
  3. mul: mul mul_symbol number | number;  
    4. 
  
  
  
  4. number:'[d.]+';      // 十进制数的正则表达式  
    5. 
  
  
  
  5. mul_symbol:'*'|'/';// Match * or /  
    6. 
  
  
  
  6. add_symbol:'+'|'-';// Match + or - 
    7.

你可能想要复习一下正则表达式，但不管怎样，这个语法都非常直截了当。让我们用一个表达式来测试一下吧:

 
 
 
    
  
  
  
  1. >>>fromplyplusimportGrammar  
    2. 
  
  
  
  2. >>> g=Grammar("""...""")  
    3. 
  
  
  
  3. >>>printg.parse('1+2*3-5').pretty()  
    4. 
  
  
  
  4. start  
    5. 
  
  
  
  5.   add  
    6. 
  
  
  
  6.     add  
    7. 
  
  
  
  7.       add  
    8. 
  
  
  
  8.         mul  
    9. 
  
  
  
  9.           number  
    10. 
  
  
  
  10.             1 
    11. 
  
  
  
  11.       add_symbol  
    12. 
  
  
  
  12.         +  
    13. 
  
  
  
  13.       mul  
    14. 
  
  
  
  14.         mul  
    15. 
  
  
  
  15.           number  
    16. 
  
  
  
  16.             2 
    17. 
  
  
  
  17.         mul_symbol  
    18. 
  
  
  
  18.           *  
    19. 
  
  
  
  19.         number  
    20. 
  
  
  
  20.           3 
    21. 
  
  
  
  21.     add_symbol  
    22. 
  
  
  
  22.       -  
    23. 
  
  
  
  23.     mul  
    24. 
  
  
  
  24.       number  
    25. 
  
  
  
  25.         5 
    26.

干得漂亮!

仔细研究一下这棵树，看看解析器选择了什么层次。

如果你希望亲自运行这个解析器，并使用你自己的表达式，你只需有Python即可。安装Pip和PlyPlus之后，将上面的命令粘贴到Python内(记得将'...'替换为实际的语法哦~)。

使树成形

Plyplus会自动创建一棵树，但它并不一定是最优的。将number放入到mul和将mul放入到add非常有利于创建一个阶层，现在我们已经有了一个阶层那它们反而会成为一个负担。我们告诉Plyplus对它们加前缀去“展开”（i.e.删除）规则。

碰到一个@常常会展开一个规则，一个#则会压平它，一个?会在它有一个子结点时展开。在这种情况下，?就是我们所需要的。

 
 
 
    
  
  
  
  1. start: add;  
    2. 
  
  
  
  2. ?add: add add_symbol mul | mul;      // Expand add if it's just a mul  
    3. 
  
  
  
  3. ?mul: mul mul_symbol number | number;// Expand mul if it's just a number  
    4. 
  
  
  
  4. number:'[d.]+';  
    5. 
  
  
  
  5. mul_symbol:'*'|'/';  
    6. 
  
  
  
  6. add_symbol:'+'|'-'; 
    7.

在新语法下树是这样的：

 
 
 
    
  
  
  
  1. >>> g=Grammar("""...""")  
    2. 
  
  
  
  2. >>>printg.parse('1+2*3-5').pretty()  
    3. 
  
  
  
  3. start  
    4. 
  
  
  
  4.   add  
    5. 
  
  
  
  5.     add  
    6. 
  
  
  
  6.       number  
    7. 
  
  
  
  7.         1 
    8. 
  
  
  
  8.       add_symbol  
    9. 
  
  
  
  9.         +  
    10. 
  
  
  
  10.       mul  
    11. 
  
  
  
  11.         number  
    12. 
  
  
  
  12.           2 
    13. 
  
  
  
  13.         mul_symbol  
    14. 
  
  
  
  14.           *  
    15. 
  
  
  
  15.         number  
    16. 
  
  
  
  16.           3 
    17. 
  
  
  
  17.     add_symbol  
    18. 
  
  
  
  18.       -  
    19. 
  
  
  
  19.     number  
    20. 
  
  
  
  20.       5 
    21.

哦，这样变得简洁多了，我敢说，它是非常好的。

括号的处理及其它特性

目前为止，我们还明显缺少一些必须的特性：括号，单元运算符(-(1+2))，及表达式中间允许存在空字符。其实这些特性都很容易就能实现，下面我们来尝试一下。

需要先引入一个重要的概念：原子。在一个原子里面（括号中及单元运算）发生的所有操作都优先于所有加法或乘法运算（包括位操作）。由于原子只是一个优先级的构造器，并无语法意义，帮我们加上"@"符号以确保在编译时它被能展开。 

允许空格出现在表达式内最简单的方法就是使用这种解释方式：add SPACE add_symbol SPACE mul | mul;  但个解释结果啰嗦且可读性差。所有，我们需要令Plyplus总是忽略空格。

下面是完整的语法，包容了以上所述特性：

 
 
 
    
  
  
  
  1. start: add;  
    2. 
  
  
  
  2. ?add: (add add_symbol)? mul;  
    3. 
  
  
  
  3. ?mul: (mul mul_symbol)? atom;  
    4. 
  
  
  
  4. @atom: neg | number |'('add')';  
    5. 
  
  
  
  5. neg:'-'atom;  
    6. 
  
  
  
  6. number:'[d.]+';  
    7. 
  
  
  
  7. mul_symbol:'*'|'/';  
    8. 
  
  
  
  8. add_symbol:'+'|'-';  
    9. 
  
  
  
  9. WHITESPACE:'[ t]+'(%ignore); 
    10.

请确保理解这个语法再进入下一步：计算！

运算

现在，我们已经可以将一个表达式转化成一棵分层树了，只需要逐分支地扫描这棵树，便可得到最终结果。

我们现在要开始编写代码了，在此之前，我需要对这棵树做两点解释：

1.每个分支都是包含如下两个属性的实例：

头(head)：规则的名字(例如add或者number);

尾(tail)：包含所有与其匹配的子规则的列表。

2.Plyplus默认会删除不必要的标记。在本例中，'( ' ，')' 和 '-' 会被删除。但add和mul会有自己的规则，Plyplus会知道它们是必须的，从而不会被删除它们。如果你需要保留这些标记，可以手动关掉这项功能，但从我的经验来看，最好不要这样做，而是手动修改相关语法效果更佳。

言归正传，现在我们开始编写代码。我们将用一个非常简单的转换器来扫描这棵树。它会从最外面的分支开始扫描，直到到达根节点为止，而我们的工作是告诉它如何扫描。如果一切顺利的话，它将总会从最外层开始扫描!让我们看看具体的实现吧。

 
 
 
    
  
  
  
  1. >>>importoperator as op  
    2. 
  
  
  
  2. >>>fromplyplusimportSTransformer  
    3. 
  
  
  
  3. classCalc(STransformer):  
    4. 
  
  
  
  4.    
    5. 
  
  
  
  5.     def_bin_operator(self, exp):  
    6. 
  
  
  
  6.         arg1, operator_symbol, arg2=exp.tail  
    7. 
  
  
  
  7.    
    8. 
  
  
  
  8.         operator_func={'+': op.add,  
    9. 
  
  
  
  9.                           '-': op.sub,  
    10. 
  
  
  
  10.                           '*': op.mul,  
    11. 
  
  
  
  11.                           '/': op.div }[operator_symbol]  
    12. 
  
  
  
  12.    
    13. 
  
  
  
  13.         returnoperator_func(arg1, arg2)  
    14. 
  
  
  
  14.    
    15. 
  
  
  
  15.     number     =lambdaself, exp:float(exp.tail[0])  
    16. 
  
  
  
  16.     neg        =lambdaself, exp:-exp.tail[0]  
    17. 
  
  
  
  17.     __default__=lambdaself, exp: exp.tail[0]  
    18. 
  
  
  
  18.    
    19. 
  
  
  
  19.     add=_bin_operator  
    20. 
  
  
  
  20.     mul=_bin_operator 
    21.

每个方法都对应一个规则。如果方法不存在的话，将调用__default__方法。我们在其中省略了start,add_symbol和mul_symbol，因为它们只会返回自己的分支。

我使用了float()来解析数字，这是个懒方法，但我也可以用解析器来实现。

为了使语句整洁，我使用了运算符模块。例如add基本上是 'lambda x,y: x+y'之类的。

OK，现在我们运行这段代码来检查一下结果。

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

那么eval()呢？7

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

成功了:)

最后一步：REPL

为了美观，我们把它封装到一个不错的计算器 REPL：

 
 
 
    
  
  
  
  1. defmain():  
    2. 
  
  
  
  2.     calc=Calc()  
    3. 
  
  
  
  3.     whileTrue:  
    4. 
  
  
  
  4.         try:  
    5. 
  
  
  
  5.             s=raw_input('> ')  
    6. 
  
  
  
  6.         exceptEOFError:  
    7. 
  
  
  
  7.             break 
    8. 
  
  
  
  8.         ifs=='':  
    9. 
  
  
  
  9.             break 
    10. 
  
  
  
  10.         tree=calc_grammar.parse(s)  
    11. 
  
  
  
  11.         printcalc.transform(tree) 
    12.

完整的代码可从这里获取：https://github.com/erezsh/plyplus/blob/master/examples/calc.py

新闻名称：50行Python代码制作一个计算器
文章路径：http://www.gawzjz.com/qtweb/news23/180173.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

Google知识

同城分类信息

成都网站优化　　 　专业网站设计　　 　网站优化排名推广　　 　成都SEO优化公司　　 　成都门窗定制　　 　雅安服务器托管　　 　成都艾瑞格　　 　成都光华机房服务器托管　　 　移动机房服务器托管　　 　手机网站制作　　 　四川成都网站设计　　 　发电机组维修保养　　 　网站建设　　 　中建建业环保　　 　电信机房托管　　 　成都雨棚定制　　 　成都网站设计　　 　广告品牌策划设计　　 　成都网站制作　　 　成都外贸网站建设