Wie kann ich eine Funktion mit optionalen Argumenten definieren?

Question

Ich habe eine Python-Funktion, die mehrere Argumente benötigt. Einige dieser Argumente könnten in manchen Szenarien weggelassen werden.

def some_function (self, a, b, c, d = None, e = None, f = None, g = None, h = None):
    #code

Die Argumente d über h sind Zeichenfolgen, die jeweils unterschiedliche Bedeutungen haben. Es ist wichtig, dass ich wählen kann, welche optionalen Parameter ich in beliebiger Kombination übergeben möchte. Zum Beispiel, (a, b, C, d, e) , oder (a, b, C, g, h) , oder (a, b, C, d, e, f oder alle von ihnen (das sind meine Entscheidungen).

Es wäre toll, wenn ich die Funktion überladen könnte - aber ich habe gelesen, dass Python das Überladen nicht unterstützt. Ich habe versucht, einige der erforderlichen int-Argumente in die Liste einzufügen - und bekam einen Argument-Mismatch-Fehler.

Im Moment sende ich leere Zeichenfolgen anstelle der ersten paar fehlenden Argumente als Platzhalter. Ich möchte eine Funktion nur mit tatsächlichen Werten aufrufen können.

Gibt es eine Möglichkeit, dies zu tun? Kann ich eine Liste anstelle der Argumentliste übergeben?

Im Moment sieht der Prototyp mit ctypes etwa so aus:

_fdll.some_function.argtypes = [c_void_p, c_char_p, c_int, c_char_p, c_char_p, c_char_p, c_char_p, c_char_p]

Answer 1

Verwenden Sie einfach die *args Parameter, der es Ihnen erlaubt, so viele Argumente wie Sie wollen nach Ihrem a,b,c . Sie müssten eine Logik hinzufügen, um die Karte args -> c,d,e,f aber es ist eine "Art" der Überlastung.

def myfunc(a,b, *args, **kwargs):
   for ar in args:
      print ar
myfunc(a,b,c,d,e,f)

Und es werden die Werte von c,d,e,f

---

Auf ähnliche Weise könnten Sie die kwargs und dann können Sie Ihre Parameter benennen.

def myfunc(a,b, *args, **kwargs):
      c = kwargs.get('c', None)
      d = kwargs.get('d', None)
      #etc
myfunc(a,b, c='nick', d='dog', ...)

Et puis kwargs würde ein Wörterbuch mit allen Parametern enthalten, die nach a,b

Answer 2

Versuchen Sie, es so zu nennen: obj.some_function( '1', 2, '3', g="foo", h="bar" ) . Nach den erforderlichen Positionsargumenten können Sie bestimmte optionale Argumente mit Namen angeben.

Answer 3

Es ist ganz einfach, tun Sie dies

def foo(a = None):
       print(a)

Anstelle von None können Sie alles eingeben, was an der Stelle stehen soll, wenn es kein Argument gibt, z.B. wenn Sie den Wert des Parameters nicht wie folgt schreiben wollen foo() dann wird er None ausgeben, weil kein Argument angegeben wurde, und wenn Sie ihm ein Argument geben, wie foo("hello world") dann wird folgendes gedruckt hello world ... ach ja, ich habe nur vergessen, euch zu sagen, dass diese Arten von Parametern, d.h. optionale Parameter, nicht in die Liste aufgenommen werden, müssen hinter allen anderen Parametern liegen. Das bedeutet, dass wir die vorherige Funktion nehmen und einen weiteren Parameter hinzufügen b

def foo(a = None, b): 
    print(a)

Wenn Sie nun Ihre Python-Datei ausführen, wird sie eine Ausnahme auslösen, die besagt, dass Non-default arguments follow default arguments ,

SyntaxError: non-default argument follows default argument

Sie müssen also das optionale oder nicht standardmäßige Argument nach den erforderlichen Argumenten einfügen

was bedeutet

def foo (a, b=None): ... #This one is right
def foo(b=None, a): ... #and this isn't

Answer 4

Erforderliche Parameter zuerst, optionale Parameter danach. Optionale Parameter immer mit einem =None .

Einfaches und schnelles Beispiel:

def example_function(param1, param2, param3=None, param4=None):
    pass

# Doesn't work, param2 missing
example_function("hello")

# Works
example_function("hello", "bye")

# Works. Both the same
example_function("hello", "bye", "hey")
example_function("hello", "bye", param3="hey")

# Works. Both the same
example_function("hello", "bye", "hey", "foo")
example_function("hello", "bye", param3="hey", param4="foo")

Answer 5

Prüfen Sie dies:

from typing import Optional

def foo(a: str, b: Optional[str] = None) -> str or None:
    pass