我正在尝试开发一个简单的python方法，它允许我计算基本的数学运算。这里的要点是我不能使用eval（），exec（）或任何其他评估python状态的函数，所以我必须手动完成。到目前为止，我已经遇到过这段代码：
solutionlist = list(basicoperationslist)
for i in range(0, len(solutionlist)):
if '+' in solutionlist[i]:
y = solutionlist[i].split('+')
solutionlist[i] = str(int(y[0]) + int(y[1]))
elif '*' in solutionlist[i]:
y = solutionlist[i].split('*')
solutionlist[i] = str(int(y[0]) * int(y[1]))
elif '/' in solutionlist[i]:
y = solutionlist[i].split('/')
solutionlist[i] = str(int(y[0]) // int(y[1]))
elif '-' in solutionlist[i]:
y = solutionlist[i].split('-')
solutionlist[i] = str(int(y[0]) - int(y[1]))
print("The solutions are: " + ', '.join(solutionlist))
因此我们有两个字符串列表，基本操作列表具有以下格式的操作：2940-81,101-16,46 / 3,10 * 9,145 / 24，-34-40。 它们总是有两个数字，中间有一个操作数。我的解决方案的问题是，当我有一个类似于最后一个的操作时，.split（）方法将我的列表拆分为一个空列表和一个包含完整操作的列表。总之，当我们将负数与负操作混合时，此解决方案不能很好地工作。我不知道在任何其他情况下是否失败，因为我只是注意到我之前描述的错误。 我的想法是，在方法结束时，我将解决方案列表作为字符串列表，它将成为基本数学运算的有序答案。 这是在我的代码遇到类似上一个操作时提示输出的错误： ValueError：基数为10的int（）的无效文字：＆＃39;＆＃39;
这里定义了basicoperationslist：
basicoperationslist = re.findall('[-]*\d+[+/*-]+\d+', step2processedoperation)
如您所见，我使用正则表达式从较大的操作中提取基本操作。 step2processedoperation是服务器发送到我的机器的String。但作为示例，它可能包含：
((87/(64*(98-94)))+((3-(97-27))-(89/69)))
它包含完整和平衡的数学运算。
也许有人可以帮我解决这个问题，或者我应该完全改变这个方法。
提前谢谢。
答案 0 :(得分：0)
我放弃了整个分裂方法，因为它过于复杂，在某些情况下可能会因为你注意到而失败。
相反，我会使用正则表达式和operator模块来简化操作。
import re
import operator
operators = {'+': operator.add,
'-': operator.sub,
'*': operator.mul,
'/': operator.truediv}
regex = re.compile(r'(-?\d+)' # 1 or more digits with an optional leading '-'
r'(\+|-|\*|/)' # one of +, - , *, /
r'(\d+)', # 1 or more digits
re.VERBOSE)
exprssions = ['2940-81', '101-16', '46/3', '10*9', '145/24', '-34-40']
for expr in exprssions:
a, op, b = regex.search(expr).groups()
print(operators[op](int(a), int(b)))
# 2859
# 85
# 15.333333333333334
# 90
# 6.041666666666667
# -74
这种方法更容易适应新案例（例如新的运营商）
答案 1 :(得分：0)
您可以轻松使用operator和dict来存储操作，而不是if-else的长列表
此解决方案还可以通过递归计算更复杂的表达式。
from operator import add, sub, mul, floordiv, truediv
from functools import reduce
OPERATIONS = {
'+': add,
'-': sub,
'*': mul,
'/': floordiv, # or '/': truediv,
'//': floordiv,
}
OPERATION_ORDER = (('+', '-'), ('//', '/', '*'))
def calculate(expression):
# expression = expression.strip()
try:
return int(expression)
except ValueError:
pass
for operations in OPERATION_ORDER:
for operation in operations:
if operation not in expression:
continue
parts = expression.split(operation)
parts = map(calculate, parts) # recursion
value = reduce(OPERATIONS[operation], parts)
# print(expression, value)
return value
在计算之前：
negative = False
if expression[0] == '-':
negative = True
expression = expression[1:]
在计算中，分割后的字符串：
if negative:
parts[0] = '-' + parts[0]
所以这总是变成：
def calculate(expression):
try:
return int(expression)
except ValueError:
pass
negative = False
if expression[0] == '-':
negative = True
expression = expression[1:]
for operations in OPERATION_ORDER:
for operation in operations:
if operation not in expression:
continue
parts = expression.split(operation)
if negative:
parts[0] = '-' + parts[0]
parts = map(calculate, parts) # recursion
return reduce(OPERATIONS[operation], parts)
使用re可以轻松检查是否有括号。首先，我们需要确保它不会识别出简单的＆＃39; parenthised中间结果（如(-1)）
PATTERN_PAREN_SIMPLE= re.compile('\((-?\d+)\)')
PAREN_OPEN = '|'
PAREN_CLOSE = '#'
def _encode(expression):
return PATTERN_PAREN_SIMPLE.sub(rf'{PAREN_OPEN}\1{PAREN_CLOSE}', expression)
def _decode(expression):
return expression.replace(PAREN_OPEN, '(').replace(PAREN_CLOSE, ')')
def contains_parens(expression):
return '(' in _encode(expression)
然后计算最左边的最外面的括号，你可以使用这个函数
def _extract_parens(expression, func=calculate):
# print('paren: ', expression)
expression = _encode(expression)
begin, expression = expression.split('(', 1)
characters = iter(expression)
middle = _search_closing_paren(characters)
middle = _decode(''.join(middle))
middle = func(middle)
end = ''.join(characters)
result = f'{begin}({middle}){end}' if( begin or end) else str(middle)
return _decode(result)
def _search_closing_paren(characters, close_char=')', open_char='('):
count = 1
for char in characters:
if char == open_char:
count += 1
if char == close_char:
count -= 1
if not count:
return
else:
yield char
围绕() calculate(middle)的原因是因为中间结果可能是否定的，如果括号被遗漏在这里，这可能会在以后出现问题。
然后算法的开头变为：
def calculate(expression):
expression = expression.replace(' ', '')
while contains_parens(expression):
expression = _extract_parens(expression)
if PATTERN_PAREN_SIMPLE.fullmatch(expression):
expression = expression[1:-1]
try:
return int(expression)
except ValueError:
pass
由于中间结果可能是否定的，我们需要在-上拆分正则表达式，以防止在5 * (-1)上分割-
所以我重新排序了这样的可能操作：
OPERATIONS = (
(re.compile('\+'), add),
(re.compile('(?<=[\d\)])-'), sub), # not match the - in `(-1)`
(re.compile('\*'), mul),
(re.compile('//'), floordiv),
(re.compile('/'), floordiv), # or '/': truediv,
)
-的模式仅在其前面有)或数字时匹配。这样我们就可以删除negative标志并处理
其余算法随后更改为：
operation, parts = split_expression(expression)
parts = map(calculate, parts) # recursion
return reduce(operation, parts)
def split_expression(expression):
for pattern, operation in OPERATIONS:
parts = pattern.split(expression)
if len(parts) > 1:
return operation, parts
可以找到完整的代码here
def test_expression(expression):
return calculate(expression) == eval(expression.replace('/','//')) # the replace to get floor division
def test_calculate():
assert test_expression('1')
assert test_expression(' 1 ')
assert test_expression('(1)')
assert test_expression('(-1)')
assert test_expression('(-1) - (-1)')
assert test_expression('((-1) - (-1))')
assert test_expression('4 * 3 - 4 * 4')
assert test_expression('4 * 3 - 4 / 4')
assert test_expression('((87/(64*(98-94)))+((3-(97-27))-(89/69)))')
test_calculate()
添加电源就像添加
一样简单(re.compile('\*\*'), pow),
(re.compile('\^'), pow),
到OPERATIONS
calculate('2 + 4 * 10^5')
400002