Python-Funktionsargumente

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

Video:Python-Funktionsargumente:Position, Schlüsselwörter und Standard

Argumente

Im Thema benutzerdefinierte Funktionen haben wir gelernt, wie man eine Funktion definiert und aufruft. Andernfalls führt der Funktionsaufruf zu einem Fehler. Hier ist ein Beispiel.

def greet(name, msg):
    """This function greets to
    the person with the provided message"""
    print("Hello", name + ', ' + msg)

greet("Monica", "Good morning!")

Ausgabe

Hello Monica, Good morning!

Hier die Funktion greet() hat zwei Parameter.

Da wir diese Funktion mit zwei Argumenten aufgerufen haben, läuft sie flüssig und wir bekommen 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("Monica")    # only one argument
TypeError: greet() missing 1 required positional argument: 'msg'

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

Variable Funktionsargumente

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-Standardargumente

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="Good morning!"):
    """
    This function greets to
    the person with the
    provided message.

    If the message is not provided,
    it defaults to "Good
    morning!"
    """

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


greet("Kate")
greet("Bruce", "How do you do?")

Ausgabe

Hello Kate, Good morning!
Hello Bruce, How do you do?

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

Andererseits der Parameter msg hat einen Standardwert von "Good morning!" . 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 daneben auch Standardwerte haben.

Das bedeutet, dass Nicht-Standardargumente nicht auf Standardargumente folgen können. Wenn wir zum Beispiel den Funktionskopf oben wie folgt definiert hätten:

def greet(msg = "Good morning!", name):

Wir würden einen Fehler erhalten als:

SyntaxError: non-default argument follows default argument

Python-Schlüsselwortargumente

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

Zum Beispiel in der obigen Funktion greet() , als wir es als greet("Bruce", "How do you do?") bezeichneten , der Wert "Bruce" wird dem Argument name zugewiesen und ähnlich "How do you do?" zu msg .

Python ermöglicht den Aufruf von Funktionen mit 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 erzeugen das gleiche Ergebnis.

# 2 keyword arguments
greet(name = "Bruce",msg = "How do you do?")

# 2 keyword arguments (out of order)
greet(msg = "How do you do?",name = "Bruce") 

1 positional, 1 keyword argument
greet("Bruce", msg = "How do you do?")

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

Ein Positionsargument nach Schlüsselwortargumenten führt zu Fehlern. Der Funktionsaufruf lautet beispielsweise wie folgt:

greet(name="Bruce","How do you do?")

Führt zu einem Fehler:

SyntaxError: non-keyword arg after keyword arg

Beliebige Python-Argumente

Manchmal wissen wir nicht im Voraus, wie viele Argumente an eine Funktion übergeben werden. Python ermöglicht es uns, diese Art von Situation durch Funktionsaufrufe mit einer beliebigen Anzahl von Argumenten zu handhaben.

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

def greet(*names):
    """This function greets all
    the person in the names tuple."""

    # names is a tuple with arguments
    for name in names:
        print("Hello", name)


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

Ausgabe

Hello Monica
Hello Luke
Hello Steve
Hello 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 einen for Schleife, um alle Argumente zurückzuholen.

Python-Funktionen Python-Rekursion

Python