Question

我所拥有的：

我有4个类的类层次结构，这些类是在链中继承的：

A类。
B派生A。
C得出B。
D派生C。

每个类都有1个（额外）属性。因此，A具有1个属性，D具有4个属性：

class A:
    def __init__(self, a):
        self.a = a

class B(A):
    def __init__(self, a, b):
        super().__init__(a)
        self.b = b

class C(B):
    def __init__(self, a, b, c):
        super().__init__(a, b)
        self.c = c

class D(C):
    def __init__(self, a, b, c, d):
        super().__init__(a, b, c)
        self.d = d

我想做什么：

我有2组D类对象。我想计算2组对象的交集。之后，我想获得2个集合的余数（第一个交点中没有项的集合）的交集，但是这次将它们进行比较，因为它们是C类对象集（因此，仅比较4个中的3个）属性）。等等...

解决方案？

在Java中，我可以计算2个集合的交集，然后将剩余的集合转换为C类的对象，然后再次计算2个集合的交集，以仅比较4个属性中的3个。 Afaik，没有像python这样的类型转换。（不正确，如评论中所述。）

如何在python中解决此问题？我可以通过某种方式更改类结构以使其成为可能吗？

Answer 1

解决此问题的一种方法是将要使用的身份作为字典的显式键，将其映射到实际对象。

class A:
    def __init__(self, a):
        self.a = a

class B(A):
    def __init__(self, a, b):
        super().__init__(a)
        self.b = b

class C(B):
    def __init__(self, a, b, c):
        super().__init__(a, b)
        self.c = c

class D(C):
    def __init__(self, a, b, c, d):
        super().__init__(a, b, c)
        self.d = d


def d_key(item):
    return item.a, item.b, item.c, item.d


def c_key(item):
    return item.a, item.b, item.c



a = [D(1, 2, 3, 4), D(1, 3, 2, 4), D(1, 2, 4, 3), D(2, 1, 3, 4)]
b = [D(1, 2, 3, 4), D(1, 3, 2, 4), D(1, 2, 4, 3), D(2, 1, 3, 5)]


ad = dict((d_key(item), item) for item in a)
bd = dict((d_key(item), item) for item in b)

common = ad.keys() & bd.keys()

ac = dict((c_key(item), item) for item in a if d_key(item) in common)
bc = dict((c_key(item), item) for item in b if d_key(item) in common)

print(ac)
print(bc)

这种方法基本上模仿了您定义每个类的哈希/等于或比较Interface的行为。

将对象强制转换为超类/仅比较超类的属性

1 个答案: