Python Function Arguments

Table of Contents

In Python können Sie eine Funktion definieren, die eine variable Anzahl von Argumenten akzeptiert. In diesem Artikel erfahren Sie, wie Sie solche Funktionen mit Standard-, Schlüsselwort- und beliebigen Argumenten definieren.

 

Argumente

Im Thema Benutzerdefinierte Funktion haben wir gelernt, wie eine Funktion definiert und aufgerufen wird. Andernfalls führt der Funktionsaufruf zu einem Fehler. Hier ist ein Beispiel.

def greet(name, msg):
    """Diese Funktion grüßt an
    die Person mit der bereitgestellten Nachricht"""
    print("Hallo", name + ', ' + msg)

greet("Ruby", "Guten Morgen!")

 

Output

Hallo Ruby, Guten Morgen!

 

Hier ist die Funktion greet() hat zwei Parameter.

Da wir diese Funktion mit zwei Argumenten aufgerufen haben, läuft sie reibungslos und wir erhalten keinen Fehler.

Wenn wir es mit einer anderen Anzahl von Argumenten aufrufen, zeigt der Interpreter eine Fehlermeldung an. Unten ist ein Aufruf dieser Funktion mit einem und keinem Argument zusammen mit den entsprechenden Fehlermeldungen.

 

>>> greet("Ruby")    # nur ein argument
TypeError: greet() 1 erforderliches Positionsargument fehlt: 'msg'

 

 

>>> greet()    # Nein arguments
TypeError: greet() missing 2 required positional arguments: 'name' and 'msg

 

 

 

Argumente für Variablenfunktionen

Bisher hatten Funktionen eine feste Anzahl von Argumenten. In Python gibt es andere Möglichkeiten, eine Funktion zu definieren, die eine variable Anzahl von Argumenten annehmen kann.

Im Folgenden werden drei verschiedene Formen dieser Art beschrieben.

 

Python Default Arguments

Funktionsargumente können in Python Standardwerte haben.

Wir können einem Argument einen Standardwert zuweisen, indem wir den Zuweisungsoperator (=) verwenden. Hier ist ein Beispiel.

 

def greet(name, msg="Guten Morgen!"):
    """
    Diese Funktion grüßt an
    die Person mit der
    bereitgestellte Nachricht.

    Wenn die Nachricht nicht bereitgestellt wird,
    es ist standardmäßig " Guten Morgen!"
    """

    print("Hallo", name + ', ' + msg)


greet("John")
greet("Wick", "Wie machen Sie?")

 

Output

Hallo John, Guten Morgen!
Hallo Wick, Wie machen Sie?

 

In dieser Funktion ist der Parameter name hat keinen Standardwert und wird während eines Anrufs benötigt (obligatorisch).

Andererseits ist der Parameter msg hat einen Standardwert von "Guten Morgen!".
Es ist also während eines Anrufs optional. Wenn ein Wert angegeben wird, wird der Standardwert überschrieben.

Eine beliebige Anzahl von Argumenten in einer Funktion kann einen Standardwert haben. Aber sobald wir ein Standardargument haben, müssen alle Argumente rechts davon auch Standardwerte haben.

Dies bedeutet, dass Nicht-Standardargumente nicht auf Standardargumente folgen können. Wenn wir beispielsweise den Funktionsheader oben wie folgt definiert hätten:

 

def greet(msg = "Guten Morgen!", name):

 

Wir würden einen Fehler wie folgt erhalten:

SyntaxError: Nicht-Standardargument folgt Standardargument

 

 

Python Keyword Arguments

 

Wenn wir eine Funktion mit einigen Werten aufrufen, werden diese Werte den Argumenten entsprechend ihrer Position zugewiesen.

Zum Beispiel in der obigen Funktion greet(), als wir es so nannten greet("Wick", "Wie machen Sie?"), der Wert "Bruce" wird dem Argument zugewiesen name und ähnlich "Wie machen Sie?" to msg.

 

Python ermöglicht den Aufruf von Funktionen mithilfe von Schlüsselwortargumenten. Wenn wir Funktionen auf diese Weise aufrufen, kann die Reihenfolge (Position) der Argumente geändert werden. Die folgenden Aufrufe der obigen Funktion sind alle gültig und führen zum gleichen Ergebnis.

 

# 2 Keyword Argumente
greet(name = "Wick",msg = "Wie machen Sie?")

# 2 Keyword-Argumente (außer Betrieb)
greet(msg = "Wie machen Sie?",name = "Wick") 

# 1 Positionell, 1 Schlüsselwortargument
greet("Wick", msg = "Wie machen Sie?")

 

Wie wir sehen, können wir während eines Funktionsaufrufs Positionsargumente mit Schlüsselwortargumenten mischen. Aber wir müssen bedenken, dass Schlüsselwortargumente auf Positionsargumente folgen müssen.

Ein Positionsargument nach Schlüsselwortargumenten führt zu Fehlern. Zum Beispiel der Funktionsaufruf wie folgt:

 

greet(name="Wick","Wie machen Sie?")

 

Wird zu einem Fehler führen:

SyntaxError: non-keyword arg after keyword arg

 

 

 

Python Arbitrary Arguments

Manchmal wissen wir nicht im Voraus die Anzahl der Argumente, die an eine Funktion übergeben werden sollen. Python erlaubt uns, diese Art von Situation durch Funktionsaufrufe mit einer beliebigen Anzahl von Argumenten zu behandeln.

In der Funktionsdefinition verwenden wir ein Sternchen (*) vor dem Parameternamen, um diese Art von Argumenten zu kennzeichnen. Hier ist ein Beispiel.

def greet(*names):
    """Diese Funktion grüßt alle
    die Person im Namenstupel."""

    # name ist ein Tupel mit Argumenten
    for name in names:
        print("Hallo", name)


greet("Monica", "Luke", "Steve", "John")

 

Output

Hallo Monica
Hallo Luke
Hallo Steve
Hallo John

 

Hier haben wir die Funktion mit mehreren Argumenten aufgerufen. Diese Argumente werden in ein Tupel verpackt, bevor sie an die Funktion übergeben werden. Innerhalb der Funktion verwenden wir a for Schleife, um alle Argumente zurückzuholen.