Python 从内部类访问外部类方法

我想要一个具有嵌套类的python类，其中内部类可以访问外部类的成员。我知道正常嵌套甚至不需要外部类有一个实例。我有一些代码，似乎可以产生我想要的结果，我想要关于风格和不可预见的复杂性的反馈

代码：

输出：

>>> a = A(5)
>>> b = a.B()
>>> b.out()
5
>>> a.x = 7
>>> b.out()
7

---

因此，A有一个内部类B，它只能从A的实例创建。然后B可以通过父变量访问A的所有成员。

这对我来说不是很好

classBdef

是一个类工厂方法。通常（而且很少）您会使用这些来创建自定义类，例如带有自定义超类的类：

def class_factory(superclass):
    class CustomClass(superclass):
        def custom_method(self):
            pass
    return CustomClass

但是您的构造没有使用自定义。事实上，它把A的东西放进B，然后把它们紧密地结合在一起。如果B需要了解某个变量，则使用参数进行方法调用，或使用对A对象的引用实例化B对象

除非有特定的原因或问题需要解决，否则只使用一个普通的工厂方法，在a中提供一个

B

对象，而不是像

B=a.B（）

这样的东西，会更容易、更清晰

---

我认为你想做的不是一个好主意。python中的“内部”类与其“外部”类绝对没有特殊关系，如果您费心在另一个类中定义一个类的话。说得一模一样：

class A(object):
    class B(object):
        pass

也就是说：

class B(object): pass
class A(object): pass
A.B = B
del B

也就是说，通过在元类上定义

\uuu get\uu（）

，将“内部”类变成一个描述符，就可以完成您所描述的内容。我建议不要这样做——这太复杂了，效益也不大

class ParentBindingType(type):
    def __get__(cls, inst, instcls):
        return type(cls.__name__, (cls,), {'parent': inst})
    def __repr__(cls):
        return "<class '%s.%s' parent=%r>" % (cls.__module__, 
            cls.__name__, getattr(cls, 'parent', None))

class B(object):
    __metaclass__ = ParentBindingType
    def out(self):
        print self.parent.x

class A(object):
    _B = B
    def __init__(self,x):
        self.x = x
        self.B = self._B

a = A(5)
print a.B
b = a.B()
b.out()
a.x = 7
b.out()

类ParentBindingType（类型）：
定义获取（cls、inst、instcls）：
返回类型（cls.\uuuuu name.\uuuuuu，（cls，），{'parent'：inst}）
定义报告（cls）：
返回“%”（cls.\u模块，
cls.\uuuuu name\uuuuuuuuu，getattr（cls，'父'，无））
B类（对象）：
__元类\父绑定类型
def输出（自我）：
打印self.parent.x
A类（对象）：
_B=B
定义初始化（self，x）：
self.x=x
self.B=self.\u B
a=a（5）
打印a.B
b=a.b（）
b、 out（）
a、 x=7
b、 out（）

印刷：

<class '__main__.B' parent=<__main__.A object at 0x85c90>>
5
7

5.
7.

是否有理由要求仅从a内部创建B的实例？类继承似乎是实现这一点的一种更简单的方法。

class ParentBindingType(type):
    def __get__(cls, inst, instcls):
        return type(cls.__name__, (cls,), {'parent': inst})
    def __repr__(cls):
        return "<class '%s.%s' parent=%r>" % (cls.__module__, 
            cls.__name__, getattr(cls, 'parent', None))

class B(object):
    __metaclass__ = ParentBindingType
    def out(self):
        print self.parent.x

class A(object):
    _B = B
    def __init__(self,x):
        self.x = x
        self.B = self._B

a = A(5)
print a.B
b = a.B()
b.out()
a.x = 7
b.out()

<class '__main__.B' parent=<__main__.A object at 0x85c90>>
5
7