L'évaluation d'une expression mathématique dans une chaîne de caractères

Pyparsing peut être utilisé pour analyser des expressions mathématiques. En particulier, fourFn.py
montre comment analyser de base des expressions arithmétiques. Ci-dessous, j'ai rewrapped fourFn en numérique analyseur de classe pour en faciliter la réutilisation.

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

Vous pouvez l'utiliser comme cette

nsp = NumericStringParser()
result = nsp.eval('2^4')
print(result)
# 16.0
result = nsp.eval('exp(2^4)')
print(result)
# 8886110.520507872

Certaines des solutions de rechange eval() et sympy.sympify().evalf()^*:

• asteval
• numexpr

^*SymPy sympify est aussi dangereuse selon l'avertissement suivant à partir de la documentation.

Avertissement: Noter que cette fonction utilise eval, et donc ne devrait pas être utilisé sur unsanitized d'entrée.

La raison eval et exec sont si dangereux, c'est que la valeur par défaut compile fonction génère du bytecode pour être valable, toute expression python, et la valeur par défaut eval ou exec exécutera toute python bytecode. Toutes les réponses à ce jour ont porté sur le fait de restreindre le bytecode qui peuvent être générés (par désinfection d'entrée) ou la construction de votre propre nom de domaine spécifique de la langue à l'aide de l'AST.

Au lieu de cela, vous pouvez facilement créer un simple eval fonction qui est incapable de faire quelque chose infâme et peut facilement l'exécution des contrôles sur la mémoire ou le temps utilisé. Bien sûr, si il est simple de mathématiques, qu'il y a un raccourci.

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]

La façon dont cela fonctionne est simple, toute constante mathématique de l'expression en toute sécurité est évalué lors de la compilation et stockée comme une constante. Le code de l'objet retourné par la compilation se compose de d, qui est le pseudo-code d' LOAD_CONST, suivi du numéro de la constante de charge (généralement le dernier de la liste), suivie par S, qui est le pseudo-code d' RETURN_VALUE. Si ce raccourci ne fonctionne pas, cela signifie que la saisie de l'utilisateur n'est pas une expression constante (contient une variable ou d'un appel de fonction ou similaire).

Cela ouvre également la porte à certains plus sophistiqués formats d'entrée. Par exemple:

stringExp = "1 + cos(2)"

Cela nécessite effectivement d'évaluer le bytecode, qui est encore assez simple. Python bytecode est une pile langage orienté, donc tout est une simple question de TOS=stack.pop(); op(TOS); stack.put(TOS) ou similaire. La clé est de ne mettre en œuvre les opcodes qui sont sûrs (chargement/stockage des valeurs, des opérations mathématiques, le retour des valeurs) et non dangereux (à l'attribut de la recherche). Si vous voulez que l'utilisateur soit en mesure d'appeler des fonctions (l'ensemble de raison de ne pas utiliser le raccourci ci-dessus), vous pouvez simplement faire de votre mise en œuvre de CALL_FUNCTION autoriser uniquement les fonctions dans un "coffre-fort" la liste.

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'))

Évidemment, la vraie version de ce serait un peu plus (il y a 119 opcodes, 24 mathématiques liée). L'ajout de STORE_FAST et quelques autres permettrait d'entrée comme 'x=5;return x+x ou similaire, trivialement facilement. Il peut même être utilisé pour exécuter créé par l'utilisateur, les fonctions, aussi longtemps que l'utilisateur a créé fonctions sont eux-mêmes exécutés par VMeval (ne les faites pas appelable!!! ou ils pourraient obtenir utilisé comme un rappel de quelque part). Boucles de gestion exige le soutien de la goto bytecode, qui signifie passer d'une for itérateur pour while et le maintien d'un pointeur à l'instruction, mais n'est-ce pas trop difficile. Pour la résistance à DOS, la boucle principale doit vérifier combien de temps a passé depuis le début du calcul, et certains opérateurs devraient refuser l'entrée sur certains la limite du raisonnable (BINARY_POWER être le plus évident).

Bien que cette approche est un peu plus long qu'un simple grammaire de l'analyseur pour les expressions simples (voir ci-dessus à propos de vous contenter de prendre l'compilé constante), elle s'étend facilement à plus compliqué d'entrée, et ne nécessite pas de traiter avec la grammaire (compile prendre quoi que ce soit arbitrairement complexe et le réduit à une suite d'instructions simples).

Vous pouvez utiliser le module ast et d'écrire un NodeVisitor qui vérifie que le type de chaque nœud est partie d'une liste blanche.

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)

Car il fonctionne par l'intermédiaire d'une liste blanche plutôt que d'une liste noire, c'est sûr. Les seules fonctions et de variables, il peut accéder à sont celles que vous avez explicitement donner accès. J'ai rempli un dict avec les mathématiques, les fonctions liées de sorte que vous pouvez facilement fournir l'accès à ces si vous voulez, mais vous devez explicitement l'utiliser.

Si la chaîne tente d'appeler des fonctions qui n'ont pas été fournis, ou appeler l'une des méthodes, une exception sera levée, et il ne sera pas exécuté.

Car il utilise Python intégré dans l'analyseur et l'évaluateur, il hérite également Python de préséance et les règles de la promotion en tant que bien.

>>> evaluate("7 + 9 * (2 << 2)")
79
>>> evaluate("6 //2 + 0.0")
3.0

Le code ci-dessus a été testé uniquement sur Python 3.

Si vous le souhaitez, vous pouvez ajouter un délai d'attente décorateur sur cette fonction.

[Je sais c'est une vieille question, mais il est intéressant de souligner de nouvelles solutions comme ils pop up]

Depuis python3.6, cette capacité est maintenant construit dans la langue, inventé "f-chaînes".

Voir: PEP 498 -- Chaîne Littérale de l'Interpolation

Par exemple (notez le f préfixe):

f'{2**4}'
=> '16'

Utilisation eval dans un endroit propre espace de noms:

>>> ns = {'__builtins__': None}
>>> eval('2 ** 4', ns)
16

Le nettoyage de l'espace de noms doit empêcher l'injection. Par exemple:

>>> 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__'

Sinon, vous obtenez:

>>> eval('__builtins__.__import__("os").system("echo got through")')
got through
0

Vous pourriez donner l'accès au module math:

>>> import math
>>> ns = vars(math).copy()
>>> ns['__builtins__'] = None
>>> eval('cos(pi/3)', ns)
0.50000000000000011