Best Practice für Vererbung: * args, ** kwargs oder explizite Angabe von Parametern

Ich finde mich oft überschreiben von Methoden der übergeordneten Klasse und kann nie entscheiden, ob ich sollte explizit auf der Liste von Parametern oder verwenden Sie einfach eine Decke *args, **kwargs konstruieren. Ist eine version besser als die andere? Gibt es eine best practice? Welche vor-und Nachteile bin ich?

class Parent(object):

    def save(self, commit=True):
        # ...

class Explicit(Parent):

    def save(self, commit=True):
        super(Explicit, self).save(commit=commit)
        # more logic

class Blanket(Parent):

    def save(self, *args, **kwargs):
        super(Blanket, self).save(*args, **kwargs)
        # more logic

Wahrnehmung der Vorteile, die explizite Variante

Mehr explizite ("Zen of Python)
leichter zu erfassen
Funktion Parameter einfach zugegriffen

Wahrnehmung der Vorteile, die Decke Variante

mehr TROCKEN
übergeordneten Klasse ist leicht austauschbar
ändern der default Werte in übergeordnete Methode weitergegeben wird, ohne Sie zu berühren andere code

InformationsquelleAutor der Frage Maik Hoepfel | 2013-01-31

23

Liskov-Substitution-Prinzip

In der Regel Sie nicht wollen, dass Sie die Signatur der Methode zu variieren, die in abgeleiteten Typen. Dies kann Probleme verursachen, wenn Sie möchten, tauschen Sie die Verwendung von abgeleiteten Typen. Dies wird oft bezeichnet als die Liskov-Substitution-Prinzip.

Vorteile der Expliziten Signaturen

Zur gleichen Zeit ich glaube nicht, dass es richtig für alle Ihre Methoden eine Signatur von *args**kwargs. Explizite Unterschriften:
- helfen, dokumentieren die Methode durch gute argument-Namen
- helfen, dokumentieren Sie die Methode, indem Sie angeben, welche Argumente sind erforderlich und welche default-Werte
- eine implizite Validierung (fehlende erforderliche args offensichtlichen Ausnahmen)
Variable Länge Argumente und Kupplung

Nicht verwechseln mit variabler Länge Argumente für eine gute Kopplung der Praxis. Es sollte eine gewisse Kohäsion zwischen einer übergeordneten Klasse und abgeleiteten Klassen, sonst würden Sie nicht zueinander in Beziehung gesetzt werden. Es ist normal für den zugehörigen code zu Folge, Kupplung, spiegelt das Niveau der zusammenhalt.

Orte, Variable Länge Argumente

Verwendung von variabler Länge Argumente sollte nicht Ihre erste option. Es sollte verwendet werden, wenn Sie einen guten Grund haben wie:
- Definition einer Funktion wrapper (also ein decorator).
- Definition einer Parametrisch polymorphe Funktion.
- Wenn die Argumente, die Sie ergreifen können, wirklich völlig variable (z.B. eine verallgemeinerte DB-Verbindungs-Funktion). DB-Verbindungs-Funktionen nehmen in der Regel einen Verbindungszeichenfolge in vielen verschiedenen Formen, sowohl in Einzel-arg-form und multi-arg-form. Es gibt auch verschiedene Optionen für unterschiedliche Datenbanken.
- ...
Machst Du Etwas Falsch?

Wenn Sie feststellen, Sie sind oft zu schaffen-Methoden, die viele Argumente oder abgeleitete Methoden mit unterschiedlichen Signaturen haben Sie möglicherweise ein größeres Problem, wie Sie die Organisation Ihrer code.

InformationsquelleAutor der Antwort dietbuddha
13

Meine Wahl wäre:
```
class Child(Parent):

    def save(self, commit=True, **kwargs):
        super(Child, self).save(commit, **kwargs)
        # more logic
```
Er verhindert den Zugriff auf commit argument von *args und **kwargs und es hält die Dinge sicher, wenn die Unterschrift des Parent:save änderungen (z.B. hinzufügen eines neuen Standard-argument).

Update : In diesem Fall, dass die *args kann die Ursache für Probleme, wenn eine neue positions-argument Hinzugefügt wird, um das übergeordnete Element. Ich würde immer nur **kwargs und verwalten nur neue Argumente mit default-Werten. Würde es vermeiden, Fehler zu propagieren.

InformationsquelleAutor der Antwort luc
4

Wenn Sie sicher sind, dass Kind wird, halten Sie die Signatur, sicherlich der explizite Ansatz ist vorzuziehen, aber als Kind wird, ändern Sie die Signatur, die ich persönlich bevorzuge die Verwendung beider Ansätze:
```
class Parent(object):
    def do_stuff(self, a, b):
        # some logic

class Child(Parent):
    def do_stuff(self, c, *args, **kwargs):
        super(Child, self).do_stuff(*args, **kwargs)
        # some logic with c
```
Diese Weise änderungen in der Signatur sind durchaus lesbar im Kind, während die original-Unterschrift ist gut lesbar in der Eltern.

Meiner Meinung nach ist dies auch der bessere Weg, wenn Sie Mehrfachvererbung, da ruft super ein paar mal ziemlich ekelhaft, wenn Sie nicht haben, args und kwargs.

Für was es Wert ist, dies ist auch der bevorzugte Weg in einer ganzen Reihe von Python-Bibliotheken und-frameworks (Django, Tornado, Anfragen, Markdown, um ein paar zu nennen). Obwohl man sollte nicht die Basis seiner Entscheidungen auf solche Dinge, ich bin bloß impliziert, dass dieser Ansatz ist sehr weit verbreitet.

InformationsquelleAutor der Antwort dmg
3

Nicht wirklich eine Antwort, sondern mehr eine Randbemerkung: Wenn Sie wirklich, wirklich wollen, um sicherzustellen, dass die Standardwerte für die Eltern der Klasse weitergegeben werden, um die Kind-Klassen, die Sie tun können, so etwas wie:
```
class Parent(object):

    default_save_commit=True
    def save(self, commit=default_save_commit):
        # ...

class Derived(Parent):

    def save(self, commit=Parent.default_save_commit):
        super(Derived, self).save(commit=commit)
```
Aber ich muss zugeben das sieht ziemlich hässlich und würde ich nur verwenden, wenn ich fühle, dass ich es wirklich brauchen.

InformationsquelleAutor der Antwort Clemens Klein-Robbenhaar
2

Bevorzuge ich explizite Argumente, weil "auto-vervollständigen" können Sie sehen, die Methode, die Signatur der Funktion, während der Aufruf der Funktion.

InformationsquelleAutor der Antwort GeneralBecos

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.