python - Python：在另一个类中访问一个类的属性和方法

Question

假设我有两个 A 类和 B 类：

Class A:
   # A's attributes and methods here

Class B:
  # B's attributes and methods here

现在我可以评估 A 在 B 类对象中的属性如下：

a_obj = A()
b_obj = B(a_obj)

我需要的是双向访问。如何访问 A 在 B 中的属性和 B 在 A 中的属性？

Answer 1

您需要以任何一种方式创建指针：

class A(object):
    parent = None


class B(object):
    def __init__(self, child):
        self.child = child
        child.parent = self

现在A可以参考self.parent（前提是不是None），也B可以参考self.child。如果您尝试创建A多个子节点的实例B，则最后一个“父节点”获胜。

Answer 2

为什么不以一种可以通过继承来处理的方式来规划您的对象。

class A(object):
    # stuff

class B(A):
    # has A methods/properties

class C(B):
    # has A and B methods/properties

在这种情况下，通过提前计划，您可以只使用C通用对象，并A使用B更专业/裸露的父母。

Answer 3

此方法将非常有用，因为您可以互换使用这两个类的对象。这有一个严重的问题，我将在最后解释。

class A:
    def MethodA(self):
        return "Inside MethodA"

    def __init__ (self, Friend=None):
        self.__dict__['a'] = "I am a"
        self.__dict__['Friend'] = Friend
        if Friend is not None: self.__dict__['Friend'].__dict__['Friend'] = self

    def __getattr__(self, name):
        if self.Friend is not None: return getattr(self.Friend, name)
        raise AttributeError ("Unknown Attribute `" + name + "`")

    def __setattr__(self, name, value):
        if self.Friend is not None: setattr(self.Friend, name, value)
        raise AttributeError ("Unknown Attribute `" + name + "`")

class B:
    def MethodB(self):
        return "Inside MethodB"

    def __init__ (self, Friend=None):
        self.__dict__['b'] = "I am b"
        self.__dict__['Friend'] = Friend
        if Friend is not None: self.__dict__['Friend'].__dict__['Friend'] = self

    def __getattr__(self, name):
        if self.Friend is not None: return getattr(self.Friend, name)
        raise AttributeError ("Unknown Attribute `" + name + "`")

    def __setattr__(self, name, value):
        if self.Friend is not None: setattr(self.Friend, name, value)
        raise AttributeError ("Unknown Attribute `" + name + "`")

解释：

根据此页面，仅当在特定对象的空间中找不到请求的属性__getattr__时__setattr__才会在 python 对象上调用。所以在构造函数中，我们正在建立两个类之间的关系。然后每当调用__getattr__or时__setattr__，我们使用方法引用另一个对象getattr。( getattr , setattr ) 我们用来__dict__在构造函数中赋值，这样我们就不会调用__setattr__or __getattr__。

样品运行：

b = B()
# print b.a    # Throws AttributeError, as A and B are not related yet
a = A(b)

print a.a
print a.b
print b.a      # Works fine here, as 'a' is not found b, returns A's a
print b.b

print a.MethodA()
print a.MethodB()
print b.MethodA()
print b.MethodB()

I am a
I am b
I am a
I am b
Inside MethodA
Inside MethodB
Inside MethodA
Inside MethodB

现在，严重的问题：

如果我们尝试访问这两个对象中都不存在的属性，我们将陷入无限递归。假设我想从“a”访问“C”。由于 C 不在 a 中，它会调用__getattr__并引用 b 对象。由于 b 对象没有 C，它将调用__getattr__将引用对象 a 的对象。所以我们最终陷入了无限递归。因此，当您不访问两个对象都不知道的任何内容时，这种方法可以正常工作。