嵌套Python类需要访问封闭类中的变量
我已经看到了一些“解决方案”，但每次的解决方案似乎都是“不要使用嵌套类，在外部定义类，然后正常使用它们”。我不喜欢这个答案，因为它忽略了我选择嵌套类的主要原因，也就是说，所有创建的子类实例都可以访问一个常量池（与基类关联） 下面是示例代码：嵌套Python类需要访问封闭类中的变量,python,scope,nested-class,Python,Scope,Nested Class,我已经看到了一些“解决方案”，但每次的解决方案似乎都是“不要使用嵌套类，在外部定义类，然后正常使用它们”。我不喜欢这个答案，因为它忽略了我选择嵌套类的主要原因，也就是说，所有创建的子类实例都可以访问一个常量池（与基类关联） 下面是示例代码： class ParentClass: constant_pool = [] children = [] def __init__(self, stream): self.constant_pool = Consta
class ParentClass:
constant_pool = []
children = []
def __init__(self, stream):
self.constant_pool = ConstantPool(stream)
child_count = stream.read_ui16()
for i in range(0, child_count):
children.append(ChildClass(stream))
class ChildClass:
name = None
def __init__(self, stream):
idx = stream.read_ui16()
self.name = constant_pool[idx]
\uuu init\uuselfclass 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 ChildClass:
name = None
def __init__(self, stream):
idx = stream.read_ui16()
self.name = ParentClass.constant_pool[idx]
再说一次，我不确定我是否理解您想要实现的目标。这里不需要两门课。下面是以更简洁的方式编写的示例代码
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。类在运行时是可变的。享受。你的问题使用了subclass这个词，所以我用它来解释你的问题。和其他回答的人一样，我不确定我是否理解你在寻找什么
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中称为self.constant\u pool
。\uuuu init\uuuudef 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
然而，我忍不住认为其他答案中建议的一些想法会更好地为您服务。另一种可供考虑的设计方案： 当您发现自己试图使用类作为名称空间时，将内部类放入它们自己的模块中并确定外部类全局变量的属性可能更有意义。换句话说，如果您从未打算实例化您的
父类全局变量在大多数编程语言中都很糟糕，但在Python中它们并不是真正的全局变量，并且被很好地封装到模块中。我使用的实际类有20个子对象和5个“共享”资源，因此当我将每个共享资源应用到每个对象时，这个解决方案将产生100行赋值。这正是我试图通过实现父/子关系来避免的黑客行为的类型。也是列表理解吗？你似乎想给这个家伙留下深刻印象。使用Python而不使用理解就像去坎昆而不去海滩。你的装饰师建议正是我想要的。我最终得到了以下结果，这在我工作的情况下实现了我想要的结果[我无法理解注释中的代码格式是如何工作的，我放弃]：
def add_parent_links（cls）：cls_init=cls.\uu init_uu_u_uinit_u（self，s）：对于k in dir（self）：if str（type）（getattr（self，k））.find（'classobj'）>-1:getattr（self，k）.parent=self-cls\u init（self，s）cls.\uuuuu init\uuuuu=\uuuuuu init\uuuuuuuu返回clsParentClassChildClassParentClass