python - 您如何仅在对象上下文中执行 python 'eval'？

Question

是否可以做类似的事情

c = MyObj()
c.eval("func1(42)+func2(24)")

在 Python 中...即在对象“c”的范围内评估 func1() 和 func2()(如果它们是该类定义中的成员函数)？我无法进行简单的解析，因为对于我的应用程序，eval 字符串可能变得任意复杂。我想用 ast 模块做一些魔术可能会成功，但由于 ast 的文献太少，我不确定去哪里找:

import ast

class MyTransformer(ast.NodeTransformer):
    def visit_Name(self, node):
        # do a generic_visit so that child nodes are processed
        ast.NodeVisitor.generic_visit(self, node)
        return ast.copy_location(
            # do something magical with names that are functions, so that they become 
            # method calls to a Formula object
            newnode,
            node
        )

class Formula(object):

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

    # we want to emulate something like Formula().eval(evalString)
    node = ast.parse(evalString, mode='eval')
    MyTransformer().visit(node)

    ast.fix_missing_locations(node)
    print eval(compile(node, '<string>', mode='eval'))    

Answer 1

您几乎肯定不想这样做，但您可以。

eval 的上下文是您要在其中评估代码的全局变量和局部变量字典。最常见的情况可能是 eval(expr, globals(), mycontext) 和 eval(expr, mycontext)，它们分别替换了默认的本地和全局上下文，而单独保留另一个。用对象的字典替换局部上下文类似于在该对象“内部”(方法)运行——尽管请记住，如果不这样做，“成为成员函数”并不会像您期望的那样好有一个 self 来调用其他成员函数......

无论如何，这是一个简单的例子:

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

请记住，__dict__ 可能不是您在这里想要的。例如:

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

为了按照您想要的方式进行这项工作，您必须确切地知道如何用 Python 术语来定义您想要的——这需要了解一些对象在幕后的工作方式(MRO，可能是描述符等)。

如果您确实需要 eval，并且您确实需要提供任意上下文，那么您最好明确地构建这些上下文(作为字典)，而不是试图强制对象扮演该角色:

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

无论如何，这种用法更接近于您尝试在 Python 中模拟的 Javascript 样式。

当然，与 JS 不同，Python 不允许在表达式中放置多行定义，因此对于复杂的情况，您必须这样做:

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

但可以说这几乎总是更具可读性(这基本上是 Python 不允许在表达式中进行多行定义的论点)。