TOC

Verwendung von * args und ** kwargs in Python 3

Einführung

Infunction definitions sindparameters benannte Entitäten, die ein Argument angeben, das eine bestimmte Funktion akzeptieren kann.

Während der Programmierung kennen Sie möglicherweise nicht alle möglichen Anwendungsfälle Ihres Codes und möchten möglicherweise mehr Optionen für zukünftige Programmierer, die mit dem Modul arbeiten, oder für Benutzer, die mit dem Code interagieren, anbieten. Wir können eine variable Anzahl von Argumenten an eine Funktion übergeben, indem wir*args und**kwargs in unserem Code verwenden.

* Args verstehen

In Python kann die Einzelsternform von*args als Parameter verwendet werden, um eine nicht mit Schlüsselwörtern versehene Argumentliste mit variabler Länge an Funktionen zu senden. Es ist erwähnenswert, dass das Sternchen (*) hier das wichtige Element ist, da das Wortargs die etablierte konventionelle Redewendung ist, obwohl es von der Sprache nicht erzwungen wird.

Schauen wir uns eine typische Funktion an, die zwei Argumente verwendet:

lets_multiply.py

def multiply(x, y):
    print (x * y)

Im obigen Code haben wir die Funktion mitx undy als Argumenten erstellt. Wenn wir dann die Funktion aufrufen, müssen wir Zahlen verwenden, umx undyzu entsprechen. s. In diesem Fall übergeben wir die Ganzzahl5 fürx und die Ganzzahl4 füry:

lets_multiply.py

def multiply(x, y):
    print (x * y)

multiply(5, 4)

Jetzt können wir den obigen Code ausführen: 

python lets_multiply.py

Wir erhalten die folgende Ausgabe, aus der hervorgeht, dass die ganzen Zahlen 5 und 4 gemäß der Funktionmultiply(x,y)multipliziert wurden: 

Output20

Was ist, wenn wir später entscheiden, drei statt nur zwei Zahlen zu multiplizieren? Wenn wir versuchen, der Funktion eine zusätzliche Nummer hinzuzufügen (siehe unten), wird eine Fehlermeldung angezeigt.

lets_multiply.py

def multiply(x, y):
    print (x * y)

multiply(5, 4, 3)
OutputTypeError: multiply() takes 2 positional arguments but 3 were given

Wenn Sie also den Verdacht haben, dass Sie später möglicherweise mehr Argumente verwenden müssen, können Sie stattdessen*args als Parameter verwenden.

Wir können im Wesentlichen dieselbe Funktion und denselben Code erstellen, die wir im ersten Beispiel gezeigt haben, indem wirx undy als Funktionsparameter entfernen und stattdessen durch*args ersetzen:

lets_multiply.py

def multiply(*args):
    z = 1
    for num in args:
        z *= num
    print(z)

multiply(4, 5)
multiply(10, 9)
multiply(2, 3, 4)
multiply(3, 5, 10, 6)

Wenn wir diesen Code ausführen, erhalten wir das Produkt für jeden dieser Funktionsaufrufe: 

Output20
90
24
900

Da wir*args verwendet haben, um eine Argumentliste mit variabler Länge an unsere Funktion zu senden, konnten wir beliebig viele Argumente an die Funktionsaufrufe übergeben.

Mit*args können Sie flexibleren Code erstellen, der eine Vielzahl von Argumenten ohne Schlüsselwörter in Ihrer Funktion akzeptiert.

** kwargs verstehen

Die doppelte Sternchenform von**kwargs wird verwendet, um ein Schlüsselwortargument mit variabler Längedictionary an eine Funktion zu übergeben. Auch hier sind die beiden Sternchen (**) das wichtige Element, da das Wortkwargs herkömmlicherweise verwendet wird, obwohl es von der Sprache nicht erzwungen wird.

Wie*args kann**kwargs beliebig viele Argumente annehmen, die Sie ihm liefern möchten. **kwargs unterscheidet sich jedoch von*args darin, dass Sie Schlüsselwörter zuweisen müssen.

Drucken wir zunächst einfach die Argumente von**kwargsaus, die wir an eine Funktion übergeben. Dazu erstellen wir eine kurze Funktion:

print_kwargs.py

def print_kwargs(**kwargs):
        print(kwargs)

Als Nächstes rufen wir die Funktion mit einigen Schlüsselwörtern auf, die an die Funktion übergeben werden:

print_kwargs.py

def print_kwargs(**kwargs):
        print(kwargs)

print_kwargs(kwargs_1="Shark", kwargs_2=4.5, kwargs_3=True)

Führen Sie das obige Programm aus und sehen Sie sich die Ausgabe an: 

python print_kwargs.py
Output{'kwargs_3': True, 'kwargs_2': 4.5, 'kwargs_1': 'Shark'}

Abhängig von der Version von Python 3, die Sie gerade verwenden, ist der Dictionary-Datentyp möglicherweise ungeordnet. In Python 3.6 und höher erhalten Sie die Schlüssel-Wert-Paare nacheinander. In früheren Versionen werden die Paare jedoch in zufälliger Reihenfolge ausgegeben.

Es ist wichtig zu beachten, dass ein Wörterbuch mit dem Namenkwargs erstellt wird und wir damit genauso arbeiten können wie mit anderen Wörterbüchern.

Erstellen wir ein weiteres kurzes Programm, um zu zeigen, wie wir**kwargs verwenden können. Hier erstellen wir eine Funktion zur Begrüßung eines Namenswörterbuchs. Zunächst beginnen wir mit einem Wörterbuch mit zwei Namen:

print_values.py

def print_values(**kwargs):
    for key, value in kwargs.items():
        print("The value of {} is {}".format(key, value))

print_values(my_name="Sammy", your_name="Casey")

Jetzt können wir das Programm ausführen und die Ausgabe betrachten: 

python print_values.py
OutputThe value of your_name is Casey
The value of my_name is Sammy

Da Wörterbücher möglicherweise nicht geordnet sind, wird Ihre Ausgabe möglicherweise zuerst mit dem NamenCaseyoder zuerst mit dem NamenSammyausgeführt.

Übergeben wir nun zusätzliche Argumente an die Funktion, um zu zeigen, dass**kwargs so viele Argumente akzeptiert, wie Sie einschließen möchten:

print_values.py

def print_values(**kwargs):
    for key, value in kwargs.items():
        print("The value of {} is {}".format(key, value))

print_values(
            name_1="Alex",
            name_2="Gray",
            name_3="Harper",
            name_4="Phoenix",
            name_5="Remy",
            name_6="Val"
        )

Wenn wir das Programm zu diesem Zeitpunkt ausführen, erhalten wir die folgende Ausgabe, die möglicherweise wieder ungeordnet ist: 

OutputThe value of name_2 is Gray
The value of name_6 is Val
The value of name_4 is Phoenix
The value of name_5 is Remy
The value of name_3 is Harper
The value of name_1 is Alex

Die Verwendung von**kwargs bietet uns Flexibilität bei der Verwendung von Schlüsselwortargumenten in unserem Programm. Wenn wir**kwargs als Parameter verwenden, müssen wir nicht wissen, wie viele Argumente wir eventuell an eine Funktion übergeben möchten.

Argumente ordnen

Beim Anordnen von Argumenten innerhalb einer Funktion oder eines Funktionsaufrufs müssen die Argumente in einer bestimmten Reihenfolge auftreten:

  1. Formale Positionsargumente

  2. *args

  3. Schlüsselwortargumente

  4. **kwargs

In der Praxis würde Ihre Funktion folgendermaßen aussehen, wenn Sie mit expliziten Positionsparametern zusammen mit*args und**kwargs arbeiten: 

def example(arg_1, arg_2, *args, **kwargs):
...

Wenn Sie zusätzlich zu*args und**kwargs mit Positionsparametern und benannten Schlüsselwortparametern arbeiten, sieht Ihre Funktion folgendermaßen aus: 

def example2(arg_1, arg_2, *args, kw_1="shark", kw_2="blobfish", **kwargs):
...

Beachten Sie beim Erstellen von Funktionen unbedingt die Reihenfolge der Argumente, damit in Ihrem Python-Code kein Syntaxfehler auftritt.

Verwendung von * args und ** kwargs in Funktionsaufrufen

Wir können auch*args und**kwargs verwenden, um Argumente an Funktionen zu übergeben.

Schauen wir uns zunächst ein Beispiel mit*args an.

some_args.py

def some_args(arg_1, arg_2, arg_3):
    print("arg_1:", arg_1)
    print("arg_2:", arg_2)
    print("arg_3:", arg_3)

args = ("Sammy", "Casey", "Alex")
some_args(*args)

In der obigen Funktion sind drei Parameter definiert alsarg_1,arg_ undarg_3. Die Funktion druckt jedes dieser Argumente aus. Anschließend erstellen wir eine Variable, die auf eine iterable Variable (in diesem Falltuple) festgelegt ist, und können diese Variable mit der Sternsyntax an die Funktion übergeben.

Wenn wir das Programm mit dem Befehlpython some_args.pyausführen, erhalten wir die folgende Ausgabe: 

Outputarg_1: Sammy
arg_2: Casey
arg_3: Alex

Wir können das obige Programm auch in iterierbarelist data type mit einem anderen Variablennamen ändern. Kombinieren wir auch die Syntax von*argsmit einernamed parameter:

some_args.py

def some_args(arg_1, arg_2, arg_3):
    print("arg_1:", arg_1)
    print("arg_2:", arg_2)
    print("arg_3:", arg_3)

my_list = [2, 3]
some_args(1, *my_list)

Wenn wir das obige Programm ausführen, wird die folgende Ausgabe erzeugt: 

Outputarg_1: 1
arg_2: 2
arg_3: 3

In ähnlicher Weise können die Argumente des Schlüsselworts**kwargszum Aufrufen einer Funktion verwendet werden. Wir richten eine Variable ein, die einem Wörterbuch mit 3 Schlüssel-Wert-Paaren entspricht (wir verwenden hierkwargs, aber sie kann beliebig aufgerufen werden) und übergeben sie an eine Funktion mit 3 Argumenten:

some_kwargs.py

def some_kwargs(kwarg_1, kwarg_2, kwarg_3):
    print("kwarg_1:", kwarg_1)
    print("kwarg_2:", kwarg_2)
    print("kwarg_3:", kwarg_3)

kwargs = {"kwarg_1": "Val", "kwarg_2": "Harper", "kwarg_3": "Remy"}
some_kwargs(**kwargs)

Führen Sie das obige Programm mit dem Befehlpython some_kwargs.pyaus: 

Outputkwarg_1: Val
kwarg_2: Harper
kwarg_3: Remy

Beim Aufrufen einer Funktion können Sie*args und**kwargs verwenden, um Argumente zu übergeben.

Fazit

Wir können die spezielle Syntax von*args und**kwargs innerhalb einer Funktionsdefinition verwenden, um eine variable Anzahl von Argumenten an die Funktion zu übergeben.

Das Erstellen von Funktionen, die*args und**kwargs akzeptieren, wird am besten in Situationen verwendet, in denen Sie erwarten, dass die Anzahl der Eingaben in der Argumentliste relativ gering bleibt. Die Verwendung von*args und**kwargs dient in erster Linie der Lesbarkeit und Bequemlichkeit, sollte jedoch mit Vorsicht erfolgen.

Related