У мене така ситуація ...

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

Як я можу отримати доступ до Outerметоду Innerкласу з класу?

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

Зауважте, що екземпляр зовнішнього класу існує не обов'язково, навіть коли ви створили екземпляр внутрішнього класу.

Насправді, часто рекомендується не використовувати вкладені класи, оскільки вкладання не передбачає якихось конкретних відносин між внутрішнім та зовнішнім класами.

Ви намагаєтесь отримати доступ до екземпляра класу Зовнішнього з внутрішнього екземпляра класу. Тож просто використовуйте фабричний метод для побудови внутрішнього екземпляра та передачі йому зовнішнього екземпляра.

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

Плюс ... "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 на "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()

пізніше

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

Ви маєте на увазі використовувати спадщину, а не вкладати такі класи? Те, що ви робите, не має сенсу в Python.

Ви можете отримати доступ до Outerметоду some_method, просто посилаючись 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.)

Ви можете легко отримати доступ до зовнішнього класу, використовуючи метаклас: після створення зовнішнього класу перевірте його атрибут 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.run_funcбуло видалено), і єдиним рішенням без переписування коду в класі a.x1було б перевизначення підкласу x1з оновленим кодом для всіх класів, похідних з класу "a", що, очевидно, було б складно і не варто це.

Я знайшов це .

Налаштовано для відповіді на ваше запитання:

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)

Я впевнений, що можна якось написати декоратора для цього чи чогось іншого

пов'язані: Яка мета внутрішніх класів пітона?

Ще одна можливість:

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

Розширюючись на переконливе мислення @ 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

Тепер відповідний рядок повинен запрацювати до того моменту, коли він фактично буде викликаний.

Останній рядок у наведеному вище коді надає внутрішньому класу статичний метод, який є клоном зовнішнього статичного методу.

Це використовує дві функції Python, які є об'єктами , а область дії - текстовою .

Зазвичай локальний обсяг посилається на локальні імена поточної функції (текстуально).

... або поточний клас у нашому випадку. Отже, на об’єкти, „локальні” для визначення класу „Зовнішній” ( Innerі some_static_method), можна посилатися безпосередньо в цьому визначенні.

Кілька років пізно до партії .... але розширити на @mike rodent«s прекрасний відповідь, я надав свій власний приклад нижче , який показує, наскільки гнучкий його рішення, і чому це повинно бути (або має бути було) прийняте відповідь.

Пітон 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

Знову ж таки, чудова відповідь, реквізит вам мікрофон!

Це занадто просто:

Вхід:

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

Вихід

клас A func1

клас B func1