Python: l'Héritage rapport à la Composition

Je suis en train de travailler avec deux classes en Python, dont l'une devrait être autorisé à avoir un nombre quelconque d'objets d'une autre classe que les enfants tout en gardant un inventaire de ces enfants comme un attribut. L'héritage semblait être le choix évident pour ce parent<>l'enfant de la situation, mais au lieu de ce que je suis arrivé à est un exemple de la composition. Voici le code simplifié:


class Parent():

    def __init__(self,firstname,lastname):
        self.firstname = firstname
        self.lastname = lastname
        self.kids = []

    def havechild(self,firstname):
        print self.firstname,"is having a child"
        self.kids.append(Child(self,firstname))

class Child(Parent):

    def __init__(self,parent,firstname):
        self.parent = parent
        self.firstname = firstname
        self.lastname = parent.lastname

Donc en gros, alors qu'il semble faire sens intuitif d'avoir des Enfants() hérite de l'objet Parent(), suppression de l'héritage, ne change rien du tout. Le seul avantage que je peux voir pour quitter Enfant(Parent) au lieu de simplement classe de l'Enfant() serait si j'ai besoin d'ajouter beaucoup plus de méthodes pour Parent que je voudrais Enfant d'hériter. À l'aide de la auto.parent = parent, j'ai déjà accès à toutes les futures attributs de la Mère.

Est-il une autre façon de l'utiliser pur héritage plutôt que de passer à la Parent exemple dans le Enfant constructeur (composition)?

Non, vous n'avez le droit chemin. Il serait mauvais pour introduire un couplage entre les objets via l'héritage tout simplement pour partager des méthodes d'entre eux, à moins que vous vouliez qu'ils ont un "est un" et même alors, vous pouvez aller de l' "mixin" route à la place.
L'héritage est pour "est-un" relations". Est un enfant, un parent? Pas nécessairement. La Composition est "a-un" relations". Un enfant a un père (et un parent a un enfant). Vous utiliser l'héritage si vous avez eu une personne de la classe, puis un enfant est une personne, de sorte que l'enfant allait hériter de personne.
Si vous avez besoin des deux classes de partager des méthodes communes, alors vous pourriez toujours les deux sous-classe d'une classe de Personne.
"Parent" ou "Enfant" sont accidentelle propriétés que "les Gens" arrive parfois d'avoir ou pas. Ainsi dans le cas de cette nomenclature, vous devriez avoir qu'une seule catégorie - Person avec ses kids tableau vide ou pas.
Vous pourriez l'héritage si vous voulez que vos enfants soient en mesure de havechild(...).

OriginalL'auteur Arne | 2013-12-30

  1. 20

    Ce n'est certainement pas bon pour inherint Enfant du Parent ou des Parents de l'Enfant.

    La bonne façon de le faire est de faire une classe de base, disons que Personne et hériter à la fois des Parents et des Enfants.
    Un avantage de ce mode est de supprimer la répétition de code, au moment où vous avez seulement prénom /nom des champs copiés dans les deux objets, mais vous pouvez avoir plus de données ou d'autres méthodes, comme get_name() de travailler avec ces données.

    Voici un exemple:

    class Person(object):

    def __init__(self, firstname, lastname):
        self.firstname = firstname
        self.lastname = lastname

    def get_name(self):
        return '%s %s' % (self.firstname, self.lastname)


class Parent(Person):

    def __init__(self, firstname, lastname):
        super(Parent, self).__init__(firstname, lastname)
        self.kids = []

    def havechild(self, firstname):
        print self.firstname, "is having a child"
        self.kids.append(Child(self, firstname))


class Child(Person):

    def __init__(self, parent, firstname):
        super(Child, self).__init__(firstname, parent.lastname)
        self.parent = parent

    Une autre façon de faire c'est de le faire sans héritage, mais une seule Personne objet (vs Parent et de l'Enfant).
    La fonctionnalité de suivi de la situation de famille, les parents et les enfants peuvent être déplacés dans un autre objet.

    Un avantage de cette approche est que vous suivez les principe de responsabilité unique et de garder les objets simples, chaque objet n'a qu'une seule chose.

    Voici un exemple:

    from collections import defaultdict

class Person(object):

    def __init__(self, firstname, lastname):
        self.firstname = firstname
        self.lastname = lastname

    def get_name(self):
        return '%s %s' % (self.firstname, self.lastname)


class FamilyRegistry(object):

    def __init__(self):
        self.kids = defaultdict(list)

    def register_birth(self, parent, child_name):
        print parent.firstname, "is having a child"
        child = Person(child_name, parent.lastname)
        self.kids[parent.lastname].append(child)
        return child

    def print_children(self, person):
        children = self.kids[person.lastname]
        if len(children) == 0:
            print '%s has no children' % person.get_name()
            return
        for child in children:
            print child.get_name()

    Il fonctionne comme ceci:

    joe = Person('Joe', 'Black')
jill = Person('Jill', 'White')
registry = FamilyRegistry()
registry.register_birth(joe, 'Joe Junior') # Joe is having a child
registry.register_birth(joe, 'Tina')       # Joe is having a child
registry.print_children(joe)               # Joe Junior Black
                                           # Tina Black
registry.print_children(jill)              # Jill White has no children

    OriginalL'auteur Boris Serebrov

  2. 0

    Tout d'abord, je pense que vous confondez les choses. Comme vous l'avez vous-même mentionner l'héritage est utilisé dans une classe qui veut hériter la nature de la classe parent et ensuite modifier ce comportement et de l'étendre.

    Dans votre exemple, l'Enfant hérite de deux choses l'un des Parents. Le constructeur __init__ et havechild. Vous êtes surcharger le constructeur et le havechild méthode ne devrait pas fonctionner, car il n'y a pas d'enfants membre de la liste pour ajouter le nouvel enfant. Aussi, il semble que vous n'êtes pas l'intention d'avoir des enfants, avoir des enfants.

    Cela étant dit, il semble que vous pouvez réellement vous voulez poser une autre question, comme Composition vs Agrégation. Il y a un tel choix de conception que Héritage vs Composition qui, en fait, peut être particulièrement intéressante pour Python, mais surtout vous demande si vous souhaitez réutiliser le code par copier le comportement d'un autonome, classe parent (héritage) ou que vous souhaitez séparer les différentes comportement de la classe de granules (par manque d'un meilleur mot), puis créer des classes qui sont compositions de ces granules.

    jetez un oeil à ce! Le livre référencé est également bien connue et a un bon catalogue pour les différents modèles de conception.

    OriginalL'auteur Matthias Michael Engh