是否可以定义javastyle（非静态）内部类（在类范围内）

Question

对于那些不熟悉java的人来说，非静态内部类是这样的类，在这些类中，对象引用了创建它的外部对象

当然，这可以在python中通过在构造函数中创建类来实现。例如：

>>> class Outer:
...    def __init__(self):
...        class inner:
...            _outer = self
...        self.Inner = Inner

>>> outer = Outer()
>>> inner = outer.Inner()
>>> outer
<__main__.Outer object at 0x7f61f9d8e978>
>>> inner._outer
<__main__.Outer object at 0x7f61f9d8e978>

我试图用一种更像Java的方式来定义它，在类主体中定义它。例如：

def nonstatic(cls):
    def ctor(*args, **kwds):
        return cls(*args, **kwds)
    return ctor

class Outer:
    @nonstatic
    class Inner:
         pass

哪种方法可行，但不是很灵活的解决方案。例如Outer（）.Inner只是一个构造函数而不是一个类型。这也意味着该解决方案将禁止从内部类继承

现在的问题是，有没有一个解决方案可以在那一点上定义它？或者这样的尝试注定会以某种方式失败？我倾向于认为这是注定的，但我想一个论点，为什么这是（或只是将是混乱？）

我没有提到它，但我正在寻找一种解决方案，其中内部类可以用外部对象作为隐式参数实例化，就像方法一样（即outer = inner.Outer()）

Answer 1

我不太清楚，为什么要嵌套类或用隐式参数实例化内部类。请记住Zen of Python：

...
Explicit is better than implicit.
Simple is better than complex.
...

你能详细说明一个用例吗

---

因为我认为你的例子不需要嵌套，你可以简单地使用

class Inner:
    def __init__(self, outer: 'Outer') -> None:
        self.outer = outer

class Outer:
    def create_inner(self) -> Inner:
        return Inner(self)

outer = Outer()
inner = outer.create_inner()

# or
inner = Inner(outer)

后者的好处是，如果您可以使用另一个Inner类（由于duck typing或继承），而无需修改Outer类

class NewInner(Inner):
    ...

outer = Outer()
inner = NewInner(outer)