Question

假设我想执行代码，例如

    value += 5

在我自己的命名空间内（所以结果基本上是mydict['value'] += 5）。有一个函数exec()，但我必须在那里传递一个字符串：

    exec('value += 5', mydict)

并将语句作为字符串传递似乎很奇怪（例如，它没有以这种方式着色）。可以这样做：

    def block():
        value += 5

    ???(block, mydict)

？最后一行的明显候选人是exec(block.__code__, mydict)，但没有运气：它提出UnboundLocalError关于value。我相信它基本上执行block()，而不是块内的代码，因此分配并不容易 - 这是正确的吗？

当然，另一种可能的解决方案是反汇编block.__code__ ......

仅供参考，我因this thread而得到了这个问题。此外，这就是为什么有些人（我未定）要求新语法

    using mydict: 
        value += 5

注意这不会引发错误，但也不会改变mydict：

    def block(value = 0):
        value += 5

    block(**mydict)

Answer 1

您可以将字节码而不是字符串传递给exec，您只需要为此目的制作正确的字节码：

>>> bytecode = compile('value += 5', '<string>', 'exec')
>>> mydict = {'value': 23}
>>> exec(bytecode, mydict)
>>> mydict['value']
28

具体来说，......：

>>> import dis
>>> dis.dis(bytecode)
  1           0 LOAD_NAME                0 (value)
              3 LOAD_CONST               0 (5)
              6 INPLACE_ADD         
              7 STORE_NAME               0 (value)
             10 LOAD_CONST               1 (None)
             13 RETURN_VALUE

加载和存储说明必须是_NAME说服，而compile使它们成为这样，而......：

>>> def f(): value += 5
... 
>>> dis.dis(f.func_code)
  1           0 LOAD_FAST                0 (value)
              3 LOAD_CONST               1 (5)
              6 INPLACE_ADD         
              7 STORE_FAST               0 (value)
             10 LOAD_CONST               0 (None)
             13 RETURN_VALUE

...函数中的代码已经过优化，可以使用_FAST版本，而这些代码不适用于传递给exec的字典。如果你使用_FAST指令以某种方式开始使用字节码，你可以修改它以使用_NAME类型，例如使用bytecodehacks或类似方法。

Answer 2

使用global关键字强制在块中修改要修改的任何变量：

def block():
    global value
    value += 5

mydict = {"value": 42}
exec(block.__code__, mydict)
print(mydict["value"])

Answer 3

这是一个疯狂的装饰者来创建这样一个使用“自定义本地人”的块。实际上，将函数内的所有变量访问权限转换为全局访问权限并使用自定义本地化字典作为环境评估结果是一种快速入侵。

import dis
import functools
import types
import string

def withlocals(func):
    """Decorator for executing a block with custom "local" variables.

    The decorated function takes one argument: its scope dictionary.

    >>> @withlocals
    ... def block():
    ...     counter += 1
    ...     luckynumber = 88

    >>> d = {"counter": 1}
    >>> block(d)
    >>> d["counter"]
    2
    >>> d["luckynumber"]
    88
    """
    def opstr(*opnames):
        return "".join([chr(dis.opmap[N]) for N in opnames])

    translation_table = string.maketrans(
            opstr("LOAD_FAST", "STORE_FAST"),
            opstr("LOAD_GLOBAL", "STORE_GLOBAL"))

    c = func.func_code
    newcode = types.CodeType(c.co_argcount,
                             0, # co_nlocals
                             c.co_stacksize,
                             c.co_flags,
                             c.co_code.translate(translation_table),
                             c.co_consts,
                             c.co_varnames, # co_names, name of global vars
                             (), # co_varnames
                             c.co_filename,
                             c.co_name,
                             c.co_firstlineno,
                             c.co_lnotab)

    @functools.wraps(func)
    def wrapper(mylocals):
        return eval(newcode, mylocals)
    return wrapper

if __name__ == '__main__':
    import doctest
    doctest.testmod()

这只是对某人goto decorator

精彩配方的修补。

Answer 4

从S.Lott上面的评论中我认为我可以通过创建新类来获得答案。

class _(__metaclass__ = change(mydict)):
    value += 1
    ...

其中change是一个元类，其__prepare__读取字典，其__new__更新字典。

为了重复使用，下面的代码段可行，但它有点难看：

def increase_value(d):
    class _(__metaclass__ = change(d)):
        value += 1
        ...

increase_value(mydict)

exec（）字节码与任意本地？

4 个答案: