Python Funktionen erklärt: Wiederverwendbare Code-Module erstellen

Was sind Funktionen in Python?

Eine Funktion ist ein Block organisierten, wiederverwendbaren Codes, der verwendet wird, um eine einzelne, zusammenhängende Aktion auszuführen. Funktionen bieten bessere Modularität für Ihre Anwendung und einen hohen Grad an Code-Wiederverwendung.

Wie Sie bereits wissen, bietet Python viele eingebaute Funktionen wie print() etc., aber Sie können auch Ihre eigenen Funktionen erstellen. Diese nennt man benutzerdefinierte Funktionen.

Eine Funktion definieren

Sie können Funktionen definieren, um die gewünschte Funktionalität bereitzustellen. Hier sind einfache Regeln für die Definition einer Funktion in Python:

• Funktionsblöcke beginnen mit dem Schlüsselwort def, gefolgt vom Funktionsnamen und Klammern ( ( ) ).

• Eingabeparameter oder Argumente sollten innerhalb dieser Klammern platziert werden. Sie können auch Parameter innerhalb dieser Klammern definieren.

• Die erste Anweisung einer Funktion kann eine optionale Anweisung sein – der Dokumentationsstring der Funktion oder Docstring.

• Der Codeblock innerhalb jeder Funktion beginnt mit einem Doppelpunkt (:) und ist eingerückt.

• Die Anweisung return [expression] verlässt eine Funktion und gibt optional einen Ausdruck an den Aufrufer zurück. Ein return ohne Argumente entspricht return None.

Syntax

def funktionsname(parameter):
    "funktions_docstring"
    funktions_suite
    return [expression]

Standardmäßig haben Parameter ein positionelles Verhalten und Sie müssen sie in der Reihenfolge übergeben, in der sie definiert wurden.

Beispiel

Die folgende Funktion nimmt einen String als Eingabeparameter und gibt ihn auf dem Standardbildschirm aus.

def printme(str):
    "This prints a passed string into this function"
    print str
    return

Eine Funktion aufrufen

Eine Funktion zu definieren gibt ihr nur einen Namen, spezifiziert die einzuschließenden Parameter und strukturiert die Codeblöcke.

Sobald die grundlegende Struktur einer Funktion feststeht, können Sie sie ausführen, indem Sie sie von einer anderen Funktion oder direkt vom Python-Prompt aus aufrufen. Beispiel für den Aufruf von printme():

#!/usr/bin/python
# Funktionsdefinition
def printme(str):
    "This prints a passed string into this function"
    print str
    return
# Jetzt printme aufrufen
printme("I'm first call to user defined function!")
printme("Again second call to the same function")

Wenn der obige Code ausgeführt wird, erzeugt er folgendes Ergebnis:

I'm first call to user defined function!
Again second call to the same function

Call by Reference vs. Value

Alle Parameter (Argumente) in Python werden per Referenz übergeben. Das bedeutet, wenn Sie ändern, worauf ein Parameter innerhalb einer Funktion verweist, spiegelt sich die Änderung auch in der aufrufenden Funktion wider. Zum Beispiel:

#!/usr/bin/python
# Funktionsdefinition
def changeme(mylist):
    "This changes a passed list into this function"
    mylist.append([1,2,3,4])
    print "Values inside the function: ", mylist
    return
# Jetzt changeme aufrufen
mylist = [10,20,30]
changeme(mylist)
print "Values outside the function: ", mylist

Hier behalten wir die Referenz des übergebenen Objekts bei und fügen Werte im selben Objekt an. Dies erzeugt folgendes Ergebnis:

Values inside the function: [10, 20, 30, [1, 2, 3, 4]]
Values outside the function: [10, 20, 30, [1, 2, 3, 4]]

Ein weiteres Beispiel, bei dem das Argument per Referenz übergeben wird und die Referenz innerhalb der aufgerufenen Funktion überschrieben wird:

#!/usr/bin/python
# Funktionsdefinition
def changeme(mylist):
    "This changes a passed list into this function"
    mylist = [1,2,3,4]  # Dies weist neue Referenz in mylist zu
    print "Values inside the function: ", mylist
    return
# Jetzt changeme aufrufen
mylist = [10,20,30]
changeme(mylist)
print "Values outside the function: ", mylist

Der Parameter mylist ist lokal zur Funktion changeme. Das Ändern von mylist innerhalb der Funktion beeinflusst mylist außen nicht. Die Funktion bewirkt nichts und erzeugt folgendes Ergebnis:

Values inside the function: [1, 2, 3, 4]
Values outside the function: [10, 20, 30]

Funktionsargumente

Sie können eine Funktion mit folgenden Arten von formalen Argumenten aufrufen:

• Erforderliche Argumente (Required arguments)
• Keyword-Argumente (Keyword arguments)
• Standardargumente (Default arguments)
• Variable-Längen-Argumente (Variable-length arguments)

Erforderliche Argumente

Erforderliche Argumente sind Argumente, die in korrekter positioneller Reihenfolge an eine Funktion übergeben werden. Hier muss die Anzahl der Argumente im Funktionsaufruf exakt mit der Funktionsdefinition übereinstimmen.

Um die Funktion printme() aufzurufen, müssen Sie definitiv ein Argument übergeben, andernfalls erhalten Sie einen Syntaxfehler:

#!/usr/bin/python
def printme(str):
    "This prints a passed string into this function"
    print str
    return
printme()

Ergebnis:

Traceback (most recent call last):
  File "test.py", line 11, in 
    printme()
TypeError: printme() takes exactly 1 argument (0 given)

Keyword-Argumente

Keyword-Argumente beziehen sich auf Funktionsaufrufe. Wenn Sie Keyword-Argumente in einem Funktionsaufruf verwenden, identifiziert der Aufrufer die Argumente über den Parameternamen.

Dies erlaubt Ihnen, Argumente auszulassen oder in anderer Reihenfolge zu platzieren, da der Python-Interpreter die Werte mithilfe der Keywords den Parametern zuordnen kann. Sie können printme() auch so aufrufen:

#!/usr/bin/python
def printme(str):
    "This prints a passed string into this function"
    print str
    return
printme(str="My string")

Ergebnis:

My string

Das folgende Beispiel gibt ein klareres Bild. Beachten Sie, dass die Reihenfolge der Parameter keine Rolle spielt:

#!/usr/bin/python
def printinfo(name, age):
    "This prints a passed info into this function"
    print "Name: ", name
    print "Age ", age
    return
printinfo(age=50, name="miki")

Ergebnis:

Name: miki
Age 50

Standardargumente (Default Arguments)

Ein Standardargument ist ein Argument, das einen Standardwert annimmt, wenn für dieses Argument kein Wert im Funktionsaufruf übergeben wird. Das folgende Beispiel verdeutlicht Standardargumente – es gibt das Standardalter aus, falls es nicht übergeben wird:

#!/usr/bin/python
def printinfo(name, age=35):
    "This prints a passed info into this function"
    print "Name: ", name
    print "Age ", age
    return
printinfo(age=50, name="miki")
printinfo(name="miki")

Ergebnis:

Name: miki
Age 50
Name: miki
Age 35

Variable-Längen-Argumente

Sie müssen möglicherweise eine Funktion für mehr Argumente verarbeiten, als Sie bei der Definition angegeben haben. Diese Argumente heißen variable-length Argumente und werden in der Funktionsdefinition nicht namentlich aufgeführt, im Gegensatz zu erforderlichen und Standardargumenten.

Syntax für eine Funktion mit nicht-Keyword-variablen Argumenten:

def funktionsname([formale_args,] *var_args_tupel):
    "funktions_docstring"
    funktions_suite
    return [expression]

Ein Sternchen (*) wird vor den Variablennamen gesetzt, der die Werte aller nicht-Keyword-variablen Argumente hält. Dieses Tupel bleibt leer, wenn während des Funktionsaufrufs keine zusätzlichen Argumente angegeben werden. Einfaches Beispiel:

#!/usr/bin/python
def printinfo(arg1, *vartuple):
    "This prints a variable passed arguments"
    print "Output is: "
    print arg1
    for var in vartuple:
        print var
    return
printinfo(10)
printinfo(70, 60, 50)

Ergebnis:

Output is: 10
Output is: 70 60 50

Anonyme Funktionen (Lambda)

Diese Funktionen heißen anonym, weil sie nicht auf die Standardweise mit dem def-Schlüsselwort deklariert werden. Sie können das lambda-Schlüsselwort verwenden, um kleine anonyme Funktionen zu erstellen.

• Lambda-Formen können beliebig viele Argumente annehmen, geben aber nur einen Wert in Form eines Ausdrucks zurück. Sie können keine Befehle oder mehrere Ausdrücke enthalten.

• Eine anonyme Funktion kann kein direkter Aufruf von print sein, da lambda einen Ausdruck erfordert.

• Lambda-Funktionen haben ihren eigenen lokalen Namensraum und können nicht auf Variablen zugreifen, die nicht in ihrer Parameterliste oder im globalen Namensraum sind.

• Obwohl lambda wie eine Einzeiler-Version einer Funktion aussieht, sind sie nicht äquivalent zu Inline-Statements in C/C++, deren Zweck darin besteht, Funktionsstapel-Allokation während des Aufrufs für Performance-Gründe zu umgehen.

Syntax

Die Syntax von lambda-Funktionen enthält nur eine einzelne Anweisung:

lambda [arg1 [,arg2,.....argn]]: expression

Beispiel zur Funktionsweise von lambda:

#!/usr/bin/python
sum = lambda arg1, arg2: arg1 + arg2
print "Value of total : ", sum(10, 20)
print "Value of total : ", sum(20, 20)

Ergebnis:

Value of total : 30
Value of total : 40

Die return-Anweisung

Die Anweisung return [expression] verlässt eine Funktion und gibt optional einen Ausdruck an den Aufrufer zurück. Ein return ohne Argumente entspricht return None.

Alle bisherigen Beispiele geben keinen Wert zurück. Sie können einen Wert aus einer Funktion wie folgt zurückgeben:

#!/usr/bin/python
def sum(arg1, arg2):
    total = arg1 + arg2
    print "Inside the function : ", total
    return total
total = sum(10, 20)
print "Outside the function : ", total

Ergebnis:

Inside the function : 30
Outside the function : 30

Gültigkeitsbereich von Variablen (Scope)

Nicht alle Variablen in einem Programm sind an allen Stellen zugänglich. Dies hängt davon ab, wo Sie eine Variable deklariert haben.

Der Gültigkeitsbereich einer Variable bestimmt den Teil des Programms, in dem Sie auf einen bestimmten Bezeichner zugreifen können. Es gibt zwei grundlegende Gültigkeitsbereiche in Python:

• Globale Variablen
• Lokale Variablen

Globale vs. Lokale Variablen

Variablen, die innerhalb eines Funktionskörpers definiert sind, haben einen lokalen Gültigkeitsbereich, und solche, die außerhalb definiert sind, haben einen globalen Gültigkeitsbereich.

Das bedeutet, dass lokale Variablen nur innerhalb der Funktion zugänglich sind, in der sie deklariert wurden, während globale Variablen im gesamten Programmkörper von allen Funktionen aus zugänglich sind. Wenn Sie eine Funktion aufrufen, werden die darin deklarierten Variablen in den Gültigkeitsbereich gebracht. Einfaches Beispiel:

#!/usr/bin/python
total = 0  # Globale Variable
def sum(arg1, arg2):
    total = arg1 + arg2  # Hier ist total lokale Variable
    print "Inside the function local total : ", total
    return total
sum(10, 20)
print "Outside the function global total : ", total

Ergebnis:

Inside the function local total : 30
Outside the function global total : 0