python - 从另一个对象 B 本身访问对象 A 的属性 A 的属性

Question

我正在解决一个物理问题，涉及一组(物理)对象(我们称之为 B)以及它们与另一个(物理)对象(我们称之为 A)的关系。每个 B 都有各自的属性，这些属性的计算可能取决于 A 的属性。 A 是独一无二的，与 A 无关，B 没有目的或意义。
有没有办法从 B 的类定义访问 A 的属性，如果要从 A 的实例实例化对象 B，那么 A 的属性将在同一“级别”上？就像是

class A(object):
    def __init__(self, foo, bar, b1, b2):
        self.foo = foo
        self.bar = bar
        self.list_bs = [b1, b2]  # instances of B

class B(object):
    def computation(self):
        # something involving foo or bar, magically accessed

我觉得我有四个选项(...是为了简洁而不是 Python 省略号):

将我的 A 实例传递给 B 的构造函数

class A(object):
    def add(self, b):
        self.list_bs.append(b)

class B(object):
    __init__(self, a, ...):
        self.a = a
        ...
        ...

    def compute1(self):
        # something involving self.a.foo

    def compute2(self):
        # something involving self.a.bar

a = A()
a.add(B(a, ...))
a.add(B(a, ...))

将我的 A 实例的选定属性传递给 B 的构造函数

class A(object):
    def add(self, b):
        self.list_bs.append(b)

class B(object):
    def __init__(self, a1, a2, ...):
        self.foo = a1
        self.bar = a2
        ...
        ...

    def compute1(self):
        # something involving self.foo

    def compute2(self):
        # something involving self.bar
a = A()
a.add(B(a.foo, a.bar, ...))
a.add(B(a.foo, a.bar, ...))

触发所有从 A 请求 A 属性的计算，即使它们与 B 更相关

def class A(object):
    def add(self, b):
        b.compute1(self.foo)
        b.compute2(self.bar)
        self.list_bs.append(b)

class B(object):
    def compute1(self, a1):
        # something involving a1

    def compute2(self, a2):
        # something involving a2

抛弃 A 并将其属性用作 B 的类属性

class B:
    foo = a1
    bar = a2

    def compute1(self):
        # something involving B.foo

    def compute2(self):
        # something involving B.bar

我是不是错过了其他东西，或者想多了？这些选项中的哪一个是最轻/最快的？
选项 1 和 2 感觉有很多重复，即使它只是引用。选项 3 感觉可能难以维护。选项 4 会让我将一些与 B 无关的 A 方法合并到 B 中，所以我不是一个大粉丝。

Answer 1

我有时更喜欢将逻辑与数据容器分开(我并不是说这是更快也不是更好的方式)，尤其是当它归结为对不同的变量/状态进行操作时。在这种情况下，我认为我会考虑使用 3 个类而不是一个类，以便数据与逻辑保持分离。如果您处理的数据很简单，这可能会超出范围，但是，除此之外:

class A(object):
    def __init__(self, foo, bar):
        self.foo = foo
        self.bar = bar
        

class B(object):
    def __init__(self, ):
        # whatever_you need

# optionally, if you really like classes, 
# you can also think about wrapping the list in his own class:
class WrapperB():
    def __init__(self):
      self.b_list = []

    def add(b: B):
       self.b_list.append(b)

class BusinessLogic()
    @staticmethod
    def compute(foo, bar, b_list: WrapperB or list):
       # whatever you need

假设您不仅有 2 个分类(A 和 B)，而且还有更多:我认为逻辑分离是一个可以考虑的选择。
编辑:
正如所指出的，具有单个静态方法的类并不是真正的“类”(从某种意义上说，您不需要为单个静态方法构建类)。在这种情况下，您可以考虑实现一个简单的功能。在这个例子中，我使用了一个类，因为如果你需要更多的逻辑，你可以扩展它。