Mam taką sytuację ...

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

Jak mogę uzyskać dostęp do Outermetody Innerklasy z poziomu klasy?

Metody klasy zagnieżdżonej nie mogą uzyskać bezpośredniego dostępu do atrybutów instancji klasy zewnętrznej.

Należy zauważyć, że niekoniecznie jest tak, że instancja klasy zewnętrznej istnieje, nawet jeśli utworzono instancję klasy wewnętrznej.

W rzeczywistości często odradza się używanie klas zagnieżdżonych, ponieważ zagnieżdżenie nie implikuje żadnego szczególnego związku między klasami wewnętrzną i zewnętrzną.

Próbujesz uzyskać dostęp do instancji klasy Outer z instancji klasy wewnętrznej. Po prostu użyj metody fabrycznej, aby zbudować instancję Inner i przekazać do niej instancję Outer.

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

może jestem szalony, ale wydaje się to rzeczywiście bardzo łatwe - chodzi o to, aby uczynić swoją wewnętrzną klasę metodą klasy zewnętrznej ...

def do_sthg( self ):
    ...

def messAround( self ):

    outerClassSelf = self

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

Poza tym ... „siebie” jest używane tylko w konwencji, więc możesz to zrobić:

def do_sthg( self ):
    ...

def messAround( outerClassSelf ):

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

Można by się sprzeciwić, że nie możesz wtedy stworzyć tej klasy wewnętrznej spoza klasy zewnętrznej ... ale to nieprawda:

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

wtedy gdzieś mile stąd:

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

nawet wypchnij trochę łódź i rozszerz tę klasę wewnętrzną (uwaga: aby super () działało, musisz zmienić sygnaturę klasy mooble na "class 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()

później

mrh1997 podniósł interesującą kwestię dotyczącą rzadkiego dziedziczenia klas wewnętrznych dostarczanych przy użyciu tej techniki. Ale wydaje się, że rozwiązanie jest dość proste:

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

Czy masz zamiar używać dziedziczenia zamiast zagnieżdżania klas w ten sposób? To, co robisz, nie ma sensu w Pythonie.

Możesz uzyskać dostęp do Outermetody some_method, odwołując się Outer.some_methoddo metod klasy wewnętrznej, ale nie będzie ona działać tak, jak się spodziewasz. Na przykład, jeśli spróbujesz tego:

class Outer(object):

    def some_method(self):
        # do something

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

... otrzymasz TypeError podczas inicjalizacji Innerobiektu, ponieważ Outer.some_methodoczekuje , że Outerjako pierwszy argument otrzyma instancję. (W powyższym przykładzie zasadniczo próbujesz wywołać some_methodjako metodę klasy Outer.)

Możesz łatwo uzyskać dostęp do zewnętrznej klasy za pomocą metaklasy: po utworzeniu klasy zewnętrznej sprawdź jej atrybut dict dla dowolnej klasy (lub zastosuj dowolną logikę, której potrzebujesz - mój to tylko trywialny przykład) i ustaw odpowiednie wartości:

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!

Korzystając z tego podejścia, możesz łatwo wiązać i odnosić się do dwóch klas między sobą.

Stworzyłem kod w Pythonie, aby używać zewnętrznej klasy z jej klasy wewnętrznej , w oparciu o dobry pomysł z innej odpowiedzi na to pytanie. Myślę, że jest krótki, prosty i łatwy do zrozumienia.

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}

Główny kod „do produkcji” (bez komentarzy itp.). Pamiętaj, aby zastąpić wszystkie wartości w nawiasach ostrych (np. <x>) Żądaną wartością.

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

Wyjaśnienie, jak działa ta metoda (podstawowe kroki):

1. Utwórz funkcję o nazwie, _subclass_containerktóra będzie działać jako opakowanie, aby uzyskać dostęp do zmiennej self, odwołanie do klasy wyższego poziomu (z kodu działającego wewnątrz funkcji).

   1. Utwórz zmienną o nazwie, _parent_classktóra jest odniesieniem do zmiennej selftej funkcji, do której podklasy _subclass_containermają dostęp (pozwala to uniknąć konfliktów nazw z innymi selfzmiennymi w podklasach).

   2. Zwróć podklasy / podklasy jako słownik / listę, aby kod wywołujący _subclass_containerfunkcję mógł uzyskać dostęp do podklas wewnątrz.

2. W __init__funkcji wewnątrz klasy wyższego poziomu (lub gdziekolwiek jest to potrzebne), odbierz zwrócone podklasy z funkcji _subclass_containerdo zmiennej subclasses.

3. Przypisz podklasy przechowywane w subclasseszmiennej do atrybutów klasy wyższego poziomu.

Kilka wskazówek ułatwiających scenariusze:

Ułatwienie kopiowania kodu przypisującego podklasy do klasy wyższego poziomu i używanie go w klasach pochodnych klasy wyższego poziomu, które mają __init__ funkcja została zmieniona:

Wstaw przed linią 12 w głównym kodzie:

def _subclass_init(self):

Następnie wstaw do tej funkcji wiersze 5-6 (głównego kodu) i zamień wiersze 4-7 na następujący kod:

self._subclass_init(self)

Umożliwienie przypisywania podklas do klasy wyższego poziomu, gdy istnieje wiele / nieznanych ilości podklas.

Zastąp wiersz 6 następującym kodem:

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

Przykładowy scenariusz, w którym to rozwiązanie byłoby przydatne i gdzie nie można uzyskać nazwy klasy wyższego poziomu:

Tworzona jest klasa o nazwie „a” ( class a:). Ma podklasy, które muszą mieć do niego dostęp (rodzic). Jedna podklasa nosi nazwę „x1”. W tej podklasie kod a.run_func()jest uruchamiany.

Następnie tworzona jest inna klasa o nazwie „b”, pochodząca z klasy „a” ( class b(a):). Następnie zostaje uruchomiony jakiś kod b.x1()(wywołanie funkcji podrzędnej „x1” z b, pochodnej podklasy). Ta funkcja działa a.run_func(), wywołując funkcję „run_func” klasy „a”, a nie funkcję „run_func” jej rodzica, „b” (tak jak powinna), ponieważ funkcja, która została zdefiniowana w klasie „a” ma odwoływać się do funkcji klasy „a”, ponieważ była ona jej rodzicem.

Spowodowałoby to problemy (np. Gdyby funkcja a.run_funczostała usunięta), a jedynym rozwiązaniem bez przepisywania kodu w klasie a.x1byłoby ponowne zdefiniowanie podklasy x1ze zaktualizowanym kodem dla wszystkich klas pochodzących z klasy „a”, co oczywiście byłoby trudne i niewarte to.

Znalazłem to .

Dostosowano do twojego pytania:

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)

Jestem pewien, że możesz jakoś napisać dekoratora do tego czy czegoś

powiązane: Jaki jest cel klas wewnętrznych Pythona?

Inna możliwość:

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

Rozwijając przekonujące myślenie @ tsnorri, że metoda zewnętrzna może być metodą statyczną :

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

Teraz dana linia powinna działać, zanim zostanie faktycznie wywołana.

Ostatni wiersz w powyższym kodzie podaje klasie Inner statyczną metodę będącą klonem statycznej metody Outer.

Wykorzystuje to dwie funkcje Pythona: funkcje są obiektami , a zakres jest tekstowy .

Zwykle zakres lokalny odwołuje się do lokalnych nazw (tekstowo) bieżącej funkcji.

... lub aktualna klasa w naszym przypadku. Zatem obiekty „lokalne” w stosunku do definicji klasy Outer ( Inneri some_static_method) mogą być odwoływane bezpośrednio w tej definicji.

Kilka lat spóźniłem się na imprezę ... ale aby rozwinąć @mike rodentwspaniałą odpowiedź, poniżej podałem własny przykład, który pokazuje, jak elastyczne jest jego rozwiązanie i dlaczego powinno (lub powinno być ) zaakceptowane odpowiedź.

Python 3.7.0

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

Wynik:

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

Ponownie, wspaniała odpowiedź, rekwizyty dla ciebie mikrofon!

To jest zbyt proste:

Wejście:

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

Wynik

klasa A func1

klasa B func1