python嵌套类(内部类相互调用)_在python中从内部类访问外部类

也许我很生气，但这看起来确实很简单-问题是让你的内部类在外部类的方法中。。。def do_sthg( self ):

...

def messAround( self ):

outerClassSelf = self

class mooble():

def do_sthg_different( self ):

...

outerClassSelf.do_sthg()

另外……”“self”仅用于约定，因此您可以这样做：def do_sthg( self ):

...

def messAround( outerClassSelf ):

class mooble():

def do_sthg_different( self ):

...

outerClassSelf.do_sthg()

可能会有人反对你不能从外部类创建这个内部类。。。但这不是真的：class Bumblebee():

def do_sthg( self ):

print "sthg"

def giveMeAnInnerClass( outerClassSelf ):

class mooble():

def do_sthg_different( self ):

print "something diff\n"

outerClassSelf.do_sthg()

return mooble

然后，在几英里之外的某个地方：blob = Bumblebee().giveMeAnInnerClass()()

blob.do_sthg_different()

甚至把船推出一点并扩展这个内部类(NB要获得super()才能工作，您必须将mooble的类签名更改为“类mooble(object)”class InnerBumblebeeWithAddedBounce( Bumblebee().giveMeAnInnerClass() ):

def bounce( self ):

print "bounce"

def do_sthg_different( self ):

super( InnerBumblebeeWithAddedBounce, self ).do_sthg_different()

print "and more different"

ibwab = InnerBumblebeeWithAddedBounce()

ibwab.bounce()

ibwab.do_sthg_different()

稍后

mrh1997提出了一个有趣的观点，即使用这种技术交付的内部类的非公共继承。但解决方案似乎非常简单：class Fatty():

def do_sthg( self ):

pass

class InnerFatty( object ):

pass

def giveMeAnInnerFattyClass(self):

class ExtendedInnerFatty( Fatty.InnerFatty ):

pass

return ExtendedInnerFatty

fatty1 = Fatty()

fatty2 = Fatty()

innerFattyClass1 = fatty1.giveMeAnInnerFattyClass()

innerFattyClass2 = fatty2.giveMeAnInnerFattyClass()

print ( issubclass( innerFattyClass1, Fatty.InnerFatty ))

print ( issubclass( innerFattyClass2, Fatty.InnerFatty ))