如何为父母/子女/祖父母设计类层次结构？

Question

希望此递归函数（ search_Bases ）遍历每个基类并对其进行__init__ 。 如何我指的是每个班级的self ，实际上并没有使用self ？ 我已经尝试了几件事，但是我无法弄清楚。 当我将Child()类更改为执行类似操作时，它会起作用。 所以我不知道下一步该怎么做。

def search_Bases(child=0):
    if child.__bases__:
        for parent in child.__bases__:
            parent.__init__(self) # <-----I can't figure out how to initiate the class
                                  # without referring to 'self'.... 
            search_Bases(parent)


class Female_Grandparent:
    def __init__(self):
        self.grandma_name = 'Grandma'

class Male_Grandparent:
    def __init__(self):
        self.grandpa_name = 'Grandpa'

class Female_Parent(Female_Grandparent, Male_Grandparent):
    def __init__(self):
        Female_Grandparent.__init__(self)
        Male_Grandparent.__init__(self)
        self.female_parent_name = 'Mother'

class Male_Parent(Female_Grandparent, Male_Grandparent):
    def __init__(self):
        Female_Grandparent.__init__(self)
        Male_Grandparent.__init__(self)
        self.male_parent_name = 'Father'

class Child(Female_Parent, Male_Parent):
    def __init__(self):
        Female_Parent.__init__(self)
        Male_Parent.__init__(self)

        #search_Bases(Child)


child = Child()
print child.grandma_name

Answer 1

我认为您没有正确理解类继承。 在Python中，

class Female_Parent(Female_Grandparent, Male_Grandparent):
    def __init__(self):

表示Female_Parent IS-A Male_Grandparent ，这似乎不太可能。 你的意思是

class Female_Parent(object):
    def __init__(self, female_grandparent, male_grandparent):

这也有问题，因为这取决于谁是问的角色变化-根据定义， Male_Grandparent （他的孙子）也是Male_Parent （他的孩子）谁也是一个Child （他的父母）。

您可以将所有课程简化为

class Person(object):
    def __init__(self, mother, father):

并从那里得到进一步的关系。 这给出了一个简单得多的结构，没有视点矛盾，但是仍然导致评估进一步的关系时出现问题，因为给定人的链接只会“上升”-给定人知道他们的父母是谁，但无法确定他们的父母是谁。儿童。

您可以保留所有人员的清单，并每次都搜索该清单（例如一位母亲在幼儿园里转悠，说：“您是我的孩子吗？您？您是我的孩子吗？”），但这似乎效率很低。

取而代之的是，您可以使两种关系成为双向关系-每个父母都有所有子女的清单，每个孩子都有所有父母的清单。 这使添加和删除人员变得更加困难，但这是值得的。

以下内容比我喜欢的要长，但是要尽我所能。 它应该更好地满足您的需求！

class Person(object):
    def __init__(self, name, sex, parents=None, children=None):
        """
        Create a Person
        """
        self.name = name
        self.sex = sex    # 'M' or 'F'

        self.parents = set()
        if parents is not None:
            for p in parents:
                self.add_parent(p)

        self.children = set()
        if children is not None:
            for c in children:
                self.add_child(c)

    def add_parent(self, p):
        self.parents.add(p)
        p.children.add(self)

    def add_child(self, c):
        self.children.add(c)
        c.parents.add(self)

    def __str__(self):
        return self.name

    def __repr__(self):
        return "Person('{}', '{}')".format(self.name, self.sex)

    #
    # Immediate relationships
    #
    # Each fn returns a set of people who fulfill the stated relationship
    #

    def _parent(self):
        return self.parents

    def _sibling(self):
        return set().union(*(p.children for p in self.parents)) - set([self])

    def _child(self):
        return self.children

    def _female(self):
        if self.sex=='F':
            return set([self])
        else:
            return set()

    def _male(self):
        if self.sex=='M':
            return set([self])
        else:
            return set()

    def relation(self, *rels):
        """
        Find the set of all people who fulfill the stated relationship

        Ex:
            self.relation("parent", "siblings")     # returns all aunts and uncles of self
        """
        # start with the current person
        ps = set([self])

        for rel in rels:
            # each argument is either a function or a string
            if callable(rel):
                # run the function against all people in the current set
                #   and collect the results to a new set
                ps = set().union(*(rel(p) for p in ps))
            else:
                # recurse to evaluate the string
                do = Person._relations[rel]
                ps = set().union(*(p.relation(*do) for p in ps))

        return ps

    def print_relation(self, *rels):
        print ', '.join(str(p) for p in self.relation(*rels))

#
# Extended relationships
#
# Supplies the necessary information for Person.relation() to do its job -
# Each key refers to a recursive function tree (nodes are string values, leaves are functions)
#
# (Unfortunately this table cannot be created until the Person class is finalized)
#
Person._relations = {
    "parent":        (Person._parent,),
    "mother":        (Person._parent, Person._female),
    "father":        (Person._parent, Person._male),
    "sibling":       (Person._sibling,),
    "sister":        (Person._sibling, Person._female),
    "brother":       (Person._sibling, Person._male),
    "child":         (Person._child,),
    "daughter":      (Person._child, Person._female),
    "son":           (Person._child, Person._male),
    "grandparent":   ("parent", "parent"),
    "grandmother":   ("parent", "mother"),
    "grandfather":   ("parent", "father"),
    "aunt":          ("parent", "sister"),
    "uncle":         ("parent", "brother"),
    "cousin":        ("parent", "sibling", "child"),
    "niece":         ("sibling", "daughter"),
    "nephew":        ("sibling", "son"),
    "grandchild":    ("child", "child"),
    "grandson":      ("child", "son"),
    "granddaughter": ("child", "daughter")
}

现在，采取行动：

mm  = Person('Grandma', 'F')
mf  = Person('Grandpa', 'M')
m   = Person('Mom', 'F', [mm, mf])
fm  = Person('Nana', 'F')
ff  = Person('Papi', 'M')
f   = Person('Dad', 'M', [fm, ff])
me  = Person('Me', 'M', [m, f])
s   = Person('Sis', 'F', [m, f])
joe = Person('Brother-in-law', 'M')
s1  = Person('Andy', 'M', [s, joe])
s2  = Person('Betty', 'F', [s, joe])
s3  = Person('Carl', 'M', [s, joe])

me.print_relation("grandmother")    # returns 'Nana, Grandma'
me.print_relation("nephew")         # returns 'Andy, Carl'