exec（）字節碼與任意本地人？

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

從美國洛特的評論上面，我認爲我的想法，使用新創建的答案類。

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

其中change是一個元類，其__prepare__讀字典，其__new__更新字典。

重用，代碼段下面的工作，但它是一種醜惡：

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

increase_value(mydict) 

Answer 4

這是一個瘋狂的裝飾，以創建一個使用「定製機」這樣的塊。實際上，將函數內部的所有變量訪問權限轉換爲全局訪問權限並以自定義locals字典作爲環境來評估結果是一件很快捷的事情。

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