Question

我有一个班级A。在__init__;

的实例的A方法期间

我创建以下两个类B和C的实例：

b = B()
c = C()

完成所有设置后，我需要在B的方法中使用C中的方法调用。

示例：

触发：

b.call_c()

的作用：

def call_c(self):
    parent.c.a_method_of_c()

我需要做些什么来实现这种结构？

Answer 1

您需要将self或c传递给B()，以便了解其他对象。

Answer 2

我需要在B的方法中调用来自C的方法。

基本上，如果方法不是类方法或静态方法，那么调用方法总是意味着您可以访问（c ）C类的对象。

看看这个例子：

#!python3

class B:
    def __init__(self, value):
        self.value = value

    def __str__(self):
        return 'class B object with the value ' + str(self.value)    


class C:
    def __init__(self, value):
        self.value = value

    def __str__(self):
        return 'class C object with the value ' + str(self.value)    


class A:
    def __init__(self, value):
        self.value = value
        self.b = B(value * 2)
        self.c = C(value * 3)

    def __str__(self):
        lst = ['class A object with the value ' + str(self.value),
               '  containing the ' + self.b.__str__(),
               '  containing also the ' + str(self.c),
               ]
        return '\n'.join(lst)


a = A(1)
print(a)
print(a.b)
print(a.c)

self.b.__str__()是从B类的对象的方法调用A类的对象的方法的示例。 str(self.c)是相同的，只能通过str()函数间接调用。

显示以下内容：

class A object with the value 1
  containing the class B object with the value 2
  containing also the class C object with the value 3
class B object with the value 2
class C object with the value 3

Answer 3

如果您将A对象作为父/容器对象传递给B和C，那么这是如何看待的：

class A(object):
    def __init__(self):
        self.b = B(self)
        self.c = C(self)

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

    def call_c(self):
        self.parent.c.a_method_of_c()

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

    # whatever...

或者，您可以将C实例传递给B的初始值设定项，如下所示：

class A(object):
    def __init__(self):
        self.c = C()
        self.b = B(self.c)

class B(object):
    def __init__(self, c):
        self.cobj = c

    def call_c(self):
        self.cobj.a_method_of_c()

class C(object):
    # whatever...

我更喜欢第二种方法，因为它会删除B上的B和C的依赖关系，以及A实现b和c属性的必要性。

如果B和C必须相互调用方法，你仍然可以使用A来建立这些关联，但保持B和C不知道A：

class A(object):
    def __init__(self):
        self.b = B()
        self.c = C()
        self.b.cobj = self.c
        self.c.bobj = self.b

class B(object):
    def __init__(self, c):
        self.cobj = None

    def call_c(self):
        if self.cobj is not None:
            self.cobj.a_method_of_c()
        else:
            raise Exception("B instance not fully initialized")

class C(object):
    # similar to B

一般来说，你的目标是尽量避免或至少减少这些依赖关系 - 让父母知道一个孩子，但孩子不知道父母。或者容器知道其包含的对象，但包含的对象不知道它们的容器。一旦你添加循环引用（对父对象或容器对象的反向引用），事情就会以各种令人惊讶的方式变得丑陋。当其中一个链接被清除但是没有反射链接时，关系可能会被破坏。或者循环关系中的垃圾收集可能会变得棘手（在Python本身中处理，但如果在框架中持久化或复制这些对象和关系，则可能无法处理）。

如何在两个类之间调用方法？

3 个答案: