Funktionsargumente in

Über Funktionsargumente

Die Grundlagen zu Funktionsargumenten findest du im Konzept zu Funktionen.

Parameternamen

Parameternamen müssen, genau wie Variablennamen, mit einem Buchstaben oder einem Unterstrich beginnen und dürfen Buchstaben, Unterstriche oder Zahlen enthalten. Parameternamen sollten keine Leerzeichen oder Satzzeichen enthalten.

Positionsargumente

Positionsargumente sind Werte, die einer Funktion in derselben Reihenfolge übergeben werden wie die Parameter, an die sie gebunden werden. Positionsargumente lassen sich auf Wunsch auch über ihren Parameternamen übergeben:

def concat(greeting, name):
    return f"{greeting}{name}"

# Passing data to the function by position.
print(concat("Hello, ", "Lilly"))
#->  Hello, Lilly

# Passing data to the function using the parameter name.
print(concat(name="Glenn", greeting="Hello, "))
#-> Hello, Glenn

Der erste Aufruf von concat übergibt die Argumente nach ihrer Position. Der zweite Aufruf von concat übergibt die Argumente über ihren Namen, wodurch sich ihre Positionen ändern lassen.

Beachte, dass Positionsargumente nicht auf Argumente folgen können, die über den Namen übergeben werden (auch Schlüsselwortargumente genannt. Nicht zu verwechseln mit var-positionalen Parametern oder **kwargs).

Diese Argumente:

print(concat(greeting="Hello, ", "Gregor"))

führen zu diesem Fehler:

SyntaxError: positional argument follows keyword argument

Wenn du für Funktionsaufrufe ausschließlich Positionsargumente verlangen willst, kannst du den /-Operator in der Parameterliste verwenden:

# Parameters showing a position-only operator. 
def concat(greeting, name, /):
    return f"{greeting}{name}"

print(concat("Hello, ", "Ginnie"))
#-> Hello, Ginnie

# Call to the function using keyword arguments.
print(concat(name="Franklin", greeting="Hello, "))
Traceback (most recent call last):
    print(concat(name="Franklin", greeting="Hello, "))
TypeError: concat() got some positional-only arguments passed as keyword arguments: 'greeting, name'

Schlüsselwortargumente

Schlüsselwortargumente verwenden beim Aufruf einer Funktion den Parameternamen. Sie können auf Wunsch auch über ihre Position angegeben werden:

def concat(greeting, name):
    return f"{greeting}{name}"

# Function call using parameter names as argument keywords.
print(concat(name="Eliza", greeting="Hello, "))
#-> Hello, Eliza

# Function call with positional data as arguments.
print(concat("Hello, ", "Tim"))
#-> Hello, Tim

Wenn du für Funktionsaufrufe ausschließlich Schlüsselwortargumente verlangen willst, kannst du den *-Operator in der Parameterliste verwenden:

# Function definition requiring keyword-only arguments.
def concat(*, greeting, name):
    return f"{greeting}{name}"

# Keyword arguments can be in an arbitrary order.
print(concat(name="Kimmie", greeting="Hello, "))
#-> Hello, Kimmie

# Calling the function with positional data raises an error.
print(concat("Hello, ", "Coleen"))
Traceback (most recent call last):
    print(concat("Hello, ", "Coleen"))
TypeError: concat() takes 0 positional arguments but 2 were given

Standardwerte für Argumente

In der Parameterliste kannst du Standardwerte für ein oder mehrere Argumente angeben. Dadurch lässt sich die Funktion bei Bedarf mit weniger Argumenten aufrufen. Standardwerte lassen sich überschreiben, indem du die Funktion mit einem neuen Argumentwert aufrufst, der den Standardwert ersetzt:

# Function with default argument values.
def concat(greeting, name="you", punctuation="!"):
    return f"{greeting}, {name}{punctuation}"

print(concat("Hello"))
#-> Hello, you!

# Overriding the default values
print(concat("Hello", name="Polly", punctuation="."))
#-> Hello, Polly.

Argumente nach Position oder Schlüsselwort

Argumente können nach Position oder über ein Schlüsselwort übergeben werden, wenn in den Parameterdefinitionen weder der /- noch der *-Operator verwendet wird. Alternativ lassen sich die Positions-oder-Schlüsselwort-Argumente zwischen den reinen Positionsparametern links und den reinen Schlüsselwortparametern rechts platzieren:

# Position-only argument followed by position-or-keyword, followed by keyword-only.
def concat(greeting, /, name, *, ending):
    return f"{greeting}{name}{ending}"

print(concat("Hello, ", "Mark", ending="!"))
#-> Hello, Mark!

print(concat("Hello, ", name="Rachel", ending="!"))
#-> Hello, Rachel!

print(concat(greeting="Hello, ", name="JoJo", ending="!"))
Traceback (most recent call last):
    print(concat(greeting="Hello, ", name="JoJo", ending="!"))
TypeError: concat() got some positional-only arguments passed as keyword arguments: 'greeting'

*args

Codebeispiele verwenden oft eine Funktionsdefinition wie die folgende:

def my_function(*args, **kwargs):
    # code snipped

*args ist ein zweiteiliger Name, der ein tuple mit einer unbestimmten Anzahl einzelner Positionsargumente darstellt, auch bekannt als variadic argument. args ist der Name, der dem tuple der Argumente gegeben wird, aber es könnte jeder andere gültige Python-Name sein, wie my_args, arguments usw. Der * ist der Operator, der die Gruppe einzelner Argumente in ein tuple umwandelt.

Da ein tuple iterierbar ist, kann args an jede andere Funktion übergeben werden, die ein iterierbares Objekt entgegennimmt. Obwohl *args häufig zusammen mit **kwargs auftritt, muss das nicht so sein:

def add(*args):
    # args is passed to the sum function, which iterates over it.
    return sum(args)

print(add(1, 2, 3))
#-> 6

Wenn *args nach einem oder mehreren Positionsargumenten steht, dann enthält *args den Rest nach diesen Positionsargumenten:

def add(first, *args):
    # first will be 1, leaving the values 2 and 3 in *args
    return first + sum(args)

print(add(1, 2, 3))
#-> 6

Wenn nach *args ein oder mehrere Standardargumente definiert sind, sind sie von den Werten in *args getrennt:

def add(first, *args, last=0):
    return first + sum(args) + last
 
print(add(1, 2, 3))
#-> 6

print(add(1, 2, 3, last=4))
#-> 10

# This uses the unpacking operator * to separate the list elements into positional arguments.
# It does not have the same behavior as the * (packing) in *args.
print(add(*[1, 2, 3]))
#-> 6

Beachte: Wenn ein Argument bereits in einem iterable steckt (etwa in einem tuple oder list), muss es entpackt werden, bevor es an eine Funktion übergeben wird, die eine beliebige Anzahl einzelner Argumente entgegennimmt. Dafür verwendest du *, den Entpackungsoperator.

* entpackt in diesem Zusammenhang den Container in seine einzelnen Elemente, die dann von *args in ein Tupel umgewandelt werden. Wenn es nur Positionsargumente gibt, muss das Entpacken zu ebenso vielen Argumenten führen, wie formale Parameter definiert sind.

Ohne das Entpacken der in add übergebenen Liste würde das Programm einen Fehler ausgeben:

def add(first, *args, last=0):
    return first + sum(args) + last

print(add([1, 2, 3]))
Traceback (most recent call last):
    print(add([1, 2, 3]))
    return first + sum(args) + last
TypeError: can only concatenate list (not "int") to list

**kwargs

**kwargs ist ein zweiteiliger Name, der eine unbestimmte Anzahl einzelner Schlüssel-Wert-Paare als Argumente darstellt. kwargs ist der Name dieser Argumentgruppe und könnte jeder andere Name sein, wie my_args, arguments usw. Das ** wandelt die Gruppe benannter Argumente in ein dictionary aus Paaren der Form {argument name: argument value} um.

Da ein Wörterbuch iterierbar ist, kann kwargs an jede andere Funktion übergeben werden, die ein iterierbares Objekt entgegennimmt. Obwohl **kwargs häufig zusammen mit *args auftritt, muss das nicht so sein:

def add(**kwargs):
    return sum(kwargs.values())

print(add(one=1, two=2, three=3))
#-> 6

Beachte, dass die Methode dict.values() aufgerufen wird, um durch die values des Wörterbuchs kwargs zu iterieren. Beim Iterieren über ein Wörterbuch werden standardmäßig die keys durchlaufen, daher muss dict.values() explizit angegeben werden:

def concat(**kwargs):
    # Join concatenates the tuples from `kwargs.items()`
    return " ".join((str(item) for item in kwargs.items()))

print(concat(one=1, two=2, three=3))
#-> ('one', 1) ('two', 2) ('three', 3)