用正则表达式解析算术字符串

Question

I need to parse an arithmetic string with only times ( * ) and add ( + ), eg, 300+10*51+20+2*21 , use regular expressions.

I have the working code below:

import re


input_str = '300+10*51+20+2*21'

#input_str = '1*2+3*4'


prod_re = re.compile(r"(\d+)\*(\d+)")
sum_re = re.compile(r"(\d+)\+?")

result = 0
index = 0
while (index <= len(input_str)-1):
    #-----
    prod_match = prod_re.match(input_str, index)
    if prod_match:
        # print 'find prod', prod_match.groups()
        result += int(prod_match.group(1))*int(prod_match.group(2))
        index += len(prod_match.group(0))+1
        continue
    #-----
    sum_match = sum_re.match(input_str, index)
    if sum_match:
        # print 'find sum', sum_match.groups()
        result += int(sum_match.group(1))
        index += len(sum_match.group(0))
        continue
    #-----
    if (not prod_match) and (not sum_match):
        print 'None match, check input string'
        break


print result

I am wondering if there is a way to avoid creating the variable index above?

Answer 1

The algorithm seems not correct. An input of 1*2+3*4 does not yield a correct result. It seems wrong that after resolving one multiplication you continue to resolve an addition, while in some cases you would have to first resolve more multiplications before doing any additions.

With some change in the regular expressions and loops, you can achieve what you want as follows:

import re

input_str = '3+1*2+3*4'

# match terms, which may include multiplications
sum_re = re.compile(r"(\d+(?:\*\d+)*)(?:\+|$)")
# match factors, which can only be numbers 
prod_re = re.compile(r"\d+")

result = 0
# find terms
for sum_match in sum_re.findall(input_str):
    # for each term, determine its value by applying the multiplications
    product = 1
    for prod_match in prod_re.findall(sum_match):
        product *= int(prod_match)
    # add the term's value to the result
    result += product

print (result)

Explanation

This regular expression:

(\d+(?:\*\d+)*)(?:\+|$)

... matches an integer followed by zero or more multiplications:

(?:\*\d+)*

The (?: makes it a non-capture group. Without ?: the method findall would assign this part of the match to a separate list element, which we don't want.

\\*\\d+ is: a literal asterisk followed by digits.

The final (?:\\+|$) is again a non-capture group, that requires either a literal + to follow, or the end of the input ( $ ).

Answer 2

The solution to your problem should be a possible sign preceded term followed by a list of terms, separated by an adding operator like in

[+-]?({term}([+-]{term})*)

in which each term is one factor, followed by a possible empty list of a multiplicative operator and another factor, like this:

{factor}([*/]{factor})*

where factor is a sequence of digits [0-9]+ , so substituting, leads to:

[+-]?([0-9]+([*/][0-9]+)*([+-][0-9]+([*/][0-9]+)*)*)

This will be a possible regexp that you can have, It assumes the structure of precedence between the operators that you can have. But it doesn't allow you to extract the different elements, as is demonstrated easily: the regexp has only 4 group elements inside (4 left parenthesis) so you can only match four of these (the first term, the last factor of the first term, the last term, and the last factor of the last term. If you begin to surround subexpressions with parenthesis, you can get more, but thing that the number of groups in a regexp is finite , and you can construct a possible infinitely long regular expression.

Said this (that you will not be able to separate all groups of things from the regexp structure) a different approach is taken: first sign is optional, and can be followed by an undefined number of terms, separated by either multiplicative operators or by additive ones:

[+-]?([0-9]+([*/+-][0-9]+)*

will do the work also (it matches the same set of expressions. Even if you restrict to the fact that only one operator can be interspesed in any secuence of 1 or more digits, the resulting regexp could be simplified to:

[-+]?[0-9]([*/+-]?[0-9])*

or with the usual notations used nowadays, to:

[-+]?\d([*/+-]?\d)*