Question

考虑以下代码：

class A:
        B = 42  # or whatever
        class C:
                a = B  # wont find `B` here

这不起作用，因为在class C中，它找不到B。

您也无法使用A.B，因为此时还不知道A因为它仍在构造中，因此它不在全局命名空间中。在成员函数中，这将起作用，因为在执行该代码时，可能已注册全局名称A。但是，我明确要求直接访问，而不是在成员函数内。

那么，在这种嵌套类构造中是否还有其他方法可以访问外部名称空间？

我猜答案可能不是，或者至少不是一个干净的方式。我在print(locals())内添加class C，在Python 2中添加{'__module__': '__main__'}，在Python 3中添加{'__qualname__': 'A.C', '__module__': '__main__'}。因此，本地人和全局变量都不会授予我访问父本地命名空间的权限。

关于非干净方式：sys._getframe(1).f_locals["B"]可行。这是正在构建的A类的本地人，而B就在那里。

那么，如果没有干净的方法，那么其他解决方案是什么？我可以直接在全局命名空间中声明所有类，但我不喜欢（对于我的特定用例）。我可以将它们移动到子模块中并将其导入A。但这使得代码阅读起来更加复杂。还有其他解决方案吗？

所以，我想它总是一样的，除非我没有展示一个真实世界的例子，否则人们不会相信这样的用例会如何发生。所以，这里是（via）：

class structs:
    # .... many more

    class _anonymous_label(ctypes.Structure):
        _fields_ = [
            ('lb_type', ctypes.c_int),
            ('lb_str', ctypes.POINTER(ctypes.c_byte))]

    class _anonymous_labellist(ctypes.Structure):
        _fields_ = [
            ('ll_nlabels', ctypes.c_int),
            ('ll_label', ctypes.POINTER(_anonymous_label))]  # error

    # .... many more

Answer 1

class Constants:
    a = 1

class A:
    class B(Constants):
        pass

    class C(Constants):
        pass

print(A.B.a, A.C.a)

Answer 2

在内部类声明完成后，我在外部类中执行内部类的类变量赋值。它变得非常复杂，非常明显并且有效：

class A: class B: a = 1 class C: pass C.a = B.a print(A.B.a, A.C.a)

Answer 3

您如何看待

var = 1
class A:
    class B:
        a = var
    class C:
        a = var

Answer 4

您始终可以使用未公开的临时对象。但是，根据您的非平凡示例的外观，这可能不合适。

# foo module
ABC_ATTRIBUTE = 42
class A:
  B = ABC_ATTRIBUTE
  class C:
    a = ABC_ATTRIBUTE
del ABC_ATTRIBUTE  # no longer accessible as foo.ABC_ATTRIBUTE

Python：如何访问外部类名称空间

4 个答案: