Comment voulez-vous faire un python 'eval' que dans un contexte de l'objet?

Vous avez presque certainement ne voulez pas le faire, mais vous peut.

Le contexte de eval est les variables globales et locales des dictionnaires que vous voulez évaluer votre code. Les cas les plus courants sont probablement eval(expr, globals(), mycontext) et eval(expr, mycontext), remplacez la valeur par défaut des contextes locaux et mondiaux, respectivement, en laissant l'autre seul. En remplaçant le contexte local d'un objet dictionnaire est similaire à l'exécution de "l'intérieur" (méthode de) cet objet—bien garder à l'esprit que d'être un membre de la fonction" ne pas faire autant de bien que vous pourriez vous attendre si vous n'avez pas de self pour appeler d'autres fonctions membre sur...

De toute façon, voici un exemple rapide:

>>> class Foo(object):
...     def __init__(self):
...         self.bar = 3
>>> foo = Foo()
>>> eval('a', globals(), foo.__dict__)
3

Gardez à l'esprit que __dict__ peut ne pas être exactement ce que vous voulez ici. Par exemple:

>>> class Foo(object):
...     @staticmethod
...     def bar():
...         return 3
>>> foo = Foo()
>>> eval('bar()', globals(), foo.__dict__)
NameError: name 'bar' is not defined
>>> eval('bar()', globals(), {k: getattr(foo, k) for k in dir(foo)}
3

Pour faire ce travail de la manière que vous voulez, vous devez savoir exactement comment définissez vous le souhaitez, en Python termes—qui nécessite de connaître un peu plus sur la manière dont les objets travaille sous les couvertures (MRO, peut-être descripteurs, etc.).

Si vous avez vraiment besoin eval, et vous avez vraiment besoin pour fournir de l'arbitraire des contextes, vous êtes probablement mieux de construction de ces explicitement les contextes (comme les dictionnaires) plutôt que d'essayer de forcer les objets dans ce rôle:

>>> foo = {
...     'bar': lambda: 3
... }
>>> eval('bar()', globals(), foo)

Cette utilisation est beaucoup plus proche du style Javascript que vous essayez d'imiter en Python de toute façon.

Bien sûr, à la différence de JS, Python ne permet pas de mettre de multiples définitions de ligne à l'intérieur d'une expression, donc, pour les cas complexes que vous avez à faire cela:

>>> def bar():
...     return 3
>>> foo = {
...     'bar': bar
... }
>>> eval('bar()', globals(), foo)

Mais sans doute que c'est presque toujours plus lisible (qui est en fait l'argument derrière Python ne permettant pas de multi-définitions de ligne dans des expressions).

OriginalL'auteur abarnert

La solution proposée ci-dessus pour remplir locals fonctionne bien dans la plupart des cas, mais peut être problématique dans le cas de propriétés (données de descripteurs). Celles-ci sont évaluées une fois lorsque le dictionnaire est rempli. Cela signifie que plusieurs références pour le même nom de variable retournera toujours exactement la même instance, qui peut ne pas être le comportement attendu dans le cas de propriétés.

Ce problème peut être résolu en notant que eval s'attend à un locals argument que se comporte comme un dict (par opposition aux variables globales, qui doit être un dict). En d'autres termes, nous pouvons remplacer __getitem__ dans votre instance pour résoudre les noms de variables à la volée dans le cadre de l'instance et de passer directement comme locals attribut eval. Votre exemple peut donc être mis en œuvre comme:

class Formula(object):
    def __getitem__(self, key):
        if key not in dir(self) or key.startswith('__'):
            raise KeyError(key)
        return getattr(self, key)

    def LEFT(self, s, n):
        return s[:n]

    def RIGHT(self, s, n):
        return s[0-n:]

    def CONCAT(self, *args, **kwargs):
        return ''.join([arg for arg in args])


def main():
    evalString = "CONCAT(LEFT('Hello', 2), RIGHT('World', 3))"
    print eval(evalString, {}, Formula())

if __name__ == "__main__":
    main()

Cette astuce devrait travailler avec l'héritage, les méthodes statiques, les méthodes de la classe et de propriétés. Enfin, à l'aide de dir et getattr évite le besoin d'interagir directement avec __dict__ ou __mro__, bien que les résultats de dir peut pas toujours complet.

OriginalL'auteur nrtc