Python - Évaluer expression mathématique à l'intérieur de la chaîne

J'ai une question concernant l'évaluation de l'expression mathématique à l'intérieur d'une chaîne.
Par exemple, pour ma chaîne est la suivante:

my_str='I have 6 * (2 + 3) apples'

Je me demande comment l'évaluer cette chaîne et obtenir le résultat suivant:

'I have 30 apples'

Est la toute façon de le faire?

Merci d'avance.

P. S. python eval fonction n'est pas utile dans ce cas. Il a soulevé une erreur, lorsque vous essayez d'évaluer avec le eval fonction.

  • Est-ce devoirs?
  • stackoverflow.com/questions/2371436/...
  • pas vraiment sur le point, comme ceci (à la différence qu') exige de les jeter non-math parties de la chaîne.
  • Pourriez-vous utiliser 'I have {{ 6 * (2 + 3) }} apples' comme un format d'entrée?
  • cela pourrait bien fonctionner avec un bon remplacement pour le eval() fonction: codepad.org/QOhSpWzH
InformationsquelleAutor Arsen Manukyan | 2012-08-28
  1. 2

    Voici ma tentative:

    >>> import string
>>> s = 'I have 6 * (2+3) apples'
>>> symbols = '^*()/+-'
>>> formula = [(x,s.index(x)) for x in s if x in string.digits+symbols]
>>> result = eval(''.join(x[0] for x in formula), {'__builtins__':None})
>>> s = s[:formula[0][1]] + str(result) + s[formula[-1][1]+1:]
>>> s
'I have 30 apples'

    Notes:

    C'est très simple, il n'a pas affaire à des équations complexes - comme ceux avec racine carrée, pi, etc. mais je crois que c'est dans l'esprit de ce que la question est après. Pour un vraiment robuste réponse voir la question posté par jeffery_the_wind; mais je crois que c'est peut-être exagéré pour ce cas simpliste.

    InformationsquelleAutor Burhan Khalid
  2. 2

    Il est parfois préférable de simplifier la question plutôt que de venir avec des solutions. Vous pouvez simplifier le problème en faisant votre code sera fourni comme ce

    my_str='I have {6 * (2 + 3)} apples'

    De cette façon, vous pouvez l'analyser à l'aide d'une simple regex et eval ce qui est à l'intérieur. Sinon, vous êtes dans beaucoup de complexité.

    InformationsquelleAutor joelhoro
  3. 1

    C'est un très épineux problème qui est sans doute à peu près impossible à résoudre en général. Cependant, voici une façon simple de s'attaquer au problème, qui travaille avec l'exemple de l'entrée.

    *étape 1-désinfecter l'entrée. C'est la partie la plus difficile à faire en général. Fondamentalement, vous avez besoin d'un moyen de tirer une seule expression mathématique de la chaîne sans déformation d'elle. Ici une simple regex fonctionne:

    sanitized = re.sub(r'[a-zA-Z]','',my_str).strip()

    *étape 2-évaluer à l'aide de eval:

    value = eval(sanitized, {'__builtins__':None})

    *étape 3-arrière substitut

    new_string = my_str.replace(sanitized, str(value))
    • Eh bien, ce n'est pas qu'il ne peut pas être résolu en général. C'est mal définie problème tel qu'il est (ce qui constitue une expression à évaluer et ce qui ne l'est pas?) mais une fois que nous réalisons que vers le bas, il est facilement résolu, si vous avez réellement la peine d'analyser les choses au lieu d'abuser de eval.
    • si c'est eval abus, alors ce n'est pas eval abus (à quel point, il ne devrait pas être supprimée de la langue complètement?). Je pense que ceci est un bon endroit pour utiliser eval étant donné que le problème est limité suffisant pour analyser l'évaluation de l'expression de la chaîne d'entrée.
    • Pour ma part, je pense que eval ne doivent pas être placés bien en vue (c'est à dire dans l'espace de noms global). Je connais des cas d'utilisation pour compile et exec (et ils sont significativement différents de ce, dans ce qu'ils contrôlent la chaîne d'entrée de 100% et l'on sait ce qu'il va faire). Je n'ai pas encore rencontre un bon cas d'utilisation de eval -- lorsque vous souhaitez évaluer une expression mathématique, écrire une manœuvre de triage de l'évaluateur ou de quelque chose. Si vous souhaitez exécuter du code Python, utilisez exec parce que c'est moins restreint. Je n'ai pas l'éviter eval pour la correction, mais de ne pas mélanger les code avec les données. (Vis de l'lisp gars qui disent code de données).
    • écrivez votre propre manœuvre de triage de l'algorithme? Vraiment? Pourquoi passer par tout ce travail pour créer et déboguer quelque chose qui est déjà (visible) de la bibliothèque standard? Je comprends l'argument que vous ne savez pas ce que vous allez en sortir, mais c'est vrai dans une certaine mesure avec toute fonction en python en raison de canard-typage et la surcharge d'opérateur. Le moral est à mettre de bonnes entrées dans vos fonctions et vous aurez de bonnes choses à l'arrière. Notez aussi que ici '6 * ( 2 + 3 )' n'est pas le code. C'est une chaîne. Nous n'essayons pas de modifier le flux de programme ou quoi que ce soit...
    • De retour en bas, mon principal point est que de nombreuses définitions de ce qui devrait être évalué nécessitent peu plus de l'analyse (cf. les règles sur le moment où un * en reStructuredText est juste un personnage et non une majoration de construire). Et oui, 6 * ( 2 + 3 ) est une chaîne de caractères, et non pas une expression Python. C'est exactement pourquoi je m'oppose à la passant à eval. En outre, SY n'est pas très difficile à mettre en œuvre étant donné les détails des descriptions de celui-ci (je l'ai fait moi-même), et testé facilement. Il y a une limite raisonnable sur ce qui peut arriver avec une fonction comme ça, ou la plupart des autres fonctions. Avec eval etc., la seule limite est celle de Python.
    • Juste être prudent. Nous avons tous bu le "eval est mal" koolaid si longtemps, il est parfois difficile de prendre du recul et de réaliser que le python devs de le laisser là-bas pour une raison (surtout qu'il est utile). Comme tous les outils puissants (par exemple, de la dynamite, scies circulaires à table ...), vous devez manipuler avec soin, mais "avec eval la seule limite est celle de Python" n'est vrai que pour un nu eval. Si vous passez un globals dictionnaire, vous limitez l'espace de noms qui eval a accès à l'utilisation et (autant que je sache), vous pouvez même l'utiliser en toute sécurité (comme je l'ai démontré dans ma réponse). Mais de toute façon ...
    • Vous avez raison, la partie la plus difficile de ce problème est en fait de trouver les chaînes qui doivent être traités comme des expressions et qui ne sont que des chaînes de caractères. Après vous avez l'expression comme une chaîne de caractères sur son propre, il devient beaucoup plus facile. (soit en utilisant eval, pyparsing ou autre chose ... -- le problème est bien défini au moins.)
    • laissez-nous continuer cette discussion dans le chat

    InformationsquelleAutor mgilson
  4. 1

    Merci à tous pour votre aide. En fait, mon exemple fourni est très simple par rapport à ce que j'ai dans la tâche réelle. J'ai lu ces chaîne à partir d'un fichier et qu'il est parfois pouvez avoir vue comme ceci:

    my_str='ENC M6_finger_VNCAPa (AA SYZE BY (0.14*2)) < (0.12 + 0.07) OPPOSITE REGION'

    Équation mathématique sont simples, mais peuvent se produit de nombreuses fois dans une chaîne de caractères, et doivent être évalués séparément.

    Donc j'écris un exemple de code, qui est en mesure de gérer ce cas de figure:
    Peut-être qu'il n'est pas bon, mais de résoudre le problème:

    def eval_math_expressions(filelist):
        for line in filelist:
              if re.match('.*[\-|\+|\*|\/].*',line):
                        lindex=int(filelist.index(line))
                        line_list=line.split()
                        exp=[]
                        for word in line_list:
                                if re.match('^\(+\d+',word) or re.match('^[\)+|\d+|\-|\+|\*|\/]',word):
                                        exp.append(word)
                                else:
                                        ready=' '.join(exp)
                                        if ready:
                                                eval_ready=str(eval(ready))
                                                line_new=line.replace(ready,eval_ready)
                                                line=line_new
                                                filelist[lindex]=line
                                        exp=[]
        return filelist
    InformationsquelleAutor Arsen Manukyan
  5. 0

    Pour une solution sans l'utilisation d'eval, voici ce que je ferais. Commencez par trouver toutes les expressions mathématiques dans la chaîne, qui va me définir comme une chaîne de caractères qui contient des espaces, des parenthèses, des nombres et des opérations, puis d'en extraire les matchs qui sont tous les espaces:

    >>> import re
>>> my_str = 'I have 6 * (2 + 3) apples'
>>> exprs = list(re.finditer(r"[\d\.\s\*\+\-\/\(\)]+", my_str))
>>> exprs = [e for e in exprs if len(my_str[e.start():e.end()].strip()) > 0]

    Ensuite, évaluer les expressions à l'aide de la NumericStringParser classe de cette question, qui utilise pyparsing:

    >>> nsp = NumericStringParser()
>>> results = [nsp.eval(my_str[e.start():e.end()]) for e in exprs]
>>> results
[30.0]

    Alors, de remplacer les résultats dans l'expression, de tri inverse l'expression de l'indice de départ et remettez-les dans la chaîne d'origine:

    >>> new_str = my_str
>>> for expr, res in sorted(zip(exprs, results), key=lambda t: t[0].start(), reverse=True):
...     new_str = new_str[:expr.start()] + (" %d " % res) + new_str[expr.end():]
... 
>>> new_str
'I have 30 apples'
    InformationsquelleAutor jterrace
  6. 0

    Mon option:

    >>> import re
>>> def calc(s):
...     val = s.group()
...     if not val.strip(): return val
...     return " %s " % eval(val.strip(), {'__builtins__': None})
>>> re.sub(r"([0-9\ \.\+\*\-\/(\)]+)", calc, "I have 6 * (2 + 3 ) apples")
'I have 30 apples'
    InformationsquelleAutor Alexey Kachayev
  7. -1

    [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'I have {6 * (2 + 3)} apples'
=> 'I have 30 apples'
color = 'green'
f'I have {6 * (2 + 3)} {color} apples'
=> 'I have 30 green apples'
    InformationsquelleAutor shx2