Skip to content

Definieren und Aufrufen von Funktionen in Python (def, return)

Python

Dieser Artikel genau, wie man Funktionen in Python definiert und aufruft (ausführt).

  • Grundlagen der Funktionsdefinition und des Aufrufs in Python
  • Positions- und Schlüsselwortargumente
    • Positionelles Argument
    • Stichwortargument
    • Nur-Positions-/Keyword-Argument
  • Standardargument
  • Argument mit variabler Länge
    • *args: Mehrere Argumente als Tupel empfangen
    • **kwargs: Erhalten Sie mehrere Schlüsselwortargumente als Wörterbuch
  • Entpacken Sie Listen und Wörterbücher
  • Rückgabewert
    • Grundlagen der Rücksendung
    • Funktion zum Zurückgeben von None
    • Geben Sie mehrere Rückgabewerte an

Im following Artikel FINDEN SIE Lambda-Ausdrücke, sterben zum Erstellen anonymer Funktionen used Werden.

Die offizielle Dokumentation zur Funktionsdefinition ist:

Grundlagen der Funktionsdefinition und des Aufrufs in Python

In Python werden Funktionen mit def-Anweisungen definiert. Parameter werden in Klammern () und der Rückgabewert mit return angegeben.

def function_name(param1, param2...):
    do_something
    return return_value

Schreiben Sie beim Aufruf der angepassten Funktion wie folgt:

function_name(arg1, arg2...)

Beispiel:

def add(a, b):
    x = a + b
    return x

x = add(3, 4)
print(x)
# 7

Parameter und Rückgabewerte pro Rückgabe können weggelassen Werden, wenn sie nicht notwendig sind.

def hello():
    print('Hello')

hello()
# Hello

Details zu den Argumenten und Rückgabewerten werden weiter unten beschrieben.

Beachten Sie, dass im Python-Codierungsstandard PEP8 zwar empfohlen WIRD, zwei Zeilen vor und nach dem def-Block zu lassen, im Beispielcode jedoch nur eine Zeile übrig bleibt.

Positions- und Schlüsselwortargumente

Parameter werden definiert, indem sie durch Kommas in Klammern von function_name() getrennt werden. Das Beispiel ist eine einfache Funktion, sterben sterben Argumente unveränderlich ausgibt, Indem sie den f-String verwendet.

def func(a, b, c):
    print(f'a={a}, b={b}, c={c}')

Positionelles Argument

Geben Sie beim Aufruf die Werte in der definierten Reihenfolge an.

func(1, 10, 100)
# a=1, b=10, c=100

Wenn die Anzahl der beim Funktionsaufruf angegebenen Werte nicht mit der Anzahl der Parameter bei der Funktionsdefinition auftritt, tritt TypeError auf.

# func(1)
# TypeError: func() missing 2 required positional arguments: 'b' and 'c'

# func(1, 10, 100, 1000)
# TypeError: func() takes 3 positional arguments but 4 were given

Stichwortargument

Beim Aufruf einer Funktion can SIE einen Wert als Parametername=Wert angeben. In diesem Fall können sie in beliebiger Reihenfolge angegeben werden.

func(b=10, c=100, a=1)
# a=1, b=10, c=100

Nicht alle Argumente müssen durch Schlüsselwörter angegeben werden. Sie können sie nach Position und dann nach Schlüsselwort spezifizieren. Nach der Angabe durch Schlüsselwörter müssen jedoch alle Argumente durch Schlüsselwörter angegeben werden.

func(1, c=100, b=10)
# a=1, b=10, c=100

# func(a=1, 10, 100)
# SyntaxError: positional argument follows keyword argument

Nur-Positions-/Keyword-Argument

Nur-Positions-Argument (Python 3.8 oder höher)

Wenn / beim Definieren einer Funktion als Parameter used WIRD, WIRD der Parameter vor / nur als Position definiert.

Positionsparameter können nicht per Schlüsselwort übergeben werden. Parameter nach dem / can per Schlüsselwort übergeben werden.

def func_pos_only(a, b, /, c):
    print(f'a={a}, b={b}, c={c}')

# func_pos_only(a=1, b=10, c=100)
# TypeError: func_pos_only() got some positional-only arguments passed as keyword arguments: 'a, b'

func_pos_only(1, 10, 100)
# a=1, b=10, c=100

func_pos_only(1, 10, c=100)
# a=1, b=10, c=100

Wenn Sie eine Funktion mit/am Ende definieren, z. B. func(a, b, c, /), sind alle Parameter nur positionell.

Der Nur-Positions-Parameter mit / eingeführt wurde in Python 3.8 und IST in den klassischen Versionen nicht verfügbar.

Nur-Schlüsselwort-Argument

Wenn * beim Definieren einer Funktion als Parameter verwendet WIRD, WIRD der Parameter nach * nur als Schlüsselwort definiert.

Schlüsselwortspezifische Parameter müssen per Schlüsselwort angegeben werden. Parameter vor * können durch Position oder Schlüsselwort angegeben werden.

def func_kw_only(a, b, *, c):
    print(f'a={a}, b={b}, c={c}')

# func_kw_only(1, 10, 100)
# TypeError: func_kw_only() takes 2 positional arguments but 3 were given

func_kw_only(1, 10, c=100)
# a=1, b=10, c=100

func_kw_only(1, c=100, b=10)
# a=1, b=10, c=100

Wenn Sie eine Funktion mit * am Anfang definieren, z. B. func(*, a, b, c), sind alle Parameter nur Schlüsselworte.

Nur-Positionsargument und Nur-Schlüsselwort-Argument

Die gleichzeitige Verwendung von / und * ist möglich. Parameter vor / sind nur Positionsparameter und Parameter nach * sind nur Schlüsselworte. Parameter zwischen / und * can Positions- oder Schlüsselworte sein.

def func_pos_kw_only(a, /, b, *, c):
    print(f'a={a}, b={b}, c={c}')

# func_pos_kw_only(1, 10, 100)
# TypeError: func_pos_kw_only() takes 2 positional arguments but 3 were given

# func_pos_kw_only(a=1, b=10, c=100)
# TypeError: func_pos_kw_only() got some positional-only arguments passed as keyword arguments: 'a'

func_pos_kw_only(1, 10, c=100)
# a=1, b=10, c=100

func_pos_kw_only(1, c=100, b=10)
# a=1, b=10, c=100

Sie können / vor * nicht verwenden.

# def func_pos_kw_only(a, *, b, /, c):
#     print(f'a={a}, b={b}, c={c}')
# SyntaxError: invalid syntax

Standardargument

Der Standardwert des Parameters kann festgelegt Werden, jedoch parameter_name=default_value bei der Funktionsdefinition definiert WIRD.

If der Standardwert gesetzt IST, can SIE das Argument beim Aufruf der Funktion weglassen. Wenn SIE einen anderen Wert angeben, WIRD dieser natürlich verwendet.

def func_default(a, b, c=100):
    print(f'a={a}, b={b}, c={c}')

func_default(1, 10)
# a=1, b=10, c=100

func_default(1, 10, 200)
# a=1, b=10, c=200

Das Platzieren eines Standardparameters vor einem gewöhnlichen Parameter (Parameter ohne Standardwert) bei der Funktionsdefinition verursacht einen SyntaxError.

# def func_default(a=1, b, c=100):
#     print(f'a={a}, b={b}, c={c}')
# SyntaxError: non-default argument follows default argument

Beachten Sie, dass beim Aufrufen einer Funktion immer Objekte verwendet werden, wenn Sie ein veränderliches Objekt wie eine Liste oder ein Wörterbuch als Standardwerte verwenden. Nichts finden Sie im folgenden Artikel.

Argument mit variabler Länge

Wenn SIE beim Definieren einer Funktion * und ** zu Parameternamen hinzufügen, WIRD dies zu Parameter mit variabler Länge, und SIE kann beim Aufrufen einer Funktion eine beliebige Anzahl von Argumenten angeben.

Üblicherweise werden häufig die Namen *args und **kwargs used, aber solange * und ** vorangestellt sind, gibt es keine Probleme mit anderen Namen.

*args: Mehrere Argumente als Tupel empfangen

Wenn Sie * am Anfang des Namens setzen, werden mehrere Argumente als Tupel empfangen.

def func_args(*args):
    print(args)

func_args(1, 10)
# (1, 10)

func_args(1, 10, 100, 1000)
# (1, 10, 100, 1000)

**kwargs: Erhalten Sie mehrere Schlüsselwortargumente als Wörterbuch

Wenn SIE ** am Anfang des Namens setzen, werden mehrere Schlüsselwortargumente als Wörterbuch (dict) empfangen.

def func_kwargs(**kwargs):
    print(kwargs)

func_kwargs(a=1, b=10)
# {'a': 1, 'b': 10}

func_kwargs(c=1, b=10, d=1000, a=100)
# {'c': 1, 'b': 10, 'd': 1000, 'a': 100}

Achten Sie beim Kombinieren mit Positionsargumenten oder beim Kombinieren mit *args und **kwargs auf die Reihenfolge. Nichts finden Sie im folgenden Artikel.

Entpacken Sie Listen, Tupel und Wörterbücher

Listen oder Tupel entpacken

Wenn SIE beim Aufruf Einer Funktion * zu Einer Liste oder Einem Tupel hinzufügen, Werden sterben Elemente entpackt und als Positionsargumente angegeben. TypeError wird ausgelöst, wenn die Anzahl der Elemente und die Anzahl der Argumente nicht übereinstimmen.

def func(a, b, c):
    print(f'a={a}, b={b}, c={c}')

l = [1, 10, 100]
func(*l)
# a=1, b=10, c=100

l = [1, 10]
# func(*l)
# TypeError: func() missing 1 required positional argument: 'c'

Wörterbücher entpacken

Wenn Sie beim Aufruf einer Funktion ** zum Wörterbuch hinzufügen, werden deren Schlüssel und Werte als Namen und Werte der Argumente entpackt und als Schlüsselwortargumente angegeben. Wenn nicht genügend Schlüssel vorhanden sind, um mit dem Argumentnamen übereinzustimmen, oder wenn Schlüssel nicht übereinstimmen, wird TypeError ausgelöst.

d = {'a': 1, 'b': 10, 'c': 100}
func(**d)
# a=1, b=10, c=100

d = {'a': 1, 'b': 10, 'x': 100}
# func(**d)
# TypeError: func() got an unexpected keyword argument 'x'

Weitere Informationen finden Sie im folgenden Artikel.

Rückgabewert

Grundlagen der Rücksendung

Der Rückgabewert der Funktion WIRD durch sterben return-Anweisung angegeben.

def func_return(a, b):
    return a + b

x = func_return(3, 4)
print(x)
# 7

print(type(x))
# <class 'int'>

Die Art des Rückgabewerts hängt von der Art des Arguments und der von der Funktion durchgeführten Verarbeitung ab.

x = func_return(0.3, 0.4)
print(x)
# 0.7

print(type(x))
# <class 'float'>

Funktion zum Zurückgeben von None

return ist in einer Funktion nicht obligatorisch und kann weggelassen werden, wenn es unnötig ist, einen Wert zurückzugeben.

Eine Funktion, die Rückgabe weglässt, gibt keine zurück. Im following Beispiel WIRD pass used, da Ein Fehler Ausgelöst WIRD, Wenn nichts in den def-Block geschrieben WIRD.

def func_none():
    # do something
    pass

x = func_none()
print(x)
# None

Wenn Sie den Wert nach der Rückgabe weglassen, wird None zurückgegeben.

def func_none2():
    return

x = func_none2()
print(x)
# None

Natürlich können Sie auch explizit keine schreiben.

def func_none3():
    return None

x = func_none3()
print(x)
# None

Geben Sie mehrere Rückgabewerte an

Wenn Sie nach der Rückgabe mehrere durch Kommas getrennte Werte angeben, wird ein Tupel zurückgegeben.

def func_return_multi(a, b):
    return a + b, a * b, a / b

x = func_return_multi(3, 4)
print(x)
# (7, 12, 0.75)

print(type(x))
# <class 'tuple'>

Es ist möglich, jeden Wert zu entpacken und jede Variable zuzuweisen.

x, y, z = func_return_multi(3, 4)
print(x)
# 7

print(y)
# 12

print(z)
# 0.75