stringExp = "2^4"
intVal = int(stringExp) # Expected value: 16
这会返回以下错误：
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int()
with base 10: '2^4'
我知道eval可以解决这个问题，但是不是有更好的 - 更重要的 - 更安全的方法来评估存储在字符串中的数学表达式吗？
答案 0 :(得分：162)
eval是邪恶的eval("__import__('os').remove('important file')") # arbitrary commands
eval("9**9**9**9**9**9**9**9", {'__builtins__': None}) # CPU, memory
注意：即使您使用set __builtins__到None，仍然可以使用内省突破：</ p>
eval('(1).__class__.__bases__[0].__subclasses__()', {'__builtins__': None})
ast import ast
import operator as op
# supported operators
operators = {ast.Add: op.add, ast.Sub: op.sub, ast.Mult: op.mul,
ast.Div: op.truediv, ast.Pow: op.pow, ast.BitXor: op.xor,
ast.USub: op.neg}
def eval_expr(expr):
"""
>>> eval_expr('2^6')
4
>>> eval_expr('2**6')
64
>>> eval_expr('1 + 2*3**(4^5) / (6 + -7)')
-5.0
"""
return eval_(ast.parse(expr, mode='eval').body)
def eval_(node):
if isinstance(node, ast.Num): # <number>
return node.n
elif isinstance(node, ast.BinOp): # <left> <operator> <right>
return operators[type(node.op)](eval_(node.left), eval_(node.right))
elif isinstance(node, ast.UnaryOp): # <operator> <operand> e.g., -1
return operators[type(node.op)](eval_(node.operand))
else:
raise TypeError(node)
您可以轻松限制每个操作或任何中间结果的允许范围，例如，限制a**b的输入参数：
def power(a, b):
if any(abs(n) > 100 for n in [a, b]):
raise ValueError((a,b))
return op.pow(a, b)
operators[ast.Pow] = power
或限制中间结果的大小：
import functools
def limit(max_=None):
"""Return decorator that limits allowed returned values."""
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
ret = func(*args, **kwargs)
try:
mag = abs(ret)
except TypeError:
pass # not applicable
else:
if mag > max_:
raise ValueError(ret)
return ret
return wrapper
return decorator
eval_ = limit(max_=10**100)(eval_)
>>> evil = "__import__('os').remove('important file')"
>>> eval_expr(evil) #doctest:+IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
TypeError:
>>> eval_expr("9**9")
387420489
>>> eval_expr("9**9**9**9**9**9**9**9") #doctest:+IGNORE_EXCEPTION_DETAIL
Traceback (most recent call last):
...
ValueError:
答案 1 :(得分：89)
Pyparsing可用于解析数学表达式。尤其是fourFn.py 演示了如何解析基本的算术表达式。下面，我将fourFn重新编译为数字解析器类，以便于重用。
from __future__ import division
from pyparsing import (Literal, CaselessLiteral, Word, Combine, Group, Optional,
ZeroOrMore, Forward, nums, alphas, oneOf)
import math
import operator
__author__ = 'Paul McGuire'
__version__ = '$Revision: 0.0 $'
__date__ = '$Date: 2009-03-20 $'
__source__ = '''http://pyparsing.wikispaces.com/file/view/fourFn.py
http://pyparsing.wikispaces.com/message/view/home/15549426
'''
__note__ = '''
All I've done is rewrap Paul McGuire's fourFn.py as a class, so I can use it
more easily in other places.
'''
class NumericStringParser(object):
'''
Most of this code comes from the fourFn.py pyparsing example
'''
def pushFirst(self, strg, loc, toks):
self.exprStack.append(toks[0])
def pushUMinus(self, strg, loc, toks):
if toks and toks[0] == '-':
self.exprStack.append('unary -')
def __init__(self):
"""
expop :: '^'
multop :: '*' | '/'
addop :: '+' | '-'
integer :: ['+' | '-'] '0'..'9'+
atom :: PI | E | real | fn '(' expr ')' | '(' expr ')'
factor :: atom [ expop factor ]*
term :: factor [ multop factor ]*
expr :: term [ addop term ]*
"""
point = Literal(".")
e = CaselessLiteral("E")
fnumber = Combine(Word("+-" + nums, nums) +
Optional(point + Optional(Word(nums))) +
Optional(e + Word("+-" + nums, nums)))
ident = Word(alphas, alphas + nums + "_$")
plus = Literal("+")
minus = Literal("-")
mult = Literal("*")
div = Literal("/")
lpar = Literal("(").suppress()
rpar = Literal(")").suppress()
addop = plus | minus
multop = mult | div
expop = Literal("^")
pi = CaselessLiteral("PI")
expr = Forward()
atom = ((Optional(oneOf("- +")) +
(ident + lpar + expr + rpar | pi | e | fnumber).setParseAction(self.pushFirst))
| Optional(oneOf("- +")) + Group(lpar + expr + rpar)
).setParseAction(self.pushUMinus)
# by defining exponentiation as "atom [ ^ factor ]..." instead of
# "atom [ ^ atom ]...", we get right-to-left exponents, instead of left-to-right
# that is, 2^3^2 = 2^(3^2), not (2^3)^2.
factor = Forward()
factor << atom + \
ZeroOrMore((expop + factor).setParseAction(self.pushFirst))
term = factor + \
ZeroOrMore((multop + factor).setParseAction(self.pushFirst))
expr << term + \
ZeroOrMore((addop + term).setParseAction(self.pushFirst))
# addop_term = ( addop + term ).setParseAction( self.pushFirst )
# general_term = term + ZeroOrMore( addop_term ) | OneOrMore( addop_term)
# expr << general_term
self.bnf = expr
# map operator symbols to corresponding arithmetic operations
epsilon = 1e-12
self.opn = {"+": operator.add,
"-": operator.sub,
"*": operator.mul,
"/": operator.truediv,
"^": operator.pow}
self.fn = {"sin": math.sin,
"cos": math.cos,
"tan": math.tan,
"exp": math.exp,
"abs": abs,
"trunc": lambda a: int(a),
"round": round,
"sgn": lambda a: abs(a) > epsilon and cmp(a, 0) or 0}
def evaluateStack(self, s):
op = s.pop()
if op == 'unary -':
return -self.evaluateStack(s)
if op in "+-*/^":
op2 = self.evaluateStack(s)
op1 = self.evaluateStack(s)
return self.opn[op](op1, op2)
elif op == "PI":
return math.pi # 3.1415926535
elif op == "E":
return math.e # 2.718281828
elif op in self.fn:
return self.fn[op](self.evaluateStack(s))
elif op[0].isalpha():
return 0
else:
return float(op)
def eval(self, num_string, parseAll=True):
self.exprStack = []
results = self.bnf.parseString(num_string, parseAll)
val = self.evaluateStack(self.exprStack[:])
return val
您可以像这样使用
nsp = NumericStringParser()
result = nsp.eval('2^4')
print(result)
# 16.0
result = nsp.eval('exp(2^4)')
print(result)
# 8886110.520507872
答案 2 :(得分：11)
eval()和sympy.sympify().evalf() * 的一些更安全的替代方案：
* 根据文档中的以下警告，SymPy sympify也不安全。
警告：请注意，此函数使用
eval，因此不应在未经过抽取的输入上使用。
答案 3 :(得分：7)
好的，所以eval的问题在于，即使你摆脱了__builtins__，它也很容易逃脱它的沙箱。转义沙箱的所有方法都归结为使用getattr或object.__getattribute__（通过.运算符）通过一些允许的对象获取对某个危险对象的引用（''.__class__.__bases__[0].__subclasses__或类似的）。将getattr设置为__builtins__即可消除None。 object.__getattribute__是困难的，因为它不能简单地删除，因为object是不可变的，因为删除它会破坏一切。但是，__getattribute__只能通过.运算符访问，因此从输入中清除它就足以确保eval无法逃脱其沙箱。
在处理公式时，唯一有效的小数使用是在[0-9]之前或之后，因此我们只删除.的所有其他实例。
import re
inp = re.sub(r"\.(?![0-9])","", inp)
val = eval(inp, {'__builtins__':None})
请注意，虽然python通常将1 + 1.视为1 + 1.0，但这会删除尾随的.并留下1 + 1。您可以将)，和EOF添加到允许关注.的内容列表中，但为什么要这么做呢？
答案 4 :(得分：6)
eval和exec之所以如此危险，是因为默认的compile函数会为任何有效的python表达式生成字节码，默认的eval或{{1将执行任何有效的python字节码。迄今为止的所有答案都集中在限制可以生成的字节码（通过清理输入）或使用AST构建自己的特定于域的语言。
相反，您可以轻松创建一个简单的exec函数，该函数无法执行任何恶意操作，并且可以轻松地对内存或使用的时间进行运行时检查。当然，如果它是简单的数学，那么就有一条捷径。
eval这种方式很简单，在编译期间可以安全地评估任何常量数学表达式并将其存储为常量。 compile返回的代码对象包含c = compile(stringExp, 'userinput', 'eval')
if c.co_code[0]==b'd' and c.co_code[3]==b'S':
return c.co_consts[ord(c.co_code[1])+ord(c.co_code[2])*256]
，它是d的字节码，后跟要加载的常量的编号（通常是列表中的最后一个），后跟{{1} }，这是LOAD_CONST的字节码。如果此快捷方式不起作用，则意味着用户输入不是常量表达式（包含变量或函数调用或类似）。
这也为一些更复杂的输入格式打开了大门。例如：
S这需要实际评估字节码，这仍然非常简单。 Python字节码是一种面向堆栈的语言，所以一切都是RETURN_VALUE或类似的简单问题。关键是只实现安全的操作码（加载/存储值，数学运算，返回值）而不是不安全的操作码（属性查找）。如果您希望用户能够调用函数（完全不使用上述快捷方式的原因），那么简单地使stringExp = "1 + cos(2)"
的实现只允许函数安全地使用。列表。
TOS=stack.pop(); op(TOS); stack.put(TOS)显然，这个版本的实际版本会更长一些（有119个操作码，其中24个是数学相关的）。添加CALL_FUNCTION和其他几个允许输入from dis import opmap
from Queue import LifoQueue
from math import sin,cos
import operator
globs = {'sin':sin, 'cos':cos}
safe = globs.values()
stack = LifoQueue()
class BINARY(object):
def __init__(self, operator):
self.op=operator
def __call__(self, context):
stack.put(self.op(stack.get(),stack.get()))
class UNARY(object):
def __init__(self, operator):
self.op=operator
def __call__(self, context):
stack.put(self.op(stack.get()))
def CALL_FUNCTION(context, arg):
argc = arg[0]+arg[1]*256
args = [stack.get() for i in range(argc)]
func = stack.get()
if func not in safe:
raise TypeError("Function %r now allowed"%func)
stack.put(func(*args))
def LOAD_CONST(context, arg):
cons = arg[0]+arg[1]*256
stack.put(context['code'].co_consts[cons])
def LOAD_NAME(context, arg):
name_num = arg[0]+arg[1]*256
name = context['code'].co_names[name_num]
if name in context['locals']:
stack.put(context['locals'][name])
else:
stack.put(context['globals'][name])
def RETURN_VALUE(context):
return stack.get()
opfuncs = {
opmap['BINARY_ADD']: BINARY(operator.add),
opmap['UNARY_INVERT']: UNARY(operator.invert),
opmap['CALL_FUNCTION']: CALL_FUNCTION,
opmap['LOAD_CONST']: LOAD_CONST,
opmap['LOAD_NAME']: LOAD_NAME
opmap['RETURN_VALUE']: RETURN_VALUE,
}
def VMeval(c):
context = dict(locals={}, globals=globs, code=c)
bci = iter(c.co_code)
for bytecode in bci:
func = opfuncs[ord(bytecode)]
if func.func_code.co_argcount==1:
ret = func(context)
else:
args = ord(bci.next()), ord(bci.next())
ret = func(context, args)
if ret:
return ret
def evaluate(expr):
return VMeval(compile(expr, 'userinput', 'eval'))
或类似的输入，很容易。它甚至可以用来执行用户创建的函数，只要用户创建的函数本身是通过VMeval执行的（不要让它们可调用!!!或者它们可以用作某个地方的回调）。处理循环需要支持STORE_FAST字节码，这意味着从'x=5;return x+x迭代器更改为goto并保持指向当前指令的指针，但不是太难。对于DOS的阻力，主循环应该检查自计算开始以来经过了多长时间，并且某些运算符应该在某个合理限制内拒绝输入（for是最明显的）。
虽然这种方法比简单表达式的简单语法分析器长一些（参见上面关于只是抓取编译常量），但它很容易扩展到更复杂的输入，并且不需要处理语法（{{1任意复杂的任何东西，并将其简化为一系列简单的指令。）
答案 5 :(得分：5)
这是一个非常迟到的回复，但我认为有用以供将来参考。而不是编写自己的数学解析器（虽然上面的pyparsing示例很棒），您可以使用SymPy。我没有很多经验，但它包含了比任何人可能为特定应用程序编写的更强大的数学引擎，并且基本的表达式评估非常简单：
>>> import sympy
>>> x, y, z = sympy.symbols('x y z')
>>> sympy.sympify("x**3 + sin(y)").evalf(subs={x:1, y:-3})
0.858879991940133
非常酷！ from sympy import *带来了更多功能支持，例如触发功能，特殊功能等，但我在这里避免使用它来显示来自哪里的内容。
答案 6 :(得分：5)
您可以使用ast模块并编写NodeVisitor来验证每个节点的类型是否为白名单的一部分。
import ast, math
locals = {key: value for (key,value) in vars(math).items() if key[0] != '_'}
locals.update({"abs": abs, "complex": complex, "min": min, "max": max, "pow": pow, "round": round})
class Visitor(ast.NodeVisitor):
def visit(self, node):
if not isinstance(node, self.whitelist):
raise ValueError(node)
return super().visit(node)
whitelist = (ast.Module, ast.Expr, ast.Load, ast.Expression, ast.Add, ast.Sub, ast.UnaryOp, ast.Num, ast.BinOp,
ast.Mult, ast.Div, ast.Pow, ast.BitOr, ast.BitAnd, ast.BitXor, ast.USub, ast.UAdd, ast.FloorDiv, ast.Mod,
ast.LShift, ast.RShift, ast.Invert, ast.Call, ast.Name)
def evaluate(expr, locals = {}):
if any(elem in expr for elem in '\n#') : raise ValueError(expr)
try:
node = ast.parse(expr.strip(), mode='eval')
Visitor().visit(node)
return eval(compile(node, "<string>", "eval"), {'__builtins__': None}, locals)
except Exception: raise ValueError(expr)
因为它通过白名单而不是黑名单工作，所以它是安全的。它可以访问的唯一函数和变量是您明确授予它访问权限的函数和变量。我使用与数学相关的函数填充了一个dict，这样你就可以轻松地提供对它们的访问，但是你必须明确地使用它。
如果字符串试图调用尚未提供的函数，或者调用任何方法，则会引发异常，并且不会执行该异常。
因为它使用Python的内置解析器和赋值器，所以它也继承了Python的优先级和推广规则。
>>> evaluate("7 + 9 * (2 << 2)")
79
>>> evaluate("6 // 2 + 0.0")
3.0
以上代码仅在Python 3上进行了测试。
如果需要，可以在此功能上添加超时装饰器。
答案 7 :(得分：3)
我想我会使用eval()，但首先会检查以确保字符串是有效的数学表达式，而不是恶意的东西。您可以使用正则表达式进行验证。
eval()还会使用其他参数来限制其运行的命名空间，以提高安全性。
答案 8 :(得分：3)
[我知道这是一个老问题，但值得在弹出时指出新的有用解决方案]
自python3.6以来，此功能现已内置于语言中，创造了“f-strings”。
请参阅：PEP 498 -- Literal String Interpolation
例如（请注意 f 前缀）：
f'{2**4}'
=> '16'
答案 9 :(得分：1)
如果您不想使用eval，那么唯一的解决方案是实现适当的语法分析器。看看pyparsing。
答案 10 :(得分：1)
基于Perkins' amazing approach，我更新并改进了他用于简单代数表达式（无函数或变量）的“快捷方式”。现在它适用于 Python 3.6+ 并避免了一些陷阱：
import re, sys
# Kept outside simple_eval() just for performance
_re_simple_eval = re.compile(rb'd([\x00-\xFF]+)S\x00')
def simple_eval(expr):
c = compile(expr, 'userinput', 'eval')
m = _re_simple_eval.fullmatch(c.co_code)
if not m:
raise ValueError(f"Not a simple algebraic expresion: {expr}")
return c.co_consts[int.from_bytes(m.group(1), sys.byteorder)]
测试，使用其他答案中的一些示例：
for expr, res in (
('2^4', 6 ),
('2**4', 16 ),
('1 + 2*3**(4^5) / (6 + -7)', -5.0 ),
('7 + 9 * (2 << 2)', 79 ),
('6 // 2 + 0.0', 3.0 ),
('2+3', 5 ),
('6+4/2*2', 10.0 ),
('3+2.45/8', 3.30625),
('3**3*3/3+3', 30.0 ),
):
result = simple_eval(expr)
ok = (result == res and type(result) == type(res))
print("{} {} = {}".format("OK!" if ok else "FAIL!", expr, result))
OK! 2^4 = 6
OK! 2**4 = 16
OK! 1 + 2*3**(4^5) / (6 + -7) = -5.0
OK! 7 + 9 * (2 << 2) = 79
OK! 6 // 2 + 0.0 = 3.0
OK! 2+3 = 5
OK! 6+4/2*2 = 10.0
OK! 3+2.45/8 = 3.30625
OK! 3**3*3/3+3 = 30.0
答案 11 :(得分：0)
如果你已经在使用wolframalpha，他们有一个python api，它允许你评估表达式。可能有点慢，但至少非常准确。
答案 12 :(得分：0)
这是我不使用eval即可解决问题的方法。适用于Python2和Python3。不适用于负数。
$ python -m pytest test.py
test.py
from solution import Solutions
class SolutionsTestCase(unittest.TestCase):
def setUp(self):
self.solutions = Solutions()
def test_evaluate(self):
expressions = [
'2+3=5',
'6+4/2*2=10',
'3+2.45/8=3.30625',
'3**3*3/3+3=30',
'2^4=6'
]
results = [x.split('=')[1] for x in expressions]
for e in range(len(expressions)):
if '.' in results[e]:
results[e] = float(results[e])
else:
results[e] = int(results[e])
self.assertEqual(
results[e],
self.solutions.evaluate(expressions[e])
)
solution.py
class Solutions(object):
def evaluate(self, exp):
def format(res):
if '.' in res:
try:
res = float(res)
except ValueError:
pass
else:
try:
res = int(res)
except ValueError:
pass
return res
def splitter(item, op):
mul = item.split(op)
if len(mul) == 2:
for x in ['^', '*', '/', '+', '-']:
if x in mul[0]:
mul = [mul[0].split(x)[1], mul[1]]
if x in mul[1]:
mul = [mul[0], mul[1].split(x)[0]]
elif len(mul) > 2:
pass
else:
pass
for x in range(len(mul)):
mul[x] = format(mul[x])
return mul
exp = exp.replace(' ', '')
if '=' in exp:
res = exp.split('=')[1]
res = format(res)
exp = exp.replace('=%s' % res, '')
while '^' in exp:
if '^' in exp:
itm = splitter(exp, '^')
res = itm[0] ^ itm[1]
exp = exp.replace('%s^%s' % (str(itm[0]), str(itm[1])), str(res))
while '**' in exp:
if '**' in exp:
itm = splitter(exp, '**')
res = itm[0] ** itm[1]
exp = exp.replace('%s**%s' % (str(itm[0]), str(itm[1])), str(res))
while '/' in exp:
if '/' in exp:
itm = splitter(exp, '/')
res = itm[0] / itm[1]
exp = exp.replace('%s/%s' % (str(itm[0]), str(itm[1])), str(res))
while '*' in exp:
if '*' in exp:
itm = splitter(exp, '*')
res = itm[0] * itm[1]
exp = exp.replace('%s*%s' % (str(itm[0]), str(itm[1])), str(res))
while '+' in exp:
if '+' in exp:
itm = splitter(exp, '+')
res = itm[0] + itm[1]
exp = exp.replace('%s+%s' % (str(itm[0]), str(itm[1])), str(res))
while '-' in exp:
if '-' in exp:
itm = splitter(exp, '-')
res = itm[0] - itm[1]
exp = exp.replace('%s-%s' % (str(itm[0]), str(itm[1])), str(res))
return format(exp)
答案 13 :(得分：0)
使用 Lark 解析器库 https://stackoverflow.com/posts/67491514/edit
from operator import add, sub, mul, truediv, neg, pow
from lark import Lark, Transformer, v_args
calc_grammar = f"""
?start: sum
?sum: product
| sum "+" product -> {add.__name__}
| sum "-" product -> {sub.__name__}
?product: power
| product "*" power -> {mul.__name__}
| product "/" power -> {truediv.__name__}
?power: atom
| power "^" atom -> {pow.__name__}
?atom: NUMBER -> number
| "-" atom -> {neg.__name__}
| "(" sum ")"
%import common.NUMBER
%import common.WS_INLINE
%ignore WS_INLINE
"""
@v_args(inline=True)
class CalculateTree(Transformer):
add = add
sub = sub
neg = neg
mul = mul
truediv = truediv
pow = pow
number = float
calc_parser = Lark(calc_grammar, parser="lalr", transformer=CalculateTree())
calc = calc_parser.parse
def eval_expr(expression: str) -> float:
return calc(expression)
print(eval_expr("2^4"))
print(eval_expr("-1*2^4"))
print(eval_expr("-2^3 + 1"))
print(eval_expr("2**4")) # Error
答案 14 :(得分：-1)
在干净的命名空间中使用eval：
>>> ns = {'__builtins__': None}
>>> eval('2 ** 4', ns)
16
clean名称空间应该可以防止注入。例如：
>>> eval('__builtins__.__import__("os").system("echo got through")', ns)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<string>", line 1, in <module>
AttributeError: 'NoneType' object has no attribute '__import__'
否则你会得到：
>>> eval('__builtins__.__import__("os").system("echo got through")')
got through
0
您可能想要访问数学模块：
>>> import math
>>> ns = vars(math).copy()
>>> ns['__builtins__'] = None
>>> eval('cos(pi/3)', ns)
0.50000000000000011
答案 15 :(得分：-1)
Python已经有一个函数来安全地评估包含文字表达式的字符串：