python - (Python) 意外创建的闭包

Question

创建嵌套类时出现意外的关闭。我怀疑这与元类、 super 或两者有关。这肯定与闭包的创建方式有关。我使用的是python2.7。

这里有五个简化的示例，演示了我所看到的相同问题(它们都是基于第一个示例):

示例 1:

class Metaclass(type): 
    def __init__(self, name, bases, dict): 
        self.CONST = 5 

class Base(object): 
    __metaclass__=Metaclass 
    def __init__(self): 
        "Set things up." 

class Subclass(Base):
    def __init__(self, name):
        super(Subclass, self).__init__(self)
        self.name = name
    def other(self, something): pass

class Test(object):
    def setup(self):
        class Subclass(Base):
            def __init__(self, name):
                super(Subclass, self).__init__(self)
                self.name = name
            def other(self, something): pass
        self.subclass = Subclass
        class Subclass2(Base):
            def __init__(self, name):
                super(Subclass, self).__init__(self)
        self.subclass2 = Subclass2

"0x%x" % id(Metaclass)
# '0x8257f74'
"0x%x" % id(Base)
# '0x825814c'
t=Test()
t.setup()
"0x%x" % id(t.subclass)
# '0x8258e8c'
"0x%x" % id(t.subclass2)
# '0x825907c'
t.subclass.__init__.__func__.__closure__
# (<cell at 0xb7d33d4c: Metaclass object at 0x8258e8c>,)
t.subclass.other.__func__.__closure__
# None
t.subclass2.__init__.__func__.__closure__
# (<cell at 0xb7d33d4c: Metaclass object at 0x8258e8c>,)
Subclass.__init__.__func__.__closure__
# None

示例 2:

class Test2(object):
    def setup(self):
        class Subclass(Base):
            def __init__(self, name):
                self.name = name
            def other(self, something): pass
        self.subclass = Subclass

t2=Test2()
t2.setup()
t2.subclass.__init__.__func__.__closure__
# None

示例 3:

class Test3(object):
    def setup(self):
        class Other(object):
            def __init__(self): 
                super(Other, self).__init__()
        self.other = Other
        class Other2(object):
            def __init__(self): pass
        self.other2 = Other2

t3=Test3()
t3.setup()
"0x%x" % id(t3.other)
# '0x8259734'
t3.other.__init__.__func__.__closure__
# (<cell at 0xb7d33e54: type object at 0x8259734>,)
t3.other2.__init__.__func__.__closure__
# None

示例 4:

class Metaclass2(type): pass

class Base2(object): 
    __metaclass__=Metaclass2 
    def __init__(self): 
        "Set things up." 

class Base3(object): 
    __metaclass__=Metaclass2 

class Test4(object):
    def setup(self):
        class Subclass2(Base2):
            def __init__(self, name):
                super(Subclass2, self).__init__(self)
        self.subclass2 = Subclass2
        class Subclass3(Base3):
            def __init__(self, name):
                super(Subclass3, self).__init__(self)
        self.subclass3 = Subclass3
        class Subclass4(Base3):
            def __init__(self, name):
                super(Subclass4, self).__init__(self)
        self.subclass4 = Subclass4

"0x%x" % id(Metaclass2)
# '0x8259d9c'
"0x%x" % id(Base2)
# '0x825ac9c'
"0x%x" % id(Base3)
# '0x825affc'
t4=Test4()
t4.setup()
"0x%x" % id(t4.subclass2)
# '0x825b964'
"0x%x" % id(t4.subclass3)
# '0x825bcac'
"0x%x" % id(t4.subclass4)
# '0x825bff4'
t4.subclass2.__init__.__func__.__closure__
# (<cell at 0xb7d33d04: Metaclass2 object at 0x825b964>,)
t4.subclass3.__init__.__func__.__closure__
# (<cell at 0xb7d33e9c: Metaclass2 object at 0x825bcac>,)
t4.subclass4.__init__.__func__.__closure__
# (<cell at 0xb7d33ddc: Metaclass2 object at 0x825bff4>,)

示例 5:

class Test5(object):
    def setup(self):
        class Subclass(Base):
            def __init__(self, name):
                Base.__init__(self)
        self.subclass = Subclass

t5=Test5()
t5.setup()
"0x%x" % id(t5.subclass)
# '0x8260374'
t5.subclass.__init__.__func__.__closure__
# None

这是我的理解(引用示例):

• 元类是继承的，因此Subclass获取Base的元类。
• 仅__init__受到影响，Subclass.other方法不是(#1)。
• 正在删除 Subclass.other没有什么区别(#1)。
• 正在删除 self.name=name来自Subclass.__init__没有什么区别(#1)。
• 闭包单元中的对象不是函数。
• 该对象不是 Metaclass或Base ，但是一些 Metaclass 类型的对象，就像 Base是(#1)。
• 该对象实际上是嵌套 Subclass 类型的对象(#1)。
• t1.subclass.__init__ 的闭合单元和t1.subclass2.__init__是相同的，即使它们来自两个不同的类 (#1)。
• 当我不嵌套创建Subclass时(#1) 那么就没有创建闭包。
• 当我不打电话时super(...).__init__在Subclass.init__没有创建闭包(#2)。
• 如果我分配 no __metaclass__并继承自object然后会出现相同的行为(#3)。
• t3.other.__init__ 闭包单元中的对象是 t3.other (#3)。
• 如果元类没有__init__，也会发生相同的行为(#4)。
• 如果 Base 也会发生相同的行为没有__init__ (#4)。
• 示例 4 中的三个子类的闭包单元均不同，并且每个都与相应的类 (#4) 匹配。
• 何时 super(...).__init__替换为 Base.__init__(self) ，闭包消失(#5)。

这是我不明白的地方:

• 为什么要为 __init__ 设置闭包？
• 为什么没有为其他设置关闭？
• 为什么闭包单元中的对象设置为 __init__ 所属的类属于？
• 为什么只有在 super(...).__init__ 时才会发生这种情况？被称为？
• 为什么当 Base.__init__(self) 时不会发生这种情况？被称为？
• 这实际上与使用元类有任何关系吗(可能是因为默认元类是 type )？

感谢您的帮助!

-埃里克

(更新)这是我当时发现的一些东西(基于 Jason 的见解):

def something1():
    print "0x%x" % id(something1)
    def something2():
        def something3():
            print "0x%x" % id(something1)
            print "0x%x" % id(something2)
            print "0x%x" % id(something3)
        return something3
    return something2

something1.__closure__
# None
something1().__closure__
# 0xb7d4056c
# (<cell at 0xb7d33eb4: function object at 0xb7d40df4>,)
something1()().__closure__
# 0xb7d4056c
# (<cell at 0xb7d33fec: function object at 0xb7d40e64>, <cell at 0xb7d33efc: function object at 0xb7d40e2c>)
something1()()()
# 0xb7d4056c
# 0xb7d4056c
# 0xb7d40e9c
# 0xb7d40ed4

首先，函数的名称位于其自身范围内。其次，如果函数引用了定义它们的函数，则函数会获得这些函数的闭包。

我没有意识到函数名称在这样的范围内。类(class)也是如此。当在函数作用域内定义类时，类方法内对该类名的任何引用都会导致该类绑定(bind)在该方法函数的闭包中，如下所示:

def test():
    class Test(object):
        def something(self):
            print Test
    return Test

test()
# <class '__main__.Test'>
test().something.__func__.__closure__
# (<cell at 0xb7d33c2c: type object at 0x825e304>,)

但是，由于无法在非函数上创建闭包，因此以下操作会失败:

def test():
    class Test(object):
        SELF=Test
        def something(self):
            print Test
    return Test

# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
#   File "<stdin>", line 2, in test
#   File "<stdin>", line 3, in Test
# NameError: free variable 'Test' referenced before assignment in enclosing scope

好东西!

Answer 1

Why does a closure get set for __init__?

它引用封闭函数(即setup)中的局部变量(即Subclass)。

Why doesn't the closure get set for other?

因为它不引用任何封闭函数中的任何局部变量(或参数)。

Why is the object in the closure cell set to the class to which __init__ belongs?

这是所引用的封闭变量的值。

Why does this only happen when super(...).__init__ is called?

Why doesn't this happen when Base.__init__(self) is called?

因为 Base 不是任何封闭函数中的局部变量。

Does this actually have anything at all to do with using metaclasses?

没有。