Tengo una situación así ...

class Outer(object):

    def some_method(self):
        # do something

    class Inner(object):
        def __init__(self):
            self.Outer.some_method()    # <-- this is the line in question

¿Cómo puedo acceder al Outermétodo de la Innerclase desde la clase?

Los métodos de una clase anidada no pueden acceder directamente a los atributos de instancia de la clase externa.

Tenga en cuenta que no es necesariamente el caso de que exista una instancia de la clase externa incluso cuando haya creado una instancia de la clase interna.

De hecho, a menudo se recomienda no usar clases anidadas, ya que el anidamiento no implica ninguna relación particular entre las clases internas y externas.

Estás intentando acceder a la instancia de clase de Outer, desde la instancia de clase interna. Así que solo use el método de fábrica para construir una instancia interna y pasarle una instancia externa.

class Outer(object):

    def createInner(self):
        return Outer.Inner(self)

    class Inner(object):
        def __init__(self, outer_instance):
            self.outer_instance = outer_instance
            self.outer_instance.somemethod()

        def inner_method(self):
            self.outer_instance.anothermethod()

tal vez estoy enojado, pero esto parece muy fácil de hecho: la cuestión es hacer que su clase interna dentro de un método de la clase externa ...

def do_sthg( self ):
    ...

def messAround( self ):

    outerClassSelf = self

    class mooble():
        def do_sthg_different( self ):
            ...
            outerClassSelf.do_sthg()

Además ... "self" solo se usa por convención, por lo que puede hacer esto:

def do_sthg( self ):
    ...

def messAround( outerClassSelf ):

    class mooble():
        def do_sthg_different( self ):
            ...
            outerClassSelf.do_sthg()

Se podría objetar que luego no puede crear esta clase interna desde fuera de la clase externa ... pero esto no es cierto:

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

luego, en algún lugar a millas de distancia:

blob = Bumblebee().giveMeAnInnerClass()()
blob.do_sthg_different()    

incluso empuje un poco el bote y extienda esta clase interna (NB para que super () funcione, debe cambiar la firma de clase de mooble a "class mooble (objeto)"

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()

luego

mrh1997 planteó un punto interesante sobre la herencia no común de clases internas entregadas mediante esta técnica. Pero parece que la solución es bastante sencilla:

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 ))

¿Quiere usar la herencia en lugar de anidar clases como esta? Lo que estás haciendo no tiene mucho sentido en Python.

Puede acceder a Outersome_method simplemente haciendo referencia Outer.some_methoddentro de los métodos de la clase interna, pero no va a funcionar como espera. Por ejemplo, si prueba esto:

class Outer(object):

    def some_method(self):
        # do something

    class Inner(object):
        def __init__(self):
            Outer.some_method()

... obtendrá un TypeError al inicializar un Innerobjeto, porque Outer.some_methodespera recibir una Outerinstancia como primer argumento. (En el ejemplo anterior, básicamente está intentando llamar some_methodcomo un método de clase de Outer).

Puede acceder fácilmente a la clase externa usando metaclase: después de la creación de la clase externa, verifique su atributo dict para cualquier clase (o aplique cualquier lógica que necesite, el mío es solo un ejemplo trivial) y establezca los valores correspondientes:

import six
import inspect


# helper method from `peewee` project to add metaclass
_METACLASS_ = '_metaclass_helper_'
def with_metaclass(meta, base=object):
    return meta(_METACLASS_, (base,), {})


class OuterMeta(type):
    def __new__(mcs, name, parents, dct):
        cls = super(OuterMeta, mcs).__new__(mcs, name, parents, dct)
        for klass in dct.values():
            if inspect.isclass(klass):
                print("Setting outer of '%s' to '%s'" % (klass, cls))
                klass.outer = cls

        return cls


# @six.add_metaclass(OuterMeta) -- this is alternative to `with_metaclass`
class Outer(with_metaclass(OuterMeta)):
    def foo(self):
        return "I'm outer class!"

    class Inner(object):
        outer = None  # <-- by default it's None

        def bar(self):
            return "I'm inner class"


print(Outer.Inner.outer)
>>> <class '__main__.Outer'>
assert isinstance(Outer.Inner.outer(), Outer)

print(Outer().foo())
>>> I'm outer class!
print(Outer.Inner.outer().foo())
>>> I'm outer class!
print(Outer.Inner().outer().foo())
>>> I'm outer class!
print(Outer.Inner().bar())
>>> I'm inner class!

Con este enfoque, puede vincular y referir fácilmente dos clases entre sí.

He creado un código Python para usar una clase externa de su clase interna , basado en una buena idea de otra respuesta para esta pregunta. Creo que es breve, simple y fácil de entender.

class higher_level__unknown_irrelevant_name__class:
    def __init__(self, ...args...):
        ...other code...
        # Important lines to access sub-classes.
        subclasses = self._subclass_container()
        self.some_subclass = subclasses["some_subclass"]
        del subclasses # Free up variable for other use.

    def sub_function(self, ...args...):
        ...other code...

    def _subclass_container(self):
        _parent_class = self # Create access to parent class.
        class some_subclass:
            def __init__(self):
                self._parent_class = _parent_class # Easy access from self.
                # Optional line, clears variable space, but SHOULD NOT BE USED
                # IF THERE ARE MULTIPLE SUBCLASSES as would stop their parent access.
                #  del _parent_class
        class subclass_2:
            def __init__(self):
                self._parent_class = _parent_class
        # Return reference(s) to the subclass(es).
        return {"some_subclass": some_subclass, "subclass_2": subclass_2}

El código principal, "listo para producción" (sin comentarios, etc.). Recuerde reemplazar todos los valores entre corchetes angulares (por ejemplo <x>) con el valor deseado.

class <higher_level_class>:
    def __init__(self):
        subclasses = self._subclass_container()
        self.<sub_class> = subclasses[<sub_class, type string>]
        del subclasses

    def _subclass_container(self):
        _parent_class = self
        class <sub_class>:
            def __init__(self):
                self._parent_class = _parent_class
        return {<sub_class, type string>: <sub_class>}

Explicación de cómo funciona este método (los pasos básicos):

1. Cree una función nombrada _subclass_containerpara actuar como un contenedor para acceder a la variable self, una referencia a la clase de nivel superior (del código que se ejecuta dentro de la función).

   1. Cree una variable nombrada _parent_classque sea una referencia a la variable selfde esta función, a la que _subclass_containerpuedan acceder las selfsubclases de (evita conflictos de nombre con otras variables en subclases).

   2. Devuelve la subclase / subclases como un diccionario / lista para que el código que llame a la _subclass_containerfunción pueda acceder a las subclases internas.

2. En la __init__función dentro de la clase de nivel superior (o donde sea necesario), reciba las subclases devueltas de la función _subclass_containeren la variable subclasses.

3. Asignar subclases almacenadas en la subclassesvariable a atributos de la clase de nivel superior.

Algunos consejos para facilitar los escenarios:

Haciendo que el código para asignar las subclases a la clase de nivel superior sea más fácil de copiar y usar en clases derivadas de la clase de nivel superior que tienen su __init__ función cambiada:

Inserte antes de la línea 12 en el código principal:

def _subclass_init(self):

Luego inserte en esta función las líneas 5-6 (del código principal) y reemplace las líneas 4-7 con el siguiente código:

self._subclass_init(self)

Hacer posible la asignación de subclases a la clase de nivel superior cuando hay muchas / desconocidas cantidades de subclases.

Reemplace la línea 6 con el siguiente código:

for subclass_name in list(subclasses.keys()):
    setattr(self, subclass_name, subclasses[subclass_name])

Escenario de ejemplo en el que esta solución sería útil y donde el nombre de clase de nivel superior debería ser imposible de obtener:

Se class a:crea una clase, denominada "a" ( ). Tiene subclases que necesitan acceder a él (el padre). Una subclase se llama "x1". En esta subclase, a.run_func()se ejecuta el código .

Luego se crea otra clase, llamada "b", derivada de la clase "a" ( class b(a):). Después de eso, se ejecuta algún código b.x1()(llamando a la subfunción "x1" de b, una subclase derivada). Esta función se ejecuta a.run_func(), llamando a la función "run_func" de la clase "a", no a la función "run_func" de su padre, "b" (como debería), porque la función que se definió en la clase "a" está configurada para referirse a la función de la clase "a", ya que era su padre.

Esto causaría problemas (por ejemplo, si a.run_funcse ha eliminado la función) y la única solución sin reescribir el código en la clase a.x1sería redefinir la subclase x1con código actualizado para todas las clases derivadas de la clase "a", lo que obviamente sería difícil y no valdría la pena. eso.

Encontré esto .

Modificado para adaptarse a su pregunta:

class Outer(object):
    def some_method(self):
        # do something

    class _Inner(object):
        def __init__(self, outer):
            outer.some_method()
    def Inner(self):
        return _Inner(self)

Estoy seguro de que de alguna manera puedes escribir un decorador para esto o algo.

relacionado: ¿Cuál es el propósito de las clases internas de Python?

Otra posibilidad:

class _Outer (object):
    # Define your static methods here, e.g.
    @staticmethod
    def subclassRef ():
        return Outer

class Outer (_Outer):
    class Inner (object):
        def outer (self):
            return _Outer

        def doSomething (self):
            outer = self.outer ()
            # Call your static mehthods.
            cls = outer.subclassRef ()
            return cls ()

Ampliando el pensamiento convincente de @ tsnorri, que el método externo puede ser un método estático :

class Outer(object):

    @staticmethod
    def some_static_method(self):
        # do something

    class Inner(object):
        def __init__(self):
            self.some_static_method()    # <-- this will work later

    Inner.some_static_method = some_static_method

Ahora la línea en cuestión debería funcionar en el momento en que realmente se llame.

La última línea del código anterior le da a la clase Inner un método estático que es un clon del método estático Outer.

Esto aprovecha dos características de Python, que las funciones son objetos y el alcance es textual .

Por lo general, el ámbito local hace referencia a los nombres locales de la función actual (textualmente).

... o clase actual en nuestro caso. Así que los objetos "locales" a la definición de la clase Outer ( Innery some_static_method) pueden ser referidos directamente dentro de esa definición.

Unos años tarde para la fiesta ... pero para ampliar @mike rodentla maravillosa respuesta, he proporcionado mi propio ejemplo a continuación que muestra cuán flexible es su solución y por qué debería ser (o debería haber sido) la aceptada. responder.

Python 3.7

class Parent():

    def __init__(self, name):
        self.name = name
        self.children = []

    class Inner(object):
        pass

    def Child(self, name):
        parent = self
        class Child(Parent.Inner):
            def __init__(self, name):
                self.name = name
                self.parent = parent
                parent.children.append(self)
        return Child(name)



parent = Parent('Bar')

child1 = parent.Child('Foo')
child2 = parent.Child('World')

print(
    # Getting its first childs name
    child1.name, # From itself
    parent.children[0].name, # From its parent
    # Also works with the second child
    child2.name,
    parent.children[1].name,
    # Go nuts if you want
    child2.parent.children[0].name,
    child1.parent.children[1].name
)

print(
    # Getting the parents name
    parent.name, # From itself
    child1.parent.name, # From its children
    child2.parent.name,
    # Go nuts again if you want
    parent.children[0].parent.name,
    parent.children[1].parent.name,
    # Or insane
    child2.parent.children[0].parent.children[1].parent.name,
    child1.parent.children[1].parent.children[0].parent.name
)


# Second parent? No problem
parent2 = Parent('John')
child3 = parent2.Child('Doe')
child4 = parent2.Child('Appleseed')

print(
    child3.name, parent2.children[0].name,
    child4.name, parent2.children[1].name,
    parent2.name # ....
)

Salida:

Foo Foo World World Foo World
Bar Bar Bar Bar Bar Bar Bar
Doe Doe Appleseed Appleseed John

Una vez más, una maravillosa respuesta, ¡apoyos para ti, Mike!

Es demasiado simple:

Entrada:

class A:
    def __init__(self):
        pass

    def func1(self):
        print('class A func1')

    class B:
        def __init__(self):
            a1 = A()
            a1.func1()

        def func1(self):
            print('class B func1')

b = A.B()
b.func1()

Salida

clase A func1

clase B func1