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

这段代码给出了随后的错误（Python 2.7.3），这让我感到惊讶：

结果：

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

enthund Python发行版——www.enthund.com
版本：7.3-2（64位）
Python 2.7.3 | EPD 7.3-2（64位）|（默认值，2012年4月11日，17:52:16）
linux2上的[GCC 4.1.2 20080704（Red Hat 4.1.2-44）]
键入“学分”、“演示”或“热情思考”以了解更多信息。
你好
>>>类Foo（对象）：
...     类栏（对象）：
...         通过
...     类别Baz（对象）：
...         类InnerBar（Bar）：
...             通过
...
回溯（最近一次呼叫最后一次）：
文件“”，第1行，在
文件“”，第4行，在Foo中
文件“”，第5行，在Baz中
NameError:未定义名称“Bar”

我怀疑这与等价的

Bar=type（…）

class

赋值的特定执行有关，但即便如此，为什么

Bar

在

Baz

中不能通过闭包实现呢

对于这种精确的实现，有没有办法解决这个问题（例如，我不想放松约束，

Bar

是

Foo

中定义的普通

类，而
Foo
中的类中的其他类可能希望从
Bar
继承）

我想到的一个特殊用例是模仿一些数据库结构，以进行更面向对象的设计，以反映数据服务项目中的模式。大部分代码是自动生成的Python，源于对XSD执行检查的程序，因此在类中定义类是模拟cer的自然方式有些关于XSD复杂类型的事情，但是还可以说它们是其他复杂类型的子类，等等。这就是为什么我不愿意将类拉到
Foo
之外以便以后继承的原因。
这里没有闭包。当执行嵌套代码时，类的主体不是父范围

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

见：

如果定义出现在功能块中，则范围将扩展到定义块中包含的任何块，除非包含的块为名称引入了不同的绑定。类块中定义的名称范围仅限于类块

我的

这里的工作是使用嵌套函数生成可访问的范围：

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（对象）：
…def product_嵌套_scope（）：
…类栏（对象）：
…通过
…类Baz（对象）：
…类内部条（条）：
…通过
…回程吧，巴兹
…Bar，Baz=product_嵌套_scope（）
…删除生成嵌套范围
... 
>>>富吧
>>>福巴兹
这里有一个可怕的黑客攻击：

class Foo(object):
    def hack(dest):
        class Bar(object):
            pass
        class Baz(object):
            class InnerBar(Bar):
                pass

        dest.update(locals())
    hack(locals())

>>Foo.Bar
>>>Foo.Baz.InnerBar
我仍然非常不确定为什么
Bar
和
Baz
在本地名称空间中没有完全发生文档化的过程，在本地名称空间中，
Foo
正在执行套件。在任何本地名称中，
Foo
之前的
Foo
是一个绑定名称，在该名称空间中，why将不会完成所有的
Bar
套件，然后
Bar
绑定到该命名空间中，然后执行所有
Baz
套件（包括
InnerBar
，它可以查找一个命名空间级别以查找
Bar
，因为
Bar
将绑定到该命名空间中），然后
Foo
完成并绑定？我缺少什么？@EMS:啊，我今天缺少咖啡因。我以为你在
Foo
中使用
Foo
。我读错了。不，类名称空间不是用于查找其他名称的作用域。
Bar
无法找到，因为
Foo
套件不是父作用域。
>>> 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'>

class Foo(object):
    def hack(dest):
        class Bar(object):
            pass
        class Baz(object):
            class InnerBar(Bar):
                pass

        dest.update(locals())
    hack(locals())

>>> Foo.Bar
<class '__main__.Bar'>
>>> Foo.Baz.InnerBar
<class '__main__.InnerBar'>