Wie man *args und **kwargs in Python-Funktionsaufrufen kombiniert

Einführung

Python's *args und **kwargs sind leistungsstarke Funktionen, die es Ihnen ermöglichen, flexiblere und dynamischere Funktionen zu schreiben. In diesem Tutorial werden wir untersuchen, wie Sie diese beiden Techniken kombinieren können, um vielseitige Funktionsaufrufe zu erstellen, die eine variable Anzahl von Argumenten und Schlüsselwortargumenten verarbeiten können. Am Ende werden Sie einen soliden Überblick darüber haben, wie Sie *args und **kwargs nutzen können, um robusteres und anpassungsfähigeres Python-Code zu schreiben.

Skills Graph

Grundlagen von *args und **kwargs

Was sind *args und **kwargs?

In Python sind *args und **kwargs spezielle Syntaxelemente, die in Funktionsdefinitionen verwendet werden, um eine variable Anzahl von Argumenten zu verarbeiten. Sie ermöglichen es Funktionen, eine beliebige Anzahl von Positionsargumenten (*args) und/oder Schlüsselwortargumenten (**kwargs) zu akzeptieren.

*args (Nicht-Schlüsselwort-Argumente)

Die *args-Syntax ermöglicht es einer Funktion, eine beliebige Anzahl von Positionsargumenten zu akzeptieren. Diese Argumente werden dann in ein Tupel gepackt, über das innerhalb der Funktion iteriert werden kann. Dies ist nützlich, wenn Sie nicht im Voraus wissen, wie viele Argumente die Funktion erhalten wird.

def print_numbers(*args):
    for arg in args:
        print(arg)

print_numbers(1, 2, 3)  ## Output: 1 2 3
print_numbers(4, 5, 6, 7, 8)  ## Output: 4 5 6 7 8

**kwargs (Schlüsselwort-Argumente)

Die **kwargs-Syntax ermöglicht es einer Funktion, eine beliebige Anzahl von Schlüsselwortargumenten zu akzeptieren. Diese Argumente werden dann in ein Wörterbuch gepackt, wobei die Schlüssel die Argumentnamen und die Werte die entsprechenden Argumentwerte sind. Dies ist nützlich, wenn Sie eine beliebige Anzahl von benannten Parametern an eine Funktion übergeben möchten.

def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="LabEx", age=30, city="New York")
## Output:
## name: LabEx
## age: 30
## city: New York

Kombination von *args und **kwargs

Sie können sowohl *args als auch **kwargs in derselben Funktionsdefinition verwenden. *args sammelt alle Positionsargumente, während **kwargs alle Schlüsselwortargumente sammelt.

def print_all(*args, **kwargs):
    for arg in args:
        print(arg)
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_all(1, 2, 3, name="LabEx", age=30)
## Output:
## 1
## 2
## 3
## name: LabEx
## age: 30

In diesem Beispiel kann die Funktion print_all() eine beliebige Anzahl von Positionsargumenten (*args) und eine beliebige Anzahl von Schlüsselwortargumenten (**kwargs) akzeptieren.

Verwendung von *args und **kwargs in Funktionsaufrufen

Übergeben von *args an eine Funktion

Um eine variable Anzahl von Positionsargumenten an eine Funktion zu übergeben, die *args akzeptiert, können Sie die Argumente einfach mit dem *-Operator entpacken.

def print_numbers(*args):
    for arg in args:
        print(arg)

numbers = [1, 2, 3, 4, 5]
print_numbers(*numbers)
## Output:
## 1
## 2
## 3
## 4
## 5

In diesem Beispiel entpackt der Ausdruck *numbers die Elemente der Liste numbers und übergibt sie als einzelne Argumente an die Funktion print_numbers().

Übergeben von **kwargs an eine Funktion

Um eine variable Anzahl von Schlüsselwortargumenten an eine Funktion zu übergeben, die **kwargs akzeptiert, können Sie den **-Operator verwenden, um ein Wörterbuch in Schlüsselwortargumente zu entpacken.

def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

info = {"name": "LabEx", "age": 30, "city": "New York"}
print_info(**info)
## Output:
## name: LabEx
## age: 30
## city: New York

In diesem Beispiel entpackt der Ausdruck **info die Schlüssel-Wert-Paare des Wörterbuchs info und übergibt sie als einzelne Schlüsselwortargumente an die Funktion print_info().

Kombination von *args und **kwargs in Funktionsaufrufen

Sie können auch *args und **kwargs in demselben Funktionsaufruf kombinieren. *args sammelt alle Positionsargumente, während **kwargs alle Schlüsselwortargumente sammelt.

def print_all(*args, **kwargs):
    for arg in args:
        print(arg)
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_all(1, 2, 3, name="LabEx", age=30)
## Output:
## 1
## 2
## 3
## name: LabEx
## age: 30

In diesem Beispiel werden 1, 2 und 3 als Positionsargumente an *args übergeben, während name und age als Schlüsselwortargumente an **kwargs übergeben werden.

Praktische Beispiele für *args und **kwargs

Variadische Funktion für arithmetische Operationen

Erstellen wir eine Funktion, die verschiedene arithmetische Operationen auf eine beliebige Anzahl von Argumenten ausführen kann.

def arithmetic_operations(*args, operator='+'):
    result = args[0]
    for i in range(1, len(args)):
        if operator == '+':
            result += args[i]
        elif operator == '-':
            result -= args[i]
        elif operator == '*':
            result *= args[i]
        elif operator == '/':
            result /= args[i]
    return result

print(arithmetic_operations(1, 2, 3, 4, operator='+'))  ## Output: 10
print(arithmetic_operations(10, 3, 2, operator='-'))  ## Output: 5
print(arithmetic_operations(2, 3, 4, operator='*'))  ## Output: 24
print(arithmetic_operations(20, 4, operator='/'))  ## Output: 5.0

In diesem Beispiel kann die Funktion arithmetic_operations() eine beliebige Anzahl von Argumenten mit *args akzeptieren, und die gewünschte arithmetische Operation wird mit dem Schlüsselwortargument operator angegeben.

Sammeln von Benutzereingaben mit *args

Angenommen, Sie möchten eine Funktion erstellen, die eine beliebige Anzahl von Benutzereingaben sammelt und in einer Liste speichert.

def collect_inputs(*args):
    user_inputs = []
    for arg in args:
        user_input = input(f"Enter {arg}: ")
        user_inputs.append(user_input)
    return user_inputs

names = collect_inputs("name", "age", "city")
print(names)
## Output:
## Enter name: LabEx
## Enter age: 30
## Enter city: New York
## ['LabEx', '30', 'New York']

In diesem Beispiel verwendet die Funktion collect_inputs() *args, um eine beliebige Anzahl von Eingabeaufforderungen zu akzeptieren, und sammelt dann die Antworten des Benutzers und speichert sie in einer Liste.

Logging-Funktion mit **kwargs

Stellen Sie sich vor, Sie möchten eine Logging-Funktion erstellen, die Nachrichten mit verschiedenen Ebenen (z. B. debug, info, warning, error) protokollieren kann und zusätzliche Metadaten enthalten kann.

def log_message(**kwargs):
    log_level = kwargs.get('level', 'info')
    message = kwargs['message']
    metadata = kwargs.get('metadata', {})

    print(f"[{log_level.upper()}] {message}")
    for key, value in metadata.items():
        print(f"  {key}: {value}")

log_message(level='debug', message='This is a debug message')
## Output:
## [DEBUG] This is a debug message

log_message(level='warning', message='Something unusual happened', metadata={'user': 'LabEx', 'timestamp': '2023-04-18 12:34:56'})
## Output:
## [WARNING] Something unusual happened
##   user: LabEx
##   timestamp: 2023-04-18 12:34:56

In diesem Beispiel verwendet die Funktion log_message() **kwargs, um eine beliebige Anzahl von Schlüsselwortargumenten zu akzeptieren, einschließlich der Log-Ebene, der Nachricht und optionaler Metadaten.

Zusammenfassung

In diesem Python-Tutorial haben Sie gelernt, wie Sie *args und **kwargs effektiv kombinieren können, um flexible und dynamische Funktionsaufrufe zu erstellen. Indem Sie die Unterschiede zwischen diesen beiden Techniken verstehen und wissen, wie Sie sie zusammen verwenden, können Sie leistungsfähigere und anpassungsfähigere Python-Funktionen schreiben, die eine Vielzahl von Eingabeszenarien verarbeiten können. Dieses Wissen wird Ihnen helfen, effizienteren und wartbareren Code zu schreiben und Sie zu einem fähigeren Python-Programmierer zu machen.