Python用正则实现计算字符串算式

• 在Python里面其实有一种特别方便实用的直接计算字符串算式的方法

• 那就是eval()

  s = '1+2*(6/2-9+3*(3*9-9))'
  print(eval(s))
  
  #97.0

• 好了，我现在就是想用正则写一个类似这样功能的东西

• 第一步，我们拿到一个算式，例如'1+2(6/2-9+3(3*9-9))'

  • 按照我们小学学的知识我们应该知道我们应该从最内层括号里面的算式开始计算

  • 那我们怎么拿到最内层括号里面的算式呢？我们可以用正则啊

    import re
    pattern = re.compile(r'\([^(^)]*?\)')
    s = '1+2*(6/2-9+3*(3*9-9))+(6-3)'
    ret = pattern.findall(s)
    print(ret)
    #['(3*9-9)','(6-3)']

  • 好了，我们现在就拿到了最内层括号以及里面的算式了，第一步完成

• 第二步，我们要把拿到的内容给它去掉括号

  • 因为我们拿到的最内层的括号可能不止一个，所以我们用一个新的列表来存一下去掉括号里面的算式

    ret2 = []
    pattern2 = re.compile(r'\((?P<tag>.*?)\)')
    for i in range(len(ret)):
        ret3 = pattern2.search(ret[i])
        ret2.append(ret3.group('tag'))
    print(ret2)
    #['3*9-9', '6-3']

  • 其实到这里我们几乎已经成功一大半了

• 第三步，我们就要来安排我们拿到的最内层括号的算式了

  • 这里只展示逻辑，我就只拿'3*9-9'(ret2[1])来说了

  • 我们还是得根据算术逻辑来，先乘除，后加减

  • 乘除

    def mul_div(s):
        if '*' in s:
            s = s.split('*')
            return float(s[0]) * float(s[1])
        elif '/' in s:
            s = s.split('/')
            return float(s[0]) / float(s[1])
    
    
    
    while True:
        pattern3 = re.compile(r'[-+*/]?(?P<tag>-?\d+(\.\d+)?[*/]-?\d+(\.\d+)?)')
        ret3 = pattern3.search(ret2[1])
        try:
            ret4 = ret3.group('tag')
        except Exception as e:
            pass
        if '*' not in ret2[1] and '/' not in ret2[1]:
            break    
        else:
    
            ret2[1] = ret2[1].replace(ret4, str(mul_div(ret4)))

    • 这里的代码，可能看不明白，我来解释一下
    • 首先mul_div()就是自己定义的一个计算乘除法的方法
    • 因为正则表达式的约束，并且用的是search，所以一下得到的字符串只可能是字符+'/'+字符或者字符+'*'+字符。所以这里字符串切割，必定会根据乘除号切成两个元素的列表
    • 我们算出了字符+'/'+字符或者字符+'*'+字符的值，我们就要用算出来的值替换掉正则匹配的字符串，直到这个字符串中没有乘除号

  • 加减

    def add_sub(s):
        if '+' in s:
            s = s.split('+')
            return float(s[0]) + float(s[1])
        else:
            if s[0] == '-':
                s = s[1::].split('-', 1)
                s[0] = '-' + s[0]
                return float(s[0]) - float(s[1])
            else:
                s = s.split('-', 1)
                return float(s[0]) - float(s[1])
    
    
    
    while True:
        pattern3 = re.compile(r'-?\d+(\.\d+)?[-+]-?\d+(\.\d+)?')
        ret3 = pattern3.search(ret2[i])
        try:
            ret4 = ret3.group()
    
        except Exception as e:
            pass
        if '+' not in ret2[i] and '-' not in ret2[i][1::]:
            break
        else:
            ret2[i] = ret2[i].replace(ret4, str(add_sub(ret4)))

    • 加减法和上面的乘除法没多少区别
    • 唯一的区别就是判断退出时，一个数可能是负数，就不能直接判断负号存不存在了，就要判断除了第一个位置，其余的位置还存不存在负号

• 第四步

  • 在这里，我们所有最内层括号算出来的数都在ret2这个列表里面，我们ret1中存放的是最内层括号以及里面的算式，所以我们将两者替换就可以了

    def str_replace(lst1,lst2):
        for i in range(len(lst1)):
            global str1
            str1 = str1.replace(lst1[i], lst2[i])
    
    str_replace(ret1,ret2)

• 第五步

  • 其实到这里我们离成功就差一小步了

  • 可能你已经发现了，我们这一套下来，就是对一个括号内的算式进行运算，如果没有括号它最后就不会对它进行操作，那我们就在字符串进来的时候给最外层套一个括号就OK了

    str1 = '1+2*(6/2-9+3*(3*9-9))'
    str1 = '( )'.replace(' ',str1)

  • 然后拿到一个算式一直重复上面的几个步骤，直到没有括号。

• 完整代码

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import re

# 乘除法
def mul_div(s):
    if '*' in s:
        s = s.split('*')
        return float(s[0]) * float(s[1])
    elif '/' in s:
        s = s.split('/')
        return float(s[0]) / float(s[1])

# 加减法
def add_sub(s):
    if '+' in s:
        s = s.split('+')
        return float(s[0]) + float(s[1])
    else:
        if s[0] == '-':
            s = s[1::].split('-', 1)
            s[0] = '-' + s[0]
            return float(s[0]) - float(s[1])
        else:
            s = s.split('-', 1)
            return float(s[0]) - float(s[1])


# 替换字符串
def str_replace(lst1,lst2):
    for i in range(len(lst1)):
        global str1
        str1 = str1.replace(lst1[i], lst2[i])


# 匹配最内层括号
pattern1 = re.compile(r'\([^(^)]*?\)')
str1 = '1+2*(6/2-9+3*(3*9-9))'
str1 = '( )'.replace(' ',str1)
while True:
    if '(' not in str1 and ')' not in str1:
        break
    ret1 = pattern1.findall(str1)

    # 匹配括号内的内容
    ret2 = []
    pattern2 = re.compile(r'\((?P<tag>.*?)\)')
    for i in range(len(ret1)):
        ret = pattern2.search(ret1[i])
        ret2.append(ret.group('tag'))


        # 计算乘除法
        while True:
            pattern3 = re.compile(r'[-+*/]?(?P<tag>-?\d+(\.\d+)?[*/]-?\d+(\.\d+)?)')
            ret3 = pattern3.search(ret2[i])
            try:
                ret4 = ret3.group('tag')
            except Exception as e:
                pass
            if '*' not in ret2[i] and '/' not in ret2[i]:
                break
            else:
                ret2[i] = ret2[i].replace(ret4, str(mul_div(ret4)))
        # 计算加法
        while True:
            pattern3 = re.compile(r'-?\d+(\.\d+)?[-+]-?\d+(\.\d+)?')
            ret3 = pattern3.search(ret2[i])
            try:
                ret4 = ret3.group()
            except Exception as e:
                pass
            if '+' not in ret2[i] and '-' not in ret2[i][1::]:
                break
            else:
                ret2[i] = ret2[i].replace(ret4, str(add_sub(ret4)))


    str_replace(ret1,ret2)

print(str1)
#97.0

• 结束语
• 希望以后有人看到了，就不要吐槽我的ret1-ret4的变量命名了
• 还有不知道有没有写清楚，看的人能不能看明白，毕竟一晚上没睡觉，可能脑子不好使。
• 我这代码肯定有很多值得优化的地方，所以仅供参考。
• 哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈

标签：ret2,算式,str1,float,Python,正则,括号,ret4
来源： https://www.cnblogs.com/nanke33/p/12101435.html