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):

并从那里获得进一步的关系。这给出了一个更简单的结构，没有观点的矛盾，但仍然导致评估进一步关系的问题，因为给定的人的链接只是“向上” - 给定的人知道他们的父母是谁，但无法识别他们的孩子。

你可以保留所有人的名单并每次搜索清单（就像一位母亲绕着幼儿园说：“你是我的孩子吗？你？你是我的孩子吗？”）但这似乎效率很低。 / p>

相反，您可以将每个关系设置为双向 - 每个父母都有一个包含所有孩子的列表，每个孩子都有一个包含所有父母的列表。它使得添加和删除人员变得更加困难，但是非常值得。

以下比我喜欢的时间长，但是我可以做到这一点;它应该更适合你的需求！

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'

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

1 个答案: