Вложенный класс Python должен получить доступ к переменной во включающем классе

Несмотря на мой «немного снисходительный» комментарий (честно говоря!), на самом деле есть способы добиться того, чего вы хотите: другой путь наследования. Пара:

1. Напишите декоратор, который анализирует класс сразу после его объявления, находит внутренние классы и копирует в них атрибуты из внешнего класса.

2. Сделайте то же самое с метаклассом.

Вот подход декоратора, так как он самый простой:

def matryoshka(cls):

    # get types of classes
    class classtypes:
        pass
    classtypes = (type, type(classtypes))

    # get names of all public names in outer class
    directory = [n for n in dir(cls) if not n.startswith("_")]

    # get names of all non-callable attributes of outer class
    attributes = [n for n in directory if not callable(getattr(cls, n))]

    # get names of all inner classes
    innerclasses = [n for n in directory if isinstance(getattr(cls, n), classtypes)]

    # copy attributes from outer to inner classes (don't overwrite)
    for c in innerclasses:
        c = getattr(cls, c)
        for a in attributes:
            if not hasattr(c, a):
                setattr(c, a, getattr(cls, a))

    return cls

Вот простой пример его использования:

@matryoshka
class outer(object):

    answer = 42

    class inner(object):

        def __call__(self):
            print self.answer

outer.inner()()   # 42

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

Здесь не нужны два класса. Вот ваш пример кода, написанный в более сжатой форме.

class ChildClass:
    def __init__(self, stream):
        idx = stream.read_ui16()
        self.name = self.constant_pool[idx]

def makeChildren(stream):
    ChildClass.constant_pool = ConstantPool(stream)
    return [ChildClass(stream) for i in range(stream.read_ui16())]

Добро пожаловать в Python. Классы изменяются во время выполнения. Наслаждаться.

Вы можете получить доступ к родительскому классу через его имя:

class ChildClass:

    name = None

    def __init__(self, stream):
        idx = stream.read_ui16()
        self.name = ParentClass.constant_pool[idx]

Опять же, я не уверен, что понимаю, чего вы пытаетесь достичь.

Другой альтернативный дизайн для рассмотрения:

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

Глобальные переменные имеют плохую репутацию в большинстве языков программирования, но в Python они не являются по-настоящему глобальными и хорошо инкапсулированы в модуль.

Ну, следующие работы (еще более упрощенные из вашего примера). Обратите внимание, что вам не нужно «объявлять» переменные-члены на уровне класса, например C++/C#/Java и т. д., просто установите их на self внутри __init__:

class ParentClass:
    def __init__(self):
        self.constant_pool = ["test"]
        self.ChildClass.constant_pool = self.constant_pool
        self.children = [self.ChildClass()]

    class ChildClass:
        def __init__(self):
            self.name = self.constant_pool[0]
            print "child name is", self.name

p = ParentClass() # Prints "child name is test"

Обратите внимание, что вы все еще можете делать то же самое без вложенных дочерних классов.

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

class ParentClass(object):
  constant_pool = [c1, c2, c3]
  def __init__(self):
    # anything not included in your question

class ChildClass(ParentClass):
  def __init__(self, stream):
    ParentClass.__init__(self)
    self.name = ParentClass.constant_pool[stream.read_ui16()]

stream = get_new_stream()
children = []
for count in range(stream.read_ui16()):
  children.append(ChildClass(stream))

Этот код использует наследование для получения ChildClass от ParentClass (и всех методов и т. д.). Constant_pool является атрибутом самого ParentClass, хотя его можно рассматривать как атрибут любого экземпляра ParentClass или ChildClass (сказать, что self.constant_pool внутри ChildClass.__init__ было бы эквивалентно приведенному выше, но, на мой взгляд, вводит в заблуждение).

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