init mit Parent Class

[peterwoodbridge]

@peterwoodbridge: Das ist IMHO keine Unterscheidung die man Anhand der Klassenhierarchie treffen sollte. Entweder bekommen die ein Attribut zu welcher Gruppe sie gehören, oder sie sollten (zusätzlich) getrennt in Gruppen vermerkt werden.

Letztlich könnte man auch mehr als nur ein Flag oder eine Gruppen-ID oder ähnliches verwenden, nämlich die Unterschiede gar nicht über Vererbung lösen, sondern durch eine Klasse die jeweils die unterschiedliche Funktionalität zur Verfügung stellt und als Attribut auf den Testpersonen gesetzt wird. Dann lässt sich eine Person auch einfach durch austausch dieses Objekts „umwandeln”. Nichts anderes machst Du bei IMHO unsauberen ändern von `__class__`.

Kannst Du dies ausführlicher erklären? Ich versteh nicht ganz, was du meinst...

[mcdwerner]

zum Beispiel so

Code: Alles auswählen

class TestPerson(Person):
    def __init__(self, is_placebo, ...):
        Person.__init__(self,  ...)
        self.is_placebo = is_placebo

Du packst alles was Du brauchst in eine Klasse TestPerson und je nachdem ob is_placebo True oder False ist machst Du was anderes in den Methoden

[Sirius3]

Ein Patient ist keine andere Person nur weil er ein Placebo bekommt. Deshalb ist eine eigene Klasse ungünstig. Die Frage die man sich beim OOP-Design stellt ist dann ob sie durch die Beziehung durch "… ist ein …" oder "… hat ein …" besser beschreiben läßt.
Bei Dir "Placebo_nehmender_Patient ist ein Patient" oder "Patient hat (nimmt) ein Placebo/wirkendes Medikament".
Der erste Fall wird durch Vererbung der zweite durch ein weiteres Attribut gelöst.

Code: Alles auswählen

class Person:
    def __init__(self, name, medikament):
        self.name = name
        self.medikament = medikament

class Placebo:
    …

class Medikament:
    …

Mir ist noch nicht ganz klar was ein Placebo jetzt speziell für Methoden hat, die auf eine Person wirkt, vielleicht kannst Du das noch näher erklären. Ansonsten wäre das ja nur so ein Flag.

[BlackJack]

Statt der Vererbung, die Du jetzt hast:

Code: Alles auswählen

class Proband(object):
    def __init__(self, name):
        self.name = name

    def do_routines(self):
        raise NotImplemented


class TestSubject(Proband):
    def __init__(self, name):
        Proband.__init__(self, name)
        # ...
    
    def do_routines(self):
        """..."""


class PlaceboSubject(Proband):
    def __init__(self, name):
        Proband.__init__(self, name)
        # ...
    
    def do_routines(self):
        """..."""

Könnte man die Unterschiede in eigenen Datentypen kapseln und Delegation statt Vererbung verwenden:

Code: Alles auswählen

class TestRoutine(object):
    def do_routines(self, proband):
        """..."""


class PlaceboRoutine(object):
    def do_routines(self, proband):
        """..."""


class Proband(object):
    def __init__(self, name, routines):
        self.name = name
        self.routines = routines

    def do_routines(self):
        self.routines.do_routines(self)

Wobei hier `do_routines()` für mehr als eine Methode stehen könnte. Jetzt kann man das `routines`-Attribut einfach auf etwas anderes setzten und damit aus einem Probanden der Placebo bekommt, einen machen der das Medikament bekommt. Oder umgekehrt. Anhand des Wertes von `routines` kann man auch einfach filtern. Man kann auch mehr als zwei Gruppen kodieren. Eventuell ohne zusätzliche Klassen. Zum Beispiel könnte man die Klasse für die Medikamenten-Gruppe parametrisieren. Die Dosierung variiert ja beispielsweise bei manchen Studien.

[peterwoodbridge]

Zur Zeit habe ich es anders gelöst:

ich habe nur noch 1 Klasse...
und beim generieren einer Person entscheide ich, ob es eine Testperson ist oder eine Placebo-Person.
Schien mir einfacher zu sein; obs "gut" ist, ist ne andere Frage

[Hyperion]

ich habe nur noch 1 Klasse...
und beim generieren einer Person entscheide ich, ob es eine Testperson ist oder eine Placebo-Person.

Öh... klingt immer noch nach *drei* (mindestens aber zwei) Klassen: Eine die generiert und jeweils eine für Test- oder Placeboperson... anstelle einer Generator-Klasse kann das natürlich auch eine Funktion sein.

Aber "Testperson" oder "Placebo-Person" klingt für mich stark nach Klasse... wobei BJ und andere ja schon die Frage stellte, *wie* sich das letztlich unterscheidet...