Comment accéder à une classe externe à partir d'une classe interne ?

Question

J'ai une situation comme ça...

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

Comment puis-je accéder au Outer de la méthode de la classe Inner classe ?

Answer 1

En développant la pensée convaincante de @tsnorri, que la méthode extérieure peut être une méthode statique :

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

Maintenant, la ligne en question devrait fonctionner au moment où elle est effectivement appelée.

La dernière ligne du code ci-dessus donne à la classe Inner une méthode statique qui est un clone de la méthode statique Outer.

---

Cela permet de tirer parti de deux fonctionnalités de Python, à savoir les fonctions sont des objets y la portée est textuelle .

En général, la portée locale fait référence aux noms locaux de la fonction (textuelle) en cours.

...ou actuel classe dans notre cas. Ainsi, les objets "locaux" à la définition de la classe Outer ( Inner y some_static_method ) peuvent être mentionnés directement dans cette définition.

Answer 2

Vous pouvez créer une classe, pour décorer les classes internes. Dans ce cas, @inner.

Puisque c'est un décorateur : Outer.A = inner(Outer.A). Si votre code nécessite Outer.A, il sera exécuté. inner.__get__ qui renvoie la classe originale (A) avec un nouvel attribut défini sur elle : A.owner = Outer.

Une méthode de classe dans la classe A, dans ce cas-ci def add(cls, y=3) peut utiliser un nouvel attribut owner à l'adresse return cls.owner.x + y + 1 .

La ligne setattr(owner, name, self.inner) , casse le descripteur car owner.name => Outer.A => A n'est plus une instance de la classe inner.

J'espère que cela vous aidera.

    class inner:

        def __init__(self, inner):
            self.inner = inner

        def __get__(self, instance, owner):
            print('__get__ method executed, only once... ')
            name = self.inner.__name__
            setattr(self.inner, 'owner', owner) 
            setattr(owner, name, self.inner) # breaks descriptor
            return self.inner #returns Inner

    class Outer:
        x = 1

        @inner
        class A:

            @classmethod
            def add(cls, y=3):
                return cls.owner.x + y + 1

    print(Outer.A.add(0)) # First time executes inner.__get__ method
    print(Outer.A.add(0)) # Second time not necessary.

    >> __get__ method executed, only once... 
    >> 2
    >> 2

Answer 3

C'est trop simple :

Entrée :

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

Sortie

classe A func1

classe B func1