python - 可以从嵌套类定义实现继承吗？

Question

令我惊讶的是这段代码给出了后续错误(Python 2.7.3):

class Foo(object):
    class Bar(object):
        pass
    class Baz(object):
        class InnerBar(Bar):
            pass

结果:

Enthought Python Distribution -- www.enthought.com
Version: 7.3-2 (64-bit)

Python 2.7.3 |EPD 7.3-2 (64-bit)| (default, Apr 11 2012, 17:52:16)
[GCC 4.1.2 20080704 (Red Hat 4.1.2-44)] on linux2
Type "credits", "demo" or "enthought" for more information.
Hello
>>> class Foo(object):
...     class Bar(object):
...         pass
...     class Baz(object):
...         class InnerBar(Bar):
...             pass
...
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 4, in Foo
  File "<stdin>", line 5, in Baz
NameError: name 'Bar' is not defined

我怀疑这与等效的 Bar = type(...) class 赋值的特定执行有关，但即便如此，为什么不呢？ t Bar 通过 Baz 中的闭包变得可用？

对于这种精确的实现，有没有办法解决这个问题(例如，我不想放松 Bar 是一个普通的 class 定义的约束在 Foo 中，并且 Foo 中的类中的其他类可能希望继承自 Bar。

我想到的特定用例是模仿某些数据库结构，以进行更加面向对象的设计，以反射(reflect)数据服务项目中的架构。大部分代码是从对 XSD 执行检查的程序派生的自动生成的 Python，因此在类中定义类是模拟 XSD 复杂类型的某些事情的自然方式，但还增加了说明它们何时是的子项的能力其他复杂类型等。这就是为什么我犹豫是否要在 Foo 之外拉一个类以供以后继承。

Answer 1

这里没有关闭。执行嵌套代码时，类的主体不是父作用域。

就嵌套作用域中的代码而言，只有全局作用域和局部作用域存在，Foo 类主体不是可以访问的命名空间。

参见 Naming and Binding documentation :

If the definition occurs in a function block, the scope extends to any blocks contained within the defining one, unless a contained block introduces a different binding for the name. The scope of names defined in a class block is limited to the class block

强调我的。

这里的解决方法是使用嵌套函数来生成一个可以访问的范围:

class Foo(object):
    def produce_nested_scope():
        class Bar(object):
            pass
        class Baz(object):
            class InnerBar(Bar):
                pass
        return Bar, Baz
    Bar, Baz = produce_nested_scope()
    del produce_nested_scope

演示:

>>> class Foo(object):
...     def produce_nested_scope():
...         class Bar(object):
...             pass
...         class Baz(object):
...             class InnerBar(Bar):
...                 pass
...         return Bar, Baz
...     Bar, Baz = produce_nested_scope()
...     del produce_nested_scope
... 
>>> Foo.Bar
<class '__main__.Bar'>
>>> Foo.Baz
<class '__main__.Baz'>