你是如何制作python的'；评估'；仅在对象上下文中？

有可能做像这样的事情吗

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

导入ast
MyTransformer类（ast.NodeTransformer）：
def visit_名称（自身、节点）：
#执行常规的_访问，以便处理子节点
ast.NodeVisitor.generic_访问（self，node）
返回ast.copy\u位置(
#用函数名做一些神奇的事情，使它们成为
#方法调用公式对象
新节点，
节点
)
类公式（对象）：
左侧def（自身、s、n）：
返回s[：n]
def右侧（自身、s、n）：
返回s[0-n:]
def CONCAT（自身，*args，**kwargs）：
返回“”。加入（[arg代表args中的arg]）
def main（）：
evalString=“CONCAT（左（'Hello'，2），右（'World'，3））”
#我们想要模拟类似于Formula（）.eval（evalString）的东西
node=ast.parse（evalString，mode='eval'）
MyTransformer（）。访问（节点）
修复缺少的位置（节点）
打印eval（编译（节点“”，模式='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

请记住，

\uuu dict\uuu

可能不是您想要的。例如：

>>> 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不允许在表达式中使用多行定义的原因）。

您可以看看这个问题的公认答案：

这对我创建自己的上下文是一种很有帮助的方法，在这种上下文中，矩形数组上的数学操作（如Python Pandas数据帧）可以“正常工作”，而无需麻烦处理难看的额外Pandas语法。例如，当我在上下文中写入“

a=x*y

”时，它会自动将

a

指定为上下文对象的属性，并且知道如何使用上下文对象的

x

和

y

属性执行向量操作

我发现这个上下文内容非常有用，尽管事实上，每当我问StackOverflow时，我经常会得到恶作剧般的回答，那一定不是我真正想做的

---

在

eval

查找函数的上下文中，您可能也可以使用它。

因此，我建议您执行以下操作：

>>> class S(object):
...     def add(self, a, b):
...         return a + b
... 
>>> filter(lambda (k,v): not k.startswith("__"), S.__dict__.items())
[('add', <function add at 0x109cec500>)]
>>> target = S()
>>> map(lambda (k, f): (k, f.__get__(target, S)), filter(lambda (k,v): not k.startswith("__"), S.__dict__.items()))
[('add', <bound method S.add of <__main__.S object at 0x109ce4ed0>>)]
>>> dict(_)
{'add': <bound method S.add of <__main__.S object at 0x109ce4ed0>>}
>>> eval("add(45, 10) + add(10, 1)", _, {})
66

>>类S（对象）：
...     def添加（自身、a、b）：
...         返回a+b
... 
>>>过滤器（lambda（k，v）：不是k.startswith（“_uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu
[（'add'，）]
>>>target=S（）
>>>映射（lambda（k，f）：（k，f.uuu获取uuu（目标，S）），过滤器（lambda（k，v）：非k.startswith（“uuu”）、S.uu dict_uuu.items（））
[（'add'，）]
>>>口述
{'add'：}
>>>评估（“添加（45，10）+添加（10，1）”，{}
66

看来你需要。让我解释一下它是如何工作的

eval

接受局部变量和全局变量作为参数

所以我们需要定义特殊的全局上下文，它将是类的“表示”

为此，我们需要提供所有“有价值的”有界方法的as

globals

字典

从简单的部分开始。我们有

S

类定义。如何获得所有“有价值”的方法？简单的

过滤器
名称来自
S.\uuuu dict\uuuuu
，以检查方法名称是否从
\uuuuuuu
开始（您可以看到，结果是我们得到一个带有1项的列表-
add
函数）

创建

target

=将成为“eval context”的

S

类的实例

下一步是最“棘手”的。我们需要从每个函数创建“绑定方法”。为了做到这一点，我们使用了这样的事实，类

\uuuuu dict\uuuuuuu

存储函数，每个函数都是非数据描述符，并且可以使用

func简单地获取有界方法。此操作在
map
中执行

从上一步中获取结果，从中创建

dict

作为

globals

传递到

eval

函数

---

我希望这会有所帮助。

上面提出的填充

局部变量的解决方案在大多数情况下都很有效，但在属性（数据描述符）的情况下可能会出现问题。在填充字典时，将对其进行一次计算。这意味着对同一个变量名的多个引用将始终retu
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()