Question

我想动态构造一个闭包的封闭环境的命名空间，使闭包内的代码可以访问这个动态内容。以下是说明我的问题的最简单的玩具示例：

def f():
    exec("Y=7",locals())    
    def closure():
        v=eval("Y*2")
        return v  
    return closure

当我使用此代码时，会发生以下情况：

In [21]: Q = f()

In [22]: Q
Out[22]: <function __main__.closure>

In [23]: Q()
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-23-51e72ed661f9> in <module>()
----> 1 Q()

<ipython-input-20-a47050c4450a> in closure()
      3
      4     def closure():
----> 5         return eval("Y*2")
      6
      7     return closure

<string> in <module>()

NameError: name 'Y' is not defined

所以，在这种情况下，使用＆＃34; exec＆＃34;添加绑定变量＆＃34; Y＆＃34;到关闭的环境不起作用。但是，由于嵌套函数，我也不能使用裸exec。

我考虑使用globals（）而不是locals（）：

def f():
    exec("Y=7",globals())

    def closure():
        return eval("Y*2")

    return closure

## -- End pasted text --

In [27]: Q=f()

In [28]: Q
Out[28]: <function __main__.closure>

In [29]: Q()
Out[29]: 14

所以，这解决了我眼前的问题，但如果我做了＃34; exec＆＃34;块有可变值吗？例如，如果我改变f（）将不同的值分配给Y，我们就会遇到一个新问题：

def f(z):
    exec("Y="+str(z),globals())

    def closure():
        return eval("Y*2")

    return closure

## -- End pasted text --

In [33]: Q=f(2)

In [34]: Q
Out[34]: <function __main__.closure>

In [35]: Q()
Out[35]: 4

In [36]: G=f(4)

In [37]: G()
Out[37]: 8

In [38]: Q()
Out[38]: 8 #doh!

所以，我需要的是一种获得绑定变量的方法＆＃34; Y＆＃34;位于闭包/函数环境的命名空间中，而不是位于＆＃34; local（）＆＃34; （无论是什么）或＆＃34; global（）＆＃34;，由于上述问题。

似乎＆＃34; exec＆＃34;无法在此特定上下文中执行。我需要执行封闭本身吗？这似乎有效。

def f(z):
    exec("Y="+str(z),locals())

    exec("def closure():\n return Y*2",locals())

    return eval("closure")

## -- End pasted text --

In [50]: G=f(3)

In [51]: G()
Out[51]: 6

In [52]: Q=f(5)

In [53]: Q()
Out[53]: 10

In [54]: G()
Out[54]: 6

In [55]: Q()
Out[55]: 10 #:-)

现在，如果我有一个更复杂的Y对象，如函数？

def f(z,args):
  exec("Y= lambda " + args[0] + ","+args[1]+":"+args[0]+"*2+"+args[1]+"*3",locals())

  exec("def closure(x,y):\n return z*Y(x,y)",locals())

  return eval("closure")

## -- End pasted text --

In [64]: Q=f(2,['a','b'])

In [65]: Q(2,2)
Out[65]: 20

In [68]: G=f(3,['a','b'])

In [69]: G(2,-1)
Out[69]: 3

In [70]: Q(2,2)
Out[70]: 20

这似乎也有效。

然而，我想知道是否有一种更优雅的方式来动态构建一个封闭环境。

我正在使用2.7.7

的IPython

Python 2.7.11 |Anaconda 2.4.0 (64-bit)| (default, Jan 19 2016, 12:08:31) [MSC v.1500 64 bit (AMD64)]
Type "copyright", "credits" or "license" for more information.

IPython 4.0.0 -- An enhanced Interactive Python.
?         -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help      -> Python's own help system.
object?   -> Details about 'object', use 'object??' for extra details.

In [1]: exec("x=2")

In [2]: x
Out[2]: 2

In [3]:

Answer 1

你不能在Python 2或3中以这种方式进行闭包;无论您尝试eval，closure等多少，Python编译器都没有在closure的任何周围函数范围中看到变量赋值，这意味着{ {1}}将在全局范围内查找Y。

您可以使用dis.dis验证这一点，字节代码将使用LOAD_GLOBAL来访问所有“闭包”变量。

您需要exec一次def f(z):...的整个代码{/ 1}}。

后两个例子似乎有用，但是这个例子：

def f(z):
    exec("Y="+str(z),locals())
    exec("def closure():\n return Y*2",locals())
    return eval("closure")

只会将locals()用作globals到exec - 这也不是正确的关闭。您正在编译绑定到其自己的全局环境的新函数实例，而不是闭包。

可以用更加傻瓜的方式编写相同的代码

def f(z):
    globs = {'Y': z}
    exec('def closure():\n return Y*2', globs)
    return globs['closure']

如何动态构造一个闭包的命名空间＆＃34; pythonically＆＃34;

1 个答案: