Wie man *args und **kwargs in Python 3 verwendet

Einführung

In Funktionsdefinitionen sind Parameter benannte Entitäten, die ein Argument spezifizieren, das eine gegebene Funktion akzeptieren kann.

Beim Programmieren sind Sie sich möglicherweise nicht aller möglichen Anwendungsfälle Ihres Codes bewusst und möchten möglicherweise den zukünftigen Programmierern, die mit dem Modul arbeiten, oder den Benutzern, die mit dem Code interagieren, mehr Optionen bieten. Wir können eine variable Anzahl von Argumenten an eine Funktion übergeben, indem wir *args und **kwargs in unserem Code verwenden.

Voraussetzungen

Sie sollten Python 3 installiert und eine Programmierumgebung auf Ihrem Computer oder Server eingerichtet haben. Wenn Sie keine Programmierumgebung eingerichtet haben, können Sie auf die Installations- und Einrichtungsanleitungen für eine lokale Programmierumgebung oder für eine Programmierumgebung auf Ihrem Server verweisen, die für Ihr Betriebssystem (Ubuntu, CentOS, Debian usw.) geeignet ist.

Verstehen von *args

In Python kann die Ein-Stern-Form von *args als Parameter verwendet werden, um einer Funktion eine nicht benannte, variabel lange Argumentenliste zu übergeben. Es ist erwähnenswert, dass der Stern (*) das wichtige Element hier ist, da das Wort args das etablierte konventionelle Idiom ist, obwohl es von der Sprache nicht durchgesetzt wird.

Lass uns eine typische Funktion betrachten, die zwei Argumente verwendet:

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

Im obigen Code haben wir die Funktion mit x und y als Argumenten erstellt, und wenn wir die Funktion aufrufen, müssen wir Zahlen verwenden, die mit x und y übereinstimmen. In diesem Fall werden wir die Ganzzahl 5 für x und die Ganzzahl 4 für y übergeben:

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, die zeigt, dass die Ganzzahlen 5 und 4 gemäß der multiply(x,y)-Funktion multipliziert wurden:

20

Was ist, wenn wir später entscheiden, dass wir lieber drei Zahlen multiplizieren möchten anstatt nur zwei? Wenn wir versuchen, eine zusätzliche Zahl zur Funktion hinzuzufügen, wie unten gezeigt, erhalten wir einen Fehler.

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

multiply(5, 4, 3)

TypeError: multiply() takes 2 positional arguments but 3 were given

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

Wir können im Wesentlichen die gleiche Funktion und den gleichen Code erstellen, die wir im ersten Beispiel gezeigt haben, indem wir x und y als Funktionsparameter entfernen und sie stattdessen durch *args ersetzen:

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:

20
90
24
900

Da wir *args verwendet haben, um eine variabel-lange Argumentliste an unsere Funktion zu senden, konnten wir so viele Argumente in die Funktionsaufrufe übergeben, wie wir wollten.

Mit *args können Sie flexibleren Code erstellen, der eine variierte Anzahl von nicht benannten Argumenten innerhalb Ihrer Funktion akzeptiert.

Das Verständnis von **kwargs

Die doppelte Sternchenform von **kwargs wird verwendet, um ein mit Schlüsselwörtern versehenes, variablenlängen Argumentdicktionär an eine Funktion zu übergeben. Auch hier sind die zwei Sternchen (**) das wichtige Element, da das Wort kwargs konventionell verwendet wird, obwohl dies nicht von der Sprache vorgeschrieben ist.

Ähnlich wie *args kann **kwargs beliebig viele Argumente annehmen, die Sie ihm zur Verfügung stellen möchten. Allerdings unterscheidet sich **kwargs von *args, da Sie Schlüsselwörter zuweisen müssen.

Zunächst lassen Sie uns die **kwargs Argumente ausdrucken, die wir an eine Funktion übergeben. Wir werden eine kurze Funktion erstellen, um dies zu tun:

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

Als nächstes rufen wir die Funktion mit einigen Schlüsselwortargumenten auf, die an die Funktion übergeben werden:

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

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

Lass uns das oben stehende Programm ausführen und den Ausgabe betrachten:

python print_kwargs.py

{'kwargs_3': True, 'kwargs_2': 4.5, 'kwargs_1': 'Shark'}

Je nach der Version von Python 3, die Sie derzeit verwenden, kann der Datentyp Dictionary ungeordnet sein. In Python 3.6 und neuer erhalten Sie die Schlüssel-Wert-Paare in Reihenfolge, aber in früheren Versionen werden die Paare in zufälliger Reihenfolge ausgegeben.

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

Lass uns ein weiteres kurzes Programm erstellen, um zu zeigen, wie wir **kwargs nutzen können. Hier werden wir eine Funktion erstellen, um ein Wörterbuch von Namen zu begrüßen. Zuerst beginnen wir mit einem Wörterbuch von zwei Namen:

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")

Wir können das Programm jetzt ausführen und uns die Ausgabe ansehen:

python print_values.py

The value of your_name is Casey
The value of my_name is Sammy

Wiederum, da Wörterbücher möglicherweise ungeordnet sind, kann Ihre Ausgabe entweder mit dem Namen Casey zuerst oder mit dem Namen Sammy zuerst sein.

Lass uns jetzt zusätzliche Argumente an die Funktion übergeben, um zu zeigen, dass **kwargs beliebig viele Argumente akzeptiert, die du einfügen möchtest:

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 an dieser Stelle ausführen, erhalten wir die folgende Ausgabe, die möglicherweise wieder ungeordnet ist:

The 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 die Flexibilität, Schlüsselwortargumente in unserem Programm zu verwenden. Wenn wir **kwargs als Parameter verwenden, müssen wir nicht wissen, wie viele Argumente wir letztendlich einer Funktion übergeben möchten.

Arguments anordnen

Beim Angeben von Argumenten innerhalb einer Funktion oder eines Funktionsaufrufs müssen die Argumente in einer bestimmten Reihenfolge angegeben werden:

1. Formale Positionsargumente

*args

2. Schlüsselwortargumente

**kwargs

In der Praxis würde Ihre Funktion, wenn Sie explizite Positionsparameter zusammen mit *args und **kwargs verwenden, folgendermaßen aussehen:

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

Und wenn Sie mit Positionsparametern zusammen mit benannten Schlüsselwortparametern zusätzlich zu *args und **kwargs arbeiten, würde Ihre Funktion so aussehen:

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

Es ist wichtig, die Reihenfolge der Argumente beim Erstellen von Funktionen im Auge zu behalten, damit man keinen Syntaxfehler in seinem Python-Code erhält.

Verwendung von *args und **kwargs in Funktionsaufrufen

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

Zuerst schauen wir uns ein Beispiel mit *args an.

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 oben genannten Funktion sind drei Parameter definiert als arg_1, arg_2 und arg_3. Die Funktion wird jedes dieser Argumente ausgeben. Wir erstellen dann eine Variable, die auf ein iterierbares Objekt (in diesem Fall ein Tuple) gesetzt wird, und können diese Variable mit der Asterisk-Syntax in die Funktion übergeben.

Wenn wir das Programm mit dem Befehl python some_args.py ausführen, erhalten wir die folgende Ausgabe:

arg_1: Sammy
arg_2: Casey
arg_3: Alex

Wir können das obige Programm auch in einen iterierbaren Listendatentyp mit einem anderen Variablennamen umändern. Lassen Sie uns auch die *args-Syntax mit einem benannten Parameter kombinieren:

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 es die folgende Ausgabe erzeugen:

arg_1: 1
arg_2: 2
arg_3: 3

Ebenso können die gekennzeichneten **kwargs-Argumente verwendet werden, um eine Funktion aufzurufen. Wir werden eine Variable einrichten, die gleich einem Dictionary mit 3 Schlüssel-Wert-Paaren ist (wir verwenden hier kwargs, aber es kann nennen, wie du willst) und es an eine Funktion mit 3 Argumenten übergeben:

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)

Lass uns das obenstehende Programm mit dem Befehl python some_kwargs.py ausführen:

kwarg_1: Val
kwarg_2: Harper
kwarg_3: Remy

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

Schlussfolgerung

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, ist am besten in Situationen geeignet, in denen Sie erwarten, dass die Anzahl der Eingaben in der Argumentliste relativ klein bleibt. Die Verwendung von *args und **kwargs dient in erster Linie der Lesbarkeit und Bequemlichkeit, sollte aber mit Bedacht erfolgen.