Методы вложенного класса не могут напрямую обращаться к атрибутам экземпляра внешнего класса.

Обратите внимание, что экземпляр внешнего класса не обязательно существует, даже если вы создали экземпляр внутреннего класса.

На самом деле, часто не рекомендуется использовать вложенные классы, поскольку вложенность не предполагает какой-либо конкретной связи между внутренним и внешним классами.

Вы пытаетесь получить доступ к экземпляру класса 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()

может быть, я злюсь, но это действительно кажется очень простым - дело в том, чтобы сделать ваш внутренний класс внутри метода внешнего класса...

def do_sthg( self ):
    ...

def messAround( self ):

    outerClassSelf = self

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

Плюс... "я" используется только по соглашению, поэтому вы можете сделать это:

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

даже немного подтолкните лодку и расширьте этот внутренний класс (обратите внимание, чтобы заставить super() работать, вам нужно изменить сигнатуру класса mooble на «класс mooble (объект)»

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

Я нашел это.

Изменено, чтобы удовлетворить ваш вопрос:

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)

Я уверен, что вы можете как-то написать декоратор для этого или что-то в этом роде

связанные: Какова цель внутренних классов python? < /а>

Вы можете легко получить доступ к внешнему классу с помощью метакласса: после создания внешнего класса проверьте его атрибут dict для любых классов (или примените любую логику, которая вам нужна - мой пример просто тривиальный) и установите соответствующие значения:

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!

Используя этот подход, вы можете легко связывать и ссылаться между двумя классами.

Я создал код Python для использования внешнего класса из его внутреннего класса, основываясь на хорошей идее другого ответ на этот вопрос. Я думаю, что это коротко, просто и понятно.

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}

Основной код, "продакшен" (без комментариев и т.д.). Не забудьте заменить все значения в угловых скобках (например, <x>) нужным значением.

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

Объяснение того, как работает этот метод (основные шаги):

1. Создайте функцию с именем _subclass_container, которая будет выступать в качестве оболочки для доступа к переменной self, ссылке на класс более высокого уровня (из кода, выполняемого внутри функции).

   1. Создайте переменную с именем _parent_class, которая является ссылкой на переменную self этой функции, к которой могут обращаться подклассы _subclass_container (чтобы избежать конфликтов имен с другими переменными self в подклассах).

   2. Верните подкласс/подклассы в виде словаря/списка, чтобы код, вызывающий функцию _subclass_container, мог получить доступ к подклассам внутри.

2. В функции __init__ внутри класса более высокого уровня (или где еще необходимо) получить возвращенные подклассы из функции _subclass_container в переменную subclasses.

3. Назначьте подклассы, хранящиеся в переменной subclasses, атрибутам класса более высокого уровня.

Несколько советов, как упростить сценарии:

Упрощено копирование кода для назначения подклассов классу более высокого уровня и его использование в классах, производных от класса более высокого уровня, у которых __init__ изменена функция:

Вставьте перед строкой 12 основного кода:

def _subclass_init(self):

Затем вставьте в эту функцию строки 5-6 (основного кода) и замените строки 4-7 следующим кодом:

self._subclass_init(self)

Создание возможности присвоения подкласса классу более высокого уровня, когда имеется много/неизвестное количество подклассов.

Замените строку 6 следующим кодом:

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

Пример сценария, где это решение было бы полезно и где имя класса более высокого уровня должно быть невозможно получить:

Создается класс с именем "a" (class a:). У него есть подклассы, которым необходимо получить к нему доступ (родительский). Один подкласс называется "x1". В этом подклассе запускается код a.run_func().

Затем создается другой класс с именем "b", производный от класса "a" (class b(a):). После этого какой-то код запускает b.x1() (вызывая подфункцию "x1" из b, производного подкласса). Эта функция запускает a.run_func(), вызывая функцию "run_func" класса "a", а не функцию "run_func" своего родителя, "b" (как следует), потому что функция, которая была определена в класс "a" установлен для ссылки на функцию класса "a", поскольку он был его родителем.

Это вызовет проблемы (например, если функция a.run_func была удалена), и единственным решением без перезаписи кода в классе a.x1 будет переопределение подкласса x1 с обновленным кодом для всех классов, производных от класса "а", что, очевидно, будет сложно. и не стоит.

Вы хотите использовать наследование, а не вложенные классы? То, что вы делаете, не имеет большого смысла в Python.

Вы можете получить доступ к некоторому_методу Outer, просто сославшись на Outer.some_method в методах внутреннего класса, но он не будет работать так, как вы ожидаете. Например, если вы попробуете это:

class Outer(object):

    def some_method(self):
        # do something

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

... вы получите TypeError при инициализации объекта Inner, потому что Outer.some_method ожидает получить экземпляр Outer в качестве первого аргумента. (В приведенном выше примере вы в основном пытаетесь вызвать some_method как метод класса Outer.)

Другая возможность:

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

Опоздал на вечеринку на несколько лет... но, чтобы расширить замечательный ответ @mike rodent, ниже я привел собственный пример, который показывает, насколько гибким является его решение и почему оно должно быть (или должен был быть был) принятым ответом.

Питон 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 # ....
)

Выход:

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

Опять же, замечательный ответ, реквизит для вас, Майк!

Развивая убедительное мышление @tsnorri, что внешний метод может быть статическим методом:

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

Теперь рассматриваемая линия должна работать к моменту ее фактического вызова.

Последняя строка в приведенном выше коде дает классу Inner статический метод, который является клоном статического метода Outer.

При этом используются две особенности Python: функции являются объектами и область действия является текстовой.

Обычно локальная область видимости ссылается на локальные имена текущей (текстовой) функции.

...или текущий класс в нашем случае. Таким образом, на объекты, «локальные» для определения внешнего класса (Inner и some_static_method), можно ссылаться непосредственно в этом определении.

Что мы можем сделать, так это передать переменную self класса Outer во внутренний класс в качестве аргумента класса, а в разделе Outer init инициализировать внутренний класс с внешним self, переданным во внутренний.

class Outer:
    def __init__(self):
        self.somevalue=91
        self.Inner=self.Inner(self)
    def SomeMethod(self):
        print('This is Something from Outer Class')

    class Inner:
        def __init__(self,Outer)
            self.SomeMethod=Outer.SomeMethod
            self.somevalue=Outer.somevalue
    
        def SomeAnotherMethod(self):
            print(self.somevalue)
            self.SomeMethod()        

>>>f=Outer()
>>>f.Inner.SomeAnotherMethod() 
91
This is Something from Outer Class

Теперь после запуска этой функции она работает

Вы можете создать класс, чтобы украсить внутренние классы. В данном случае @inner.

Так как это декоратор: Outer.A = inner(Outer.A). Как только ваш код требует Outer.A, он будет выполнен методом inner.__get__, который возвращает исходный класс (A) с новым набором атрибутов: A.owner = Outer.

Метод класса в классе A, в данном случае def add(cls, y=3), может использовать новый атрибут owner в return cls.owner.x + y + 1.

Строка setattr(owner, name, self.inner) прерывает дескриптор, потому что owner.name => Outer.A => A больше не является экземпляром внутреннего класса.

Надеюсь это поможет.

    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

Это слишком просто:

Вход:

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

Выход

функция класса А1

функция класса B1