Захваченные переменные в "eval" в Python

У меня возникли проблемы с пониманием семантики "eval()" и "exec" в Python. (Весь код в этом вопросе ведет себя аналогично в Python 2.7.8 и Python 3.4.2). документация для "eval" говорит:

Если оба [locals и globals] опущены, выражение выполняется в среде, где вызывается eval().

Аналогичный язык для "exec". Я явно не понимаю этого предложения, потому что я ожидал бы, что четыре функции, определенные следующей программой, будут делать то же самое.

def h(x):
    ls = locals()
    exec('def i(y): return (w, x, y)', globals(), ls)
    i = ls['i']
    def       j(y): return (w, x, y)
    k = eval('lambda y: (w, x, y)')
    l =       lambda y: (w, x, y)
    return i, j, k, l

w = 1

i, j, k, l = h(2)

Они не делают.

>>> i(3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1, in i
NameError: name 'x' is not defined
>>> j(3)
(1, 2, 3)
>>> k(3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1, in <lambda>
NameError: name 'x' is not defined
>>> l(3)
(1, 2, 3)

Разборка кода показывает, почему: "x" рассматривается как глобальная переменная с помощью "eval" и "exec".

from dis import dis
print("This is `i`:")
dis(i)
print("This is `j`:")
dis(j)
print("This is `k`:")
dis(k)
print("This is `l`:")
dis(l)
print("For reference, this is `h`:")
dis(h)

Вывод:

This is `i`:
  1           0 LOAD_GLOBAL              0 (w)
              3 LOAD_GLOBAL              1 (x)
              6 LOAD_FAST                0 (y)
              9 BUILD_TUPLE              3
             12 RETURN_VALUE        
This is `j`:
 25           0 LOAD_GLOBAL              0 (w)
              3 LOAD_DEREF               0 (x)
              6 LOAD_FAST                0 (y)
              9 BUILD_TUPLE              3
             12 RETURN_VALUE        
This is `k`:
  1           0 LOAD_GLOBAL              0 (w)
              3 LOAD_GLOBAL              1 (x)
              6 LOAD_FAST                0 (y)
              9 BUILD_TUPLE              3
             12 RETURN_VALUE        
This is `l`:
 27           0 LOAD_GLOBAL              0 (w)
              3 LOAD_DEREF               0 (x)
              6 LOAD_FAST                0 (y)
              9 BUILD_TUPLE              3
             12 RETURN_VALUE        
For reference, this is `h`:
 22           0 LOAD_NAME                0 (locals)
              3 CALL_FUNCTION            0
              6 STORE_FAST               1 (ls)

 23           9 LOAD_CONST               1 ('def i(y): return (w, x, y)')
             12 LOAD_NAME                1 (globals)
             15 CALL_FUNCTION            0
             18 LOAD_FAST                1 (ls)
             21 EXEC_STMT           

 24          22 LOAD_FAST                1 (ls)
             25 LOAD_CONST               2 ('i')
             28 BINARY_SUBSCR       
             29 STORE_FAST               2 (i)

 25          32 LOAD_CLOSURE             0 (x)
             35 BUILD_TUPLE              1
             38 LOAD_CONST               3 (<code object j at 0x7ffc3843c030, file "test.py", line 25>)
             41 MAKE_CLOSURE             0
             44 STORE_FAST               3 (j)

 26          47 LOAD_NAME                2 (eval)
             50 LOAD_CONST               4 ('lambda y: (w, x, y)')
             53 CALL_FUNCTION            1
             56 STORE_FAST               4 (k)

 27          59 LOAD_CLOSURE             0 (x)
             62 BUILD_TUPLE              1
             65 LOAD_CONST               5 (<code object <lambda> at 0x7ffc3843c3b0, file "test.py", line 27>)
             68 MAKE_CLOSURE             0
             71 STORE_FAST               5 (l)

 28          74 LOAD_FAST                2 (i)
             77 LOAD_FAST                3 (j)
             80 LOAD_FAST                4 (k)
             83 LOAD_FAST                5 (l)
             86 BUILD_TUPLE              4
             89 RETURN_VALUE

Вопрос

"j" и "l" выше имеют поведение, которое я хочу. Как я могу получить это поведение с помощью "eval" или "exec"?

Отказ 1

Использование класса вместо функции, поскольку внешняя оболочка меняет семантику, но в противоположность желаемому пути. Он превращает "x" в глобальный.

class H:
    x = 2
    f = staticmethod(eval('lambda y: (w, x, y)'))

H.dis(H.f)

w = 1
H.f(3)

Вывод:

  1           0 LOAD_GLOBAL              0 (w)
              3 LOAD_GLOBAL              1 (x)
              6 LOAD_FAST                0 (y)
              9 BUILD_TUPLE              3
             12 RETURN_VALUE        
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1, in <lambda>
NameError: global name 'x' is not defined

Обтекание "classmethod" или отказ от него как метода несвязанного экземпляра просто ухудшают ситуацию.

Отказ 2

Подстановка "x" с использованием строковой интерполяции для целых чисел:

def h(x):
    return eval('lambda y: (w, %r, y)' % x)

k = h(2)

dis(k)

w = 1
k(3)

Вывод:

  1           0 LOAD_GLOBAL              0 (w)
              3 LOAD_CONST               1 (2)
              6 LOAD_FAST                0 (y)
              9 BUILD_TUPLE              3
             12 RETURN_VALUE        
(1, 2, 3)

Однако я не хочу предполагать, что "x" можно без потерь преобразовать в строку и обратно. Попытка разбита в следующих примерах:

k = h(lambda: "something")

k = h(open('some_file', 'w'))

cell = ["Wrong value"]
k = h(cell)
cell[0] = "Right value"
k(3)

Отказ 3

Поскольку Python ищет глобальную переменную, одна очевидная попытка - передать "x" в качестве глобальной переменной:

def h(x):
    my_globals = {'w': w, 'x': x}
    return eval('lambda y: (w, x, y)', my_globals)

k = h(2)

dis(k)

w = 1
k(3)

Вывод:

  1           0 LOAD_GLOBAL              0 (w)
              3 LOAD_GLOBAL              1 (x)
              6 LOAD_FAST                0 (y)
              9 BUILD_TUPLE              3
             12 RETURN_VALUE        
(1, 2, 3)

Эта попытка нарушена, потому что она слишком рано считывает значение "w":

w = "Wrong value"
k = h(2)
w = "Right value"
k(3)

Успех 1

В конце концов я нашел подход, который работает, но мне это действительно не нравится:

def h(x):
    return eval('lambda x: lambda y: (w, x, y)')(x) 

k = h(2)

dis(k)

w = 1
k(3)

Вывод:

  1           0 LOAD_GLOBAL              0 (w)
              3 LOAD_DEREF               0 (x)
              6 LOAD_FAST                0 (y)
              9 BUILD_TUPLE              3
             12 RETURN_VALUE
(1, 2, 3)

В частности, это станет болезненным, если я не знаю полный список локальных переменных, захваченных строкой, которую я передаю в "eval" .

Можете ли вы сделать лучше?

Обновление 2014-12-25

Отказ 4

Ищем больше способов создания локальной переменной "x" , я пробовал это:

def h(x):
    ls = locals()
    exec('x = x\ndef i(y): return (w, x, y)', globals(), ls)
    exec('_ = x\ndef j(y): return (w, x, y)', globals(), ls)
    return ls['i'], ls['j'], ls['_'], ls['x']

i, j, check1, check2 = h(2)

assert check1 == 2
assert check2 == 2

w = 1

print("This is `i`:")
dis(i)
print("This is `j`:")
dis(j)

print("i(3) = %r" % (i(3),))
print("j(3) = %r" % (j(3),))

Дополнительное назначение "x" не влияет. Утверждения подтверждают, что "x" находится в словаре локальных жителей, но он не захватывается лямбдами. Вот результат:

This is `i`:
  2           0 LOAD_GLOBAL              0 (w)
              3 LOAD_GLOBAL              1 (x)
              6 LOAD_FAST                0 (y)
              9 BUILD_TUPLE              3
             12 RETURN_VALUE
This is `j`:
  2           0 LOAD_GLOBAL              0 (w)
              3 LOAD_GLOBAL              1 (x)
              6 LOAD_FAST                0 (y)
              9 BUILD_TUPLE              3
             12 RETURN_VALUE

Вызов "i" и "j" приводит к сбою, жалуясь на отсутствие глобальной переменной "x" .

Успех 2

[Edit 2014-12-29: Это удается только для Python 3.]

Другой способ создания локальной переменной:

def h(x):
    i = eval('[lambda y: (w, x, y) for x in [x]][0]')
    j = eval('[lambda y: (w, x, y) for _ in [x]][0]')
    return i, j

i, j = h(2)

w = 1

print("This is `i`:")
dis(i)
print("This is `j`:")
dis(j)

print("i(3) = %r" % (i(3),))
print("j(3) = %r" % (j(3),))

Странно, в этом случае дополнительное присвоение "x" действительно имеет эффект. Это работает, то есть "i" отличается от "j". Вот результат:

This is `i`:
  1           0 LOAD_GLOBAL              0 (w)
              3 LOAD_DEREF               0 (x)
              6 LOAD_FAST                0 (y)
              9 BUILD_TUPLE              3
             12 RETURN_VALUE
This is `j`:
  1           0 LOAD_GLOBAL              0 (w)
              3 LOAD_GLOBAL              1 (x)
              6 LOAD_FAST                0 (y)
              9 BUILD_TUPLE              3
             12 RETURN_VALUE
i(3) = (1, 2, 3)

Вызов "j" выдается из строя, жалуясь на отсутствие глобального "x" , но "i" работает по желанию и имеет правильный байт-код.

Почему это работает, а "Failure 4" выше нет? Каково правило, которое определяет, можно ли захватить локальное "x" ? И какова история этого дизайна? (Это кажется абсурдным!)

ОТВЕТЫ

Ответ 1

Я думаю, вы хотите, чтобы ваши созданные функции наследовали локальную среду создаваемой ими функции, а также реальную глобальную среду (функции, которая их создает). То почему вы не любите их ссылаясь на x как глобальное, право?

Далее создается функция "обертка" вокруг желаемой функции, все внутри одной и той же строки exec. Значения локалей создаваемых функций передаются при вызове или повторном вызове оболочки, создавая новое завернутое закрытие.

Код чувствителен к новым переменным, создаваемым в контексте locals. Для некоторых проблем необходимо убедиться, что имена функций и оболочек известны и имеют значения.

def wrap_f(code, gs, ls, wrapper_name, function_name):
    ls[function_name] = ls[wrapper_name] = None
    arglist = ",".join(ls.keys())
    wrapcode = """
def {wrapper_name}({arglist}):
{code}
    return {function_name}
    """.format(wrapper_name=wrapper_name, arglist=arglist, 
               code=code, function_name=function_name)
    exec(wrapcode, gs, ls)
    wrapper = ls[wrapper_name]
    return wrapper, wrapper(**ls)

Итак, чтобы ответить на исходный вопрос, этот код...

def h(x):
    mcode = "    def m(y): return (w, x, y)"  # must be indented 4 spaces.
    mwrap, m = wrap_f(mcode, globals(), locals(), "mwrap", "m")
    return m

w = 1
m = h(2)
print m(3)

... производит этот вывод:

(1, 2, 3)

И этот пример показывает, что делать, когда изменяются локали в функции создателя:

def foo(x):
    barleycode = """
    def barley(y):
        print "barley x =", x
        print "barley y =", y
    """
    barleywrap, barley = wrap_f(barleycode, globals(), locals(), 
                               "barleywrap", "barley")
    barley("this string")
    print

    x = "modified x"
    barley = barleywrap(**locals())
    barley("new arg")
    print

    x = "re-modified x"
    barley("doesn't see the re-mod.")

x = "the global x"

foo("outer arg")

Это приводит к выходу:

barley x = outer arg
barley y = this string

barley x = modified x
barley y = new arg

barley x = modified x
barley y = doesn't see the re-mod.

Ответ 2

Я не уверен, что у меня все получилось, но я постараюсь изо всех сил: Я думаю, когда вы запускаете eval/exec python, он не понимает, что он внутри функции, я действительно не знаю почему. То, что я попытаюсь сделать, это использовать строку формата, подобную этой

k = eval("lambda y: (w, {0}, y)".format(x))

Я не уверен, что эта штука работает. Кроме того, почему вам нужно использовать eval и exec таким образом?