用Python最原始的函数模拟eval函数的浮点数运算功能

前几天看一个网友提问,如何计算'1+1'这种字符串的值,不能用eval函数.

我仿佛记得以前新手时,对这个问题完全不知道如何下手.

我觉得处理括号实在是太复杂了,多层嵌套括号怎么解析呢?一些多余的括号呢?

而在没有括号的情况下,处理不同运算符之间的优先级又很头疼.

而'**'这种占2个字符的运算符,还有着奇特的优先级规则,x**y**z应先计算y**z,并且如果z后面还跟着**的话,则不能先计算y**z..这是最难的地方!

 

但是,今天我竟然把它实现了!而且是用最原始的函数实现的,它们是:

str,s.isdigit,s.find,s.count,
dict,float
if,in,and,not
==,>=,+(字符串连接)

 

float对象的6个方法不计算在内,这是无法避免的基础函数.

而str,float,dict只是起到类型转换或初始化数据的作用.所以真正用到的函数更是少之又少.

可能正是因为如此,我在程序设计上花了很多的心思.我用了非常多的if判断.显得有些难以看懂.而实际上每个分支都对应一种简单的情况.

唯一难的地方在于幂的递归运算(get_rig_rest函数).

 

这令我非常激动.这让我意识到自己解决复杂问题的能力!

另外应该指出,我的思路来自于前段时间学习Scheme时重写一些基本函数所养成的递归思考的习惯.

同时,Python真的是太方便和强大了,快速的print让测试+修改十分简单,极大提高了大脑解决抽象问题的能力(没有print,也许你要浪费很多笔,纸和时间).

dic={'+':float.__add__,
'-':float.__sub__,
'*':float.__mul__,
'/':float.__floordiv__,
'%':float.__mod__,
'**':float.__pow__,}
priority=dict((('**',3),('*',2),('/',2),('%',2),('+',1),('-',1)))
def prt(opf,p_opf):
'幂运算符总是最优先,即使左边也是幂运算符'
if p_opf=='**':
return False
return priority[opf]>=priority[p_opf]
def get_val(lef,opf,rig):
return str(dic[opf](float(lef),float(rig)))
def isfloat(s):
return s.isdigit() or s=='.'
def get_brace(s,start=0):
pos=s.find(')',start)+1
brace=s[:pos]
if brace.count('(')==brace.count(')'):
return brace,s[pos:]
return get_brace(s,pos)
def get_rig_rest(s,num=''):
'分裂为数字+剩余部分'
'如果数字后是幂运算符,则需要计算该数字的幂,将结果作为数字部分返回'
if s[:2] =='**':
pow_num,rest=get_rig_rest(s[2:])
return get_val(num,'**',pow_num),rest
if s=='' or s[0] in dic:
return num,s
if s[0]=='(':
brace,rest=get_brace(s)
return ieval(brace[1:-1]),rest
if isfloat(s[0]):
return get_rig_rest(s[1:],num+s[0])
def ieval(s,lef='',opf=None,rig=''):
if not opf and not s:
return lef
if not opf and isfloat(s[0]):
return ieval(s[1:],lef+s[0],opf,rig)
if not opf and s[0] in dic:
if s[1]=='*':
return ieval(s[2:],lef,'**',rig)
return ieval(s[1:],lef,s[0],rig)
if not opf and s[0]=='(':
brace,rest=get_brace(s)
if not rest:
return ieval(brace[1:-1])
return ieval(rest,lef+ieval(brace[1:-1]),
opf,rig)
if opf and not s:
return get_val(lef,opf,rig)
if opf and s[0]=='(':
brace,rest=get_brace(s)
if not rest:
return get_val(lef,opf,ieval(brace[1:-1]))
return ieval(lef+opf+ieval(brace[1:-1])+rest,
'',None,'')
if opf and isfloat(s[0]):
return ieval(s[1:],lef,opf,rig+s[0])
if opf and s[0] in dic:
number=2 if s[1]=='*' else 1
p_opf=s[:number]
if prt(opf,p_opf):
return ieval(s,get_val(lef,opf,rig),None,'')
p_rig,p_rest=get_rig_rest(s[number:])
return ieval(lef+opf+get_val(rig,p_opf,p_rig)+p_rest,
'',None,'')
test=['1+2+3', #常规
'1+2*9', #简单运算符优先级
'1+2*(3+4)', #简单运算符优先级+括号
'4**3**2', #幂运算优先级
'3+2*0.5**(2+2**2)',#多重优先级+括号
'(1+2)*(2+3)', #并列括号
'((9+3)/2)', #嵌套括号
'((1234)-1)', #多余括号
'((1+3**2)*((2%3+(3+3*2**3))*(4-1)*(1+2)+5*6)*4)'] #复杂情形
for x in test:
print(ieval(x),'---',eval(x))

 

结果:

>>>
6.0 --- 6
19.0 --- 19
15.0 --- 15
262144.0 --- 262144
3.03125 --- 3.03125
15.0 --- 15
6.0 --- 6.0
1233.0 --- 1233
11640.0 --- 11640