named Parameter mehrmals übergeben

Question

Ich frage mich, ob es eine Best Practice oder eine Konvention für diese Art von "verkettet" genannten Parameter gibt. Ich versuche, die erste Variable d zu bar durch foo zu übergeben. Es ist irgendwie peinlich, es auf diese Weise zu machen, und ich glaube, dass es einen schlaueren Weg geben sollte, aber nach dem Durchsehen von Tonnen von Dokumenten heute noch keine Ahnung.

def bar(a=0, b=0, c=0, d=0): 
    print(a,b,c,d) 

def foo(b=0,d=0): 
    bar(d=d) 

foo(d=1) 
#(0,0,0,1) 

Answer 1

Ich glaube nicht, gibt es eine bessere Art und Weise, dies zu tun, aber wenn die b Parameter nicht dann in foo() benutzt werden hätte ich es dort nicht in.

def bar(a=0, b=0, c=0, d=0): 
    print(a,b,c,d) 

def foo(d=0): 
    bar(d=d) 

foo(1) 
#(0,0,0,1) 

Answer 2

Jede Antwort hier ist subjektiv, aber ich werde nicht einreichen, um die Frage zu schließen, weil ich denke, dass dies für jeden wertvoll ist, der Python und berufliche Praxis lernt.

das gesagt ist, ich denke, die Art und Weise haben Sie es richtig ist, wenn b in foo angenommen wird, in einer Codezeile in der Funktion verwendet werden, nachdem bar genannt wird. Wenn b nicht verwendet wird, sollten Sie es aus der Parameterliste entfernen.

Aber lassen Sie mich einen weiteren Fall machen, während wir bei der Subjektivität sind: spezifizieren Argumente bei einem Funktionsaufruf durch Verwendung von Schlüsselwortargumenten so viel wie möglich.

Warum?

Wenn Sie komplexen Code in einer professionellen Umgebung betrachten, wird deutlich, was in eine Funktion übertragen wird und warum. Und in Python ist explizit gegenüber implizit bevorzugt.

Sie werden Ihren Code einmal schreiben. Sie könnten es ein paar Mal korrigieren. Jemand wird Ihren Code lesen, um tausendmal mit einem Produktionsproblem fertig zu werden.

Nehmen Sie zum Beispiel die folgenden Code (der ein Finanzmodell ist):

def black_scholes(spot, strike, volatility, risk_free_rate, expiry=.25): 
    # do calculation and return result 
    # .... 
    return result 

option_value = black_scholes(44, 48, .08, .54, .75) 

Legen Sie Ihre Hand über die Parameterliste in der Funktionsdefinition. Können Sie sagen, was jede dieser Zahlen darstellt? Sicher, Sie können die Definition in der gleichen Datei finden und die Positionsargumente vergleichen, aber was, wenn black_scholes() in einem anderen Modul ist? Jetzt ist es ein bisschen härter. Was ist, wenn wir dies erweitern und einen Wrapper mit höherer Ebene um black_scholes() und hinzufügen, der ist, was wir debuggen mussten, um dies zu erreichen? Jetzt

, lassen Sie mich Ihnen den Funktionsaufruf zeigen mit Schlüsselwort-Argumente:

result = black_scholes(spot=44, strike=48, volatility=.08, risk_free_rate=.54, expiry=.75) 

Das jetzt viel klarer wird, und wir können antizipieren, was das erwartete Ergebnis sein sollte. Wir haben auch viel Zeit beim Lesen des Codes eingespart und haben ein Ergebnis, mit dem man (verglichen mit dem Erwarteten) vergleichen kann, anstatt über die Funktion im Debugger zu gehen, anstatt Zeile für Zeile darin zu lesen.