Python Args und Kwargs

Einführung

In diesem Lab lernen Sie *args und **kwargs in Python kennen. Diese speziellen Syntaxformen mögen zunächst einschüchternd wirken, sind aber leicht zu verstehen und bieten eine leistungsstarke Möglichkeit, Ihre Funktionen flexibler zu gestalten. Sie werden lernen, wie man Funktionen definiert, die eine variable Anzahl von Argumenten akzeptieren können, was eine gängige und nützliche Funktion in vielen Python-Programmen und Bibliotheken ist.

Args und Kwargs

In diesem Schritt lernen Sie die grundlegende Syntax von *args und **kwargs kennen. Diese werden in Funktionsdefinitionen verwendet, um das Übergeben einer undefinierten Anzahl von Argumenten zu ermöglichen. *args ist für nicht-benannte (positionale) Argumente, während **kwargs für Schlüsselwortargumente (Keyword Arguments) dient.

Hinweis: Wenn Sie mit der Verwendung der WebIDE (ähnlich VS Code) nicht vertraut sind, lernen Sie dies zuerst in diesem Lab.

Zuerst sehen wir uns an, wie man eine Funktion definiert, die jede Kombination von Argumenten akzeptieren kann. Suchen Sie im linken Dateiexplorer die Datei main.py im Verzeichnis ~/project und öffnen Sie sie im Editor.

Fügen Sie den folgenden Code zu main.py hinzu:

## Define a function that accepts any number of positional and keyword arguments
def some_function(*args, **kwargs):
    print("This function can accept any arguments.")
    print(f"Received positional arguments: {args}")
    print(f"Received keyword arguments: {kwargs}")
    print("-" * 20)

## Call with any number of positional arguments
some_function('arg1', 'arg2', 'arg3')

## Call with any number of keyword arguments
some_function(key1='arg1', key2='arg2', key3='arg3')

## Call with both positional and keyword arguments
some_function('positional_arg', key1='keyword_arg')

## Or call with no arguments at all
some_function()

Es ist wichtig zu beachten, dass args und kwargs lediglich Namenskonventionen sind. Der einfache Stern (*) und der doppelte Stern (**) sind die eigentliche Syntax, die die Arbeit leistet. Es gilt jedoch als gute Praxis in der Python-Community, diese Konventionen einzuhalten.

Führen Sie nun das Skript aus, indem Sie ein Terminal in der WebIDE öffnen und den folgenden Befehl ausführen:

python3 main.py

Sie sollten die folgende Ausgabe sehen, die demonstriert, wie die Funktion verschiedene Aufrufe behandelt:

This function can accept any arguments.
Received positional arguments: ('arg1', 'arg2', 'arg3')
Received keyword arguments: {}
--------------------
This function can accept any arguments.
Received positional arguments: ()
Received keyword arguments: {'key1': 'arg1', 'key2': 'arg2', 'key3': 'arg3'}
--------------------
This function can accept any arguments.
Received positional arguments: ('positional_arg',)
Received keyword arguments: {'key1': 'keyword_arg'}
--------------------
This function can accept any arguments.
Received positional arguments: ()
Received keyword arguments: {}
--------------------

Dies zeigt, dass *args positionale Argumente in einem Tupel sammelt und **kwargs Schlüsselwortargumente in einem Dictionary sammelt.

*args

In diesem Schritt konzentrieren Sie sich speziell auf *args. Diese Syntax ermöglicht es einer Funktion, eine beliebige Anzahl von positionellen Argumenten entgegenzunehmen. Diese Argumente werden in einem Tupel gesammelt.

Löschen Sie den vorherigen Inhalt aus main.py und fügen Sie den folgenden Code hinzu. Dieses Beispiel definiert eine Funktion, die *args entgegennimmt, und gibt die empfangenen Argumente zusammen mit ihrem Typ aus.

## *args collects positional arguments into a tuple
def some_function(*args):
    print(f'Arguments passed: {args} as {type(args)}')

## Pass multiple arguments - they'll be collected into the args tuple
some_function('arg1', 'arg2', 'arg3')

In diesem Code weist *args in der Funktionssignatur Python an, alle zusätzlichen positionellen Argumente, die an some_function übergeben werden, zu sammeln und sie in einem Tupel namens args abzulegen.

Führen Sie nun das Skript im Terminal aus:

python3 main.py

Die Ausgabe bestätigt, dass die Argumente als Tupel übergeben wurden:

Arguments passed: ('arg1', 'arg2', 'arg3') as <class 'tuple'>

Dies demonstriert, wie *args eine einfache Möglichkeit bietet, eine variable Anzahl von Eingaben zu verarbeiten, ohne jede einzelne als separaten Parameter definieren zu müssen.

**kwargs

In diesem Schritt lernen Sie, wie Sie **kwargs verwenden. Diese Syntax wird verwendet, um eine beliebige Anzahl von Schlüsselwortargumenten (Keyword Arguments) in einem Dictionary zu sammeln. Dies ist nützlich, wenn Sie benannte Argumente verarbeiten möchten, die Sie nicht im Voraus definiert haben.

Löschen Sie den Inhalt von main.py und fügen Sie den folgenden Code hinzu. Dieses Beispiel definiert eine Funktion, die **kwargs akzeptiert, und gibt die gesammelten Schlüsselwortargumente sowie deren Typ aus.

## **kwargs collects keyword arguments into a dictionary
def some_function(**kwargs):
    print(f'keywords: {kwargs} as {type(kwargs)}')

## Pass keyword arguments - they'll be collected into the kwargs dict
some_function(key1='arg1', key2='arg2')

Hier weist **kwargs in der Funktionssignatur Python an, alle Schlüsselwortargumente, die an some_function übergeben werden, in einem Dictionary namens kwargs zu sammeln. Die Schlüssel des Dictionaries sind die Argumentnamen und die Werte sind die Argumentwerte.

Führen Sie das Skript im Terminal aus:

python3 main.py

Die Ausgabe zeigt, dass die Schlüsselwortargumente in einem Dictionary gesammelt wurden:

keywords: {'key1': 'arg1', 'key2': 'arg2'} as <class 'dict'>

Diese Funktion wird in Python häufig für Funktionen verwendet, die Optionen oder Konfigurationen übergeben müssen, was saubere und lesbare Funktionsaufrufe ermöglicht.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie *args und **kwargs in Python verwenden, um flexiblere Funktionen zu erstellen.

Sie haben gelernt, dass:

• *args eine variable Anzahl von positionellen Argumenten in einem Tupel sammelt.
• **kwargs eine variable Anzahl von Schlüsselwortargumenten in einem Dictionary sammelt.
• args und kwargs konventionelle Namen sind, aber die Syntax * und ** diese Funktionalität ermöglicht.

Die Beherrschung von *args und **kwargs ist ein wichtiger Schritt beim Schreiben von fortgeschrittenerem und wiederverwendbarem Python-Code. Sie können nun Funktionen erstellen, die anpassungsfähiger für verschiedene Arten von Eingaben sind.