Funktionen sind ein wichtiger Bestandteil von Python und werden genutzt, um Codeblöcke zu definieren, die zu einem späteren Zeitpunkt im Programm unter Nutzung des Namens wiederverwendet werden können. Jede Funktion besteht aus den folgenden Komponenten:

• def – Schlüsselwort: Mit diesem Stichwort beginnt jede Funktionsdefinition gefolgt von einem eindeutigen Namen für die Funktion. Die Benamungsregeln für Funktionen sind identisch mit denen für Variablen, sodass der Funktionsname nicht mit einer Zahl beginnen kann und keine Sonderzeichen enthalten darf. 
• Parameter & Argumente: Dies sind Variablen, die der Funktion übergeben werden, wenn sie aufgerufen werden. Mit diesen können innerhalb der Funktion Berechnungen durchgeführt oder andere Änderungen vorgenommen werden. Die Argumente hingegen sind die tatsächlichen Werte, die die Funktion beim Aufruf erhält. Die Parameter werden in runden Klammern definiert und von Kommas getrennt. Die erste Zeile einer Funktion endet nach der Definition der Parameter mit einem Doppelpunkt.
• Einrückung: Wie bereits beschrieben wurde, spielen Einrückungen in Python eine wichtige Rolle und zeigen an, welche Codeabschnitte zusammengehören. Nach der Zeile mit dem Schlüsselwort def folgt eine Einrückung, die sich bis zum Ende der Funktion fortsetzt und somit anzeigt, wann die Funktion endet. 
• Rückgabewerte: Um die Berechnungen, die innerhalb einer Funktion stattfinden wieder an das restliche Programm abzugeben, nutzt man sogenannte Rückgabewerte, die durch ein vorangestelltes return gekennzeichnet sind. Diese Rückgabewerte müssen jedoch nicht definiert sein. Eine Funktion kann auch ohne return enden. Wichtig ist hierbei jedoch zu erwähnen, dass die Ausführung des Codes auf jeden Fall nach return stoppt und der darauffolgende Code mit Einrückung nicht mehr beachtet wird.

Was sind die verschiedenen Arten von Argumenten und wie kann man sie verwenden?

Die Parameter ermöglichen beim Aufruf einer Funktion, dass verschiedene Werte an diese übergeben werden, welche anschließend für die weitere Berechnung genutzt werden können. Dies bildet den Hauptkern von Funktionen, da dadurch ermöglicht wird, dass ein standardisierter Codeblock mehrmals aufgerufen werden kann und die entsprechenden Ergebnisse zurückliefert. 

Es gibt verschiedene Arten von Argumenten, die genutzt werden können: 

Positionelle Argumente werden durch die Position im Funktionsaufruf festgelegt. Die Position spielt somit eine entscheidende Rolle, da diese mit der Funktionsdefinition abgeglichen wird. Dadurch kann ein Aufruf mit denselben Argumenten an unterschiedlichen Positionen auch zu anderen Ergebnissen führen. 

Schlüsselwort – Argumente hingegen können mithilfe von Parameternamen im Funktionsaufruf identifiziert werden. Dadurch wird der Code auch einfacher verständlich, da explizit angegeben wird, welches Argument für welchen Parameter übergeben wird. Durch dieses Detail spielt die Reihenfolge der Argumente keine Rolle mehr. 

Mithilfe von Standardparametern können Default – Werte hinterlegt werden, die genutzt werden, wenn kein explizites Argument für diesen Parameter im Funktionsaufruf angegeben wurde. Wenn jedoch ein Argument übergeben wird, findet der Default – Wert keine Anwendung. 

In manchen Fällen kann es sinnvoll sein, dass die Parameter nicht von vornherein fest definiert sind, sondern beim Aufruf definiert werden und sich bei jedem Funktionsaufruf ändern können. Für solche Fälle nutzt man in Python *args für die Übergabe beliebig vieler Positionsargumente und **kwargs für die Übergabe beliebig vieler Schlüsselwortargumente. 

Wie gibt man Werte aus einer Funktion zurück?

Das Hauptziel von Funktionen ist, wiederverwendbare Codeblöcke zu erstellen, die zu verschiedenen Zeiten während der Programmausführung aufgerufen werden können und abhängig von den Argumenten verschiedene Ergebnisse zurückliefern können. Damit das Ergebnis der Funktion wieder an das Programm zurückgespielt werden kann, wird das return Schlüsselwort genutzt. Dadurch kann das Ergebnis der Funktion in einer Variablen abgespeichert und im Programm weiterverwendet werden. 

Dabei kann eine Funktion auch mehr als einen Wert zurückgegeben. Jedoch muss dies im Funktionsaufruf bedacht werden, sodass beim Aufruf auch genügend Variablen zur Verfügung gestellt werden, die die Ergebnisse abspeichern. Ist dies nicht der Fall, wirft das Programm einen Fehler. 

Bei der Arbeit mit dem return – Statement ist es jedoch wichtig zu wissen, dass es dazu führt, dass die Funktion an genau diesem Punkt terminiert. Wenn es somit zu früh aufgerufen wird, wird der nachfolgende Code nicht mehr ausgeführt. Dieses Verhalten kann beispielsweise in Schleifen schnell zu Verwirrung führen. Deshalb sollte man darauf achten, die Rückgabe am richtigen Punkt zu platzieren. 

Nur die zweite Funktion gibt das richtige Ergebnis zurück, da die erste Funktion bereits nach einer Iteration terminiert, da das return Statement innerhalb der for – Schleife genutzt wird. 

Was sind die verschiedenen Lebensdauern und Gültigkeitsbereiche von Variablen in Funktionen?

Im Zusammenhang von Funktionen und Variablen muss man den Geltungsbereich von Variablen beachten. Variablen, die innerhalb einer Funktion definiert werden, haben ihren Geltungsbereich auch nur innerhalb dieser Funktion. Diese sogenannten lokalen Variablen werden außerhalb der Funktion nicht mal erkannt, da das außerhalb ihres Gültigkeitsbereichs ist. 

Anders verhält es sich hingegen mit globalen Variablen, die außerhalb der Funktion definiert werden. Diese ist auch Teil des Geltungsbereichs der Funktion und wird innerhalb der Funktion erkannt und es kann mit dieser Variablen weitergerechnet werden. 

Um jedoch Änderungen an dieser Variablen vornehmen zu können oder deren Wert zu überschreiben, muss vorher das Schlüsselwort global zusammen mit der Variablen genutzt werden, um den Geltungsbereich anzupassen, sodass die Änderungen auch außerhalb der Funktion geltend sind. 

Was sind Funktionen, die schon in Python eingebaut sind?

Python hat eine Vielzahl von standardisierten Funktionen, die bereits so hinterlegt sind, dass sie ohne weiteres genutzt werden können. Die wichtigsten, eingebauten Funktionen in Python sind:

• print(): Diese Funktion gibt die Argumente innerhalb der Klammern in der Konsole oder dem Jupyter Notebook aus. Die folgenden Programmbausteine werden weiterhin ausgeführt. Hierbei können auch mehrere Argumente übergeben werden, die dann in der entsprechenden Reihenfolge zusammengefügt und mit einem Leerzeichen getrennt werden. 
• len(): Diese Funktion gibt die Länge von verschiedenen Datenstrukturen zurück. Sie kann beispielsweise dafür genutzt werden, um die Anzahl von Zeichen in einem String auszugeben.
• type(): Mithilfe dieses Aufrufs kann der Datentyp einer Variablen zurückgegeben werden. 
• range():  Die range – Funktion gibt eine Folge von Zahlen zurück unter Angabe eines Start- und eines Endpunktes. Der Endpunkt ist hierbei nicht Teil der Folge.

Was ist die Rekursion?

Die Rekursion bezeichnet eine Programmiertechnik bei der sich eine Funktion selbst aufrufen kann. In Python kann dies umgesetzt werden, indem eine Funktion sich innerhalb der Definition einfach selbst aufruft. Bei dem Aufruf wird eine neue Instanz erzeugt, die unabhängig von der aufrufenden Instanz ist und somit ihre eigenen Variablen hat. 

Durch diese Technik können rekursive Berechnungen durchgeführt werden, die zum Beispiel bei der Fakultät benötigt werden. Die Fakultät ist definiert als das Produkt der Ganzzahl mit der Fakultät der vorangegangenen Ganzzahl. Dies lässt sich in Python wie folgt umsetzen. 

Der Prozess der Rekursion unterscheidet dabei zwei Fälle: 

1. Basisfall: Der Basisfall umfasst die Bedingung, bei der die Rekursion stoppt, die Funktion aufhört sich selbst aufzurufen und ein Ergebnis zurückgibt. In dem gezeigten Beispiel ist der Basisfall erreicht, wenn n den Wert null angenommen hat. 
2. Rekursiver Fall: Der rekursive Fall ist die Bedingung unter der die Funktion sich weiterhin selbst aufruft, um eine Teilrechnung zu vollziehen. Bei der Fakultät ist der rekursive Fall erreicht, solange n ungleich Null ist, da dann weiterhin die Fakultät der kleineren Zahl berechnet werden muss. 

Was sind Funktionen höherer Ordnung?

Python Funktionen höherer Ordnung zeichnen sich dadurch aus, dass sie ganze Funktionen als Eingabevariablen nutzen. Bis zu diesem Zeitpunkt hatten wir uns hingegen nur mit Funktionen beschäftigt, die einzelne Werte oder möglicherweise noch Listen als Eingabe benutzen. Mithilfe von diesem Konzept können in Python leistungsfähige Applikationen erstellt werden, die in der Lage sind eine Funktion auf verschiedene Objekte hintereinander anzuwenden.

In Python gibt es standardmäßige Funktionen höherer Ordnung, die in vielen Programmen zum Einsatz kommen. Die häufigsten sind:

• map() verwendet eine bestimmte Funktion um diese auf alle Elemente in einem Iterable, also beispielsweise einer Liste oder einem Tupel, anzuwenden. Als Ergebnis gibt es dasselbe Iterable mit den Ergebnissen aus der angewendeten Funktion zurück. In unserem Beispiel nutzt map() die Funktion square() als erstes Argument und führt dieses auf einer Liste mit Zahlen aus. Als Ergebnis entsteht eine neue Liste in der jedes vorherige Element entsprechend quadriert wurde:

• filter() nutzt als Eingabe eine Funktion, über die bestimmt wird nach welcher Logik gefiltert werden soll. Als zweites Argument wird analog zu map() ein Iterable genutzt, dessen Elemente entsprechend gefiltert werden soll. In unserem Beispiel sollen nur die Elemente enthalten bleiben, die gerade sind, also durch zwei teilbar sind. Die Filterlogik wird in der Funktion is_even() hinterlegt und als erstes Argument an filter() übergeben. In der Liste numbers sind dann alle Zahlen enthalten, die gefiltert werden sollen und von der lediglich die zwei und die vier übrig bleiben.

• reduce() bietet die Möglichkeit eine Berechnung mit allen Elementen des Iterables durchzuführen. Dadurch können beispielsweise alle Elemente miteinander multipliziert oder summiert werden. Somit liefert reduce() auch als Ergebnis kein Iterable, sondern einen einzigen Wert zurück. In unserem Beispiel berechnen wir das Produkt aus allen Elementen, die in der Liste numbers hinterlegt sind. Die Logik des Multiplizierens ist dabei in der Funktion multiply hinterlegt.

Funktionen höherer Ordnung bieten ein leistungsstarkes Werkzeug, indem sie es ermöglichen, dass ganze Funktionen als Eingabeparameter für eine andere Funktion dienen können. Dadurch lassen sich auch einzelne Codebausteine effizient wiederverwertet und dadurch der Code übersichtlicher gestalten.

Was sind Lambda-Funktionen?

Die Lambda Funktionen in Python sind sogenannte anonyme Funktionen, da für die Definition kein expliziter Name benötigt wird. Stattdessen kann innerhalb von einer Zeile unter der Verwendung des Stichworts lambda eine funktionierende Funktion definiert werden. Aufgrund dieses Stichworts werden die Funktionen auch oft nur Lambdas oder Lambda-Funktionen genannt. Auch in anderen Programmiersprachen, wie beispielsweise C# oder Java, werden solche Funktionen eingesetzt.

Sie lassen sich ganz einfach mit dem Parameter lambda, der Nennung der Variablen und dem Ausdruck, den die Funktion berechnen soll definieren:

An diesem Beispiel erkennt man auch deutlich, warum Python Lambdas anonyme Funktionen sind: Der Funktion selbst kann man nämlich keinen Namen geben, man kann sie lediglich in einer Variablen (function) abspeichern.

Wenn wir also die Summenfunktion aus unserem anfänglichen Beispiel mithilfe von Python Lambdas nachbauen wollen, sieht das folgendermaßen aus:

Wie man sieht, können auch mehr als ein Argument an Python Lambdas weitergegeben werden. Die Funktion sum_difference können wir jedoch nicht mit Python Lambdas nachbauen, da die anonymen Funktionen immer nur ein Resultat ausgeben können. Stattdessen müssen also zwei unterschiedliche Funktionen definiert werden und auch doppelt gerufen werden:

Es gibt verschiedene Fälle in denen es sinnvoll sein kann, Python Lambdas zu nutzen:

• Wenn simple Funktionen definiert werden, die lediglich einen Output haben und eine geringe Zahl an Inputs. In großen Projekten kann es sinnvoll sein, eine solche Funktion nicht explizit zu definieren, um Platz zu sparen und nicht unnötig für Verwirrung zu sorgen. Des weiteren erspart man sich in umfangreichen Klassen Probleme bei der Vererbung etc.
• Dasselbe Argument zieht auch dann, wenn Funktionen nur ein einziges Mal zum Einsatz kommen. Dann kann man auch auf die explizite Definition verzichten, da sowieso niemand mehr auf die Funktion zugreifen muss.
• Zusätzlich können anonyme Funktionen dafür sorgen, dass der Inhalt der Funktion schneller und einfacher verständlich wird, da es in einer einzige Zeile definiert ist. Die explizite Definition von Funktionen kann dazu führen, dass eine gewisse Verständlichkeit verloren geht.
• Darüber hinaus gibt es in Python Funktionen, wie beispielsweise “filter” oder “map”, die Funktionen als Input nehmen. In diesen Fällen ist es also sinnvoll, Python Lambda zu nutzen.

Was sind Dekoratoren in Python?

Die sogenannten Python Decorators bieten die Möglichkeit, die Funktionalität einer Funktion abzuändern. Auf den ersten Blick mag das sinnlos erscheinen, da man auch einfach die ursprüngliche Funktion abändern kann. In der Praxis kann die Nutzung von Python Decorators jedoch durchaus Sinn machen und dazu beitragen, dass der Code einfacher und verständlicher wird.

Beim Logging von Programmen werden häufig Decorators eingesetzt, um mitzuschreiben, welche Funktion wann aufgerufen wurde. Damit man diese Befehle nicht in jede Funktion explizit mit aufgenommen werden muss, nutzt man Decorator, um das Logging einmal zentral definieren und anschließend mehrfach einsetzen zu können.

Dazu schauen wir uns ein einfaches Beispiel an und nutzen eine simple Funktion, die einfach nur “Hello!” ausgibt:

Dazu können wir jetzt eine Funktion definieren, die den Aufruf von say_hello() dokumentiert, sodass man anschließend feststellen kann, ob der Aufruf funktioniert hat und die Funktion wie gewollt ausgeführt wurde. Dazu müssen wir in eine Funktion in der Funktion definieren.

In unserem Fall ist die äußere Funktion log_decorator, welche eine Funktion func als Input nutzt. Diese äußere Funktion wird später für den Decorator genutzt. Wenn wir an dieser Stelle keine zweite, innere Funktion definieren würden, würde die Funktion nur beim initialen Definieren des Decorators aufgerufen werden und nicht jedes Mal, wenn say_hello() aufgerufen wird.

Die innere Funktion wrapper() beschreibt nun die eigentliche Funktionalität, also dass es zuerst eine Ausgabe gibt, dann die Funktion aufgerufen wird und anschließend wieder eine Ausgabe gemacht wird:

Nun muss die say_hello() Funktion nochmals neu mit dem vorangestellten log_decorator definiert werden. Ein Python Decorator ist durch das anfängliche @-Zeichen erkennbar.

Der Vorteil, welcher sich aus der Nutzung des Python Decorators ergibt, ist nun, dass beim Ausbau des Programms die Wrapper Funktion wieder verwendet werden kann. Wenn wir nun also eine weitere Funktion hinzufügen, wie beispielsweise say_bye(), können wir diese auch mit demselben Decorator loggen und müssen es nicht zusätzlich definieren.

Das solltest Du mitnehmen

• Funktionen sind eine wichtige Säule in der Python-Programmierung und ermöglichen es, dass bestimmte Logiken und Codebestandteile mehrmals aufgerufen werden können.
• Für die Definition einer Funktion benötigt man das vorangestellte Schlüsselwort def, einen Namen für die Funktion und eine Reihe von Parametern, die in runden Klammern definiert werden.
• Die Parameter können entweder positionelle Argumente sein, bei denen die Reihenfolge der Werte entscheidend ist, oder Schlüsselwort Argumente, bei dem über Schlüsselwörter der Wert dem richtigen Parameter zugeordnet wird.
• Bei der Rekursion handelt es sich um ein Konzept bei der eine Funktion sich beim Durchlaufen des Algorithmus selbst aufruft. Dies kann beispielsweise bei der Berechnung der Fakultät benötigt werden.
• Lambda-Funktionen, oder sogenannte anonyme Funktionen, können innerhalb einer Zeile definiert werden und benötigen keinen Funktionsnamen.
• Die Python Decorator ermöglichen es, die Funktionalität einer Funktion zu erweitern, ohne dass der ursprüngliche Code verändert wird.

Andere Beiträge zum Thema Funktionen in Python

Die Universität von Stanford hat einen interessanten Artikel über Funktionen in Python.