Funktionen in Python - einfach erklärt!

Python-Funktionen sind ein grundlegendes Konzept in der Programmierung. Sie sind wiederverwendbare Codeblöcke, die eine bestimmte Aufgabe ausführen und einen Wert zurückgeben. Diese ermöglichen es Dir, Deinen Code in kleinere, besser handhabbare Teile aufzuteilen, was Deinen Code modularer macht und das Lesen, Verstehen und Debuggen erleichtert. Python verfügt über eine umfangreiche Sammlung von integrierten Funktionen, erlaubt Dir aber auch, eigene benutzerdefinierte Funktionen zu erstellen.

In diesem Artikel werden wir die Grundlagen von Funktionen in Python erkunden, wie man sie definiert und aufruft und wie man Argumente übergibt und Rückgabewerte erhält. Wir werden auch einige fortgeschrittene Themen behandeln, wie z.B. Lambda-Funktionen, Rekursion und Dekorateure.

Wie definiert man eine Python-Funktion?

In Python werden Funktionen mit dem Schlüsselwort def gefolgt von dem Namen und einem Paar Klammern definiert. Die Klammern können optionale Parameter enthalten, die die Funktion akzeptieren kann. Die Definition wird dann von einem Doppelpunkt (:) gefolgt, um den Beginn des Codeblocks der Funktion anzuzeigen. Beachte, dass nach dem Schlüsselwort def die nächste Zeile mit einer Einrückung beginnt, um den Funktionscode anzuzeigen.

Die grundlegende Syntax einer Funktionsdefinition in Python lautet wie folgt:

Der Funktionsname sollte den gleichen Benennungskonventionen wie Variablen folgen und Kleinbuchstaben sowie Unterstriche für mehrere Wörter verwenden. Parameter sind Platzhalter für Werte, die an die Funktion übergeben werden können, wenn sie aufgerufen wird. Sie werden innerhalb der Klammern aufgelistet und durch Kommas getrennt. Funktionen können beliebig viele Parameter haben, auch keine.

Innerhalb des Funktionscodeblocks schreibst Du die Anweisungen, die das Verhalten der Funktion definieren. Diese Anweisungen werden jedes Mal ausgeführt, wenn die Funktion aufgerufen wird. Um das Ende des Funktionscodeblocks anzugeben, rückst Du die Anweisungen einfach ein. Anders als in einigen anderen Programmiersprachen verwendet Python keine geschweiften Klammern oder explizite Schlüsselwörter, um das Ende einer Funktion zu kennzeichnen.

Optional kann eine Funktion eine Rückgabeanweisung haben, um einen Wert an den aufrufenden Code zurückzugeben. Die Rückgabeanweisung beendet die Funktion und gibt den angegebenen Wert an den Aufrufer zurück. Es ist wichtig zu beachten, dass eine Funktion vor oder nach ihrer Verwendung im Code definiert werden kann. Es wird jedoch empfohlen, Funktionen vor ihrem Aufruf zu definieren, um die Lesbarkeit des Codes zu gewährleisten.

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

Der erste Hauptbaustein von Funktionen, den wir genauer betrachten möchten, sind die Argumente oder Parameter. Es gibt verschiedene Arten, die wir für verschiedene Anwendungen verwenden können, die wir in diesem Abschnitt genauer erläutern werden. In Python kann eine Funktion Argumente oder Parameter akzeptieren, mit denen Werte an die Funktion übergeben werden können, wenn sie aufgerufen wird. Das Verständnis der verschiedenen Arten von Argumenten ist für eine flexible und dynamische Verwendung von Funktionen wesentlich.

Positionelle Argumente: Diese werden durch ihre Position im Funktionsaufruf festgelegt. Die Reihenfolge der Argumente ist wichtig, da sie basierend auf ihrer Position in der Funktionsdefinition abgeglichen werden. Wenn wir die Reihenfolge im Funktionsaufruf ändern, wird beispielsweise das Alter von 25 als Name zurückgegeben und der Name als Alter.

Schlüsselwort-Argumente: Sie werden durch ihre Parameternamen im Funktionsaufruf identifiziert. Sie ermöglichen die namentliche Angabe von Argumenten, was lesbarer und flexibler sein kann. Durch die Angabe der Parameternamen spielt die Reihenfolge keine Rolle mehr.

Standard-Parameter: Den Funktionen können Standardparameterwerte zugewiesen werden. Diese Werte werden verwendet, wenn ein Argument beim Funktionsaufruf nicht angegeben wird. Mit Standardparametern kannst Du bestimmte Parameter optional machen. Hier ist ein Beispiel:

Argumente mit variabler Länge: Python erlaubt es Funktionen, eine variable Anzahl von Argumenten zu akzeptieren, indem die Syntax *args und **kwargs verwendet wird. *args erlaubt die Übergabe mehrerer Positionsargumente, während **kwargs die Übergabe mehrerer Schlüsselwortargumente erlaubt.

Wenn Du die Funktionsargumente und -parameter in Python verstehst, kannst Du vielseitige und anpassungsfähige Funktionen erstellen, die mit unterschiedlichen Eingaben und Szenarien umgehen können. Durch die Nutzung von Positionsargumenten, Schlüsselwortargumenten, Standardparametern und Argumenten mit variabler Länge kannst Du Funktionen schreiben, die für eine Vielzahl von Anwendungsfällen geeignet sind.

Wie gibt man Werte aus einer Funktion zurück?

In Python können Funktionen mit der return-Anweisung Werte zurückgeben. Mit Rückgabewerten können Ausgaben oder Ergebnisse an den aufrufenden Code weitergeben werden. Die Verwendung von Rückgabewerten ist wichtig, um die Ausgabe einer Funktion zu erfassen und zu nutzen.

Hier ist ein Beispiel, das die Verwendung von Rückgabewerten in einer Funktion demonstriert:

Im obigen Beispiel nimmt die Funktion add_numbers zwei Argumente, a und b, und berechnet deren Summe. Die return-Anweisung wird verwendet, um die berechnete Summe an den Aufrufer zurückzuschicken. Der Rückgabewert wird dann in der Ergebnisvariablen gespeichert und gedruckt, was zu der Ausgabe 7 führt.

Eine Funktion kann jedes gültige Python-Objekt zurückgeben, einschließlich Zahlen, Zeichenketten, Listen, Wörterbücher oder sogar benutzerdefinierte Objekte. Sie kann auch mehrere Werte als Tupel zurückgeben, die vom aufrufenden Code entpackt werden können.

Hier ist ein Beispiel, das die Rückgabe mehrerer Werte veranschaulicht:

In diesem Fall gibt die Funktion get_person_details drei Werte zurück: Name, Alter und Stadt. Der Funktionsaufruf ordnet jeden zurückgegebenen Wert einer separaten Variablen zu, die unabhängig im aufrufenden Code verwendet werden kann.

Es ist wichtig zu beachten, dass eine Funktion mehrere Rückgabeanweisungen haben kann. Sobald eine Rückgabeanweisung auftritt, wird die Ausführung der Funktion angehalten und der angegebene Wert an den Aufrufer zurückgegeben. Wenn eine Funktion keine Rückgabeanweisung hat oder die Rückgabeanweisung keinen Wert angibt, gibt die Funktion standardmäßig den Wert None zurück.

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

In Python bezieht sich der Geltungsbereich einer Variablen auf ihre Sichtbarkeit und Zugänglichkeit im gesamten Code. Das Verständnis des Gültigkeitsbereichs von Variablen ist entscheidend für die effektive Verwaltung und Verwendung von Variablen innerhalb von Funktionen und kann Fehler vermeiden, indem man sich vor Augen hält, welche Variable gültig ist.

Lokale Variablen: Variablen, die innerhalb einer Funktion definiert sind, haben einen lokalen Geltungsbereich, d. h. sie sind nur innerhalb dieser Funktion zugänglich. Lokale Variablen werden erstellt, wenn die Funktion aufgerufen wird, und zerstört, wenn die Funktion ihre Ausführung beendet hat.

In diesem Beispiel ist die Variable x innerhalb der Funktion my_function definiert. Sie ist nur innerhalb der Funktion zugänglich, und der Versuch, außerhalb der Funktion auf sie zuzugreifen, führt zu einem Fehler.

Globale Variablen: Variablen, die außerhalb einer Funktion oder im globalen Bereich definiert sind, werden als globale Variablen bezeichnet. Auf sie kann von jedem Teil des Codes aus zugegriffen werden, auch innerhalb von Funktionen. Um eine globale Variable innerhalb einer Funktion zu ändern, müssen Sie das Schlüsselwort global verwenden.

In diesem Fall wird das globale Schlüsselwort verwendet, um anzuzeigen, dass sich die Variable x innerhalb der Funktion auf die globale Variable x bezieht. Daher wirkt sich eine Änderung innerhalb der Funktion auch auf die globale Variable aus.

Lebensdauer der Variablen: Die Lebensdauer einer Variablen ist der Zeitraum, in dem sie im Speicher vorhanden ist. Bei lokalen Variablen beginnt ihre Lebensdauer mit dem Aufruf der Funktion und endet mit deren Beendigung. Globale Variablen hingegen sind so lange vorhanden, wie das Programm läuft. Es ist wichtig zu beachten, dass beim rekursiven Aufruf einer Funktion jeder rekursive Aufruf einen neuen Satz lokaler Variablen mit eigenem Geltungsbereich und eigener Lebensdauer erzeugt. Jeder rekursive Aufruf hat einen eigenen Satz von Variablen, der von den Variablen der anderen rekursiven Aufrufe getrennt ist.

Das Verständnis von Geltungsbereich und Lebensdauer von Variablen hilft bei der Vermeidung von Namenskonflikten, der Organisation von Code und der effektiven Verwaltung von Daten. Es wird im Allgemeinen empfohlen, lokale Variablen innerhalb von Funktionen zu verwenden, um Daten zu kapseln und ihre Sichtbarkeit auf die Stellen zu beschränken, an denen sie benötigt werden. Globale Variablen sollten sparsam und mit Vorsicht verwendet werden, da sie die Komplexität erhöhen und den Code schwerer verständlich und wartbar machen können.

Was sind übliche eingebaute Funktionen?

Python bietet eine Vielzahl von eingebauten Funktionen, die für die Durchführung verschiedener Operationen zur Verfügung stehen. Wenn Du diese verstehst und nutzt, kannst Du Deinen Code erheblich vereinfachen und Deine Programmiererfahrung verbessern. Hier sind einige häufig verwendete integrierte Funktionen in Python:

print(): Gibt die angegebenen Werte oder Variablen auf der Konsole aus.

len(): Gibt die Länge eines Objekts zurück, z. B. einer Zeichenkette, einer Liste oder eines Tupels.

input(): Liest Eingaben des Benutzers über die Konsole.

type(): Gibt den Typ eines Objekts zurück.

range(): Erzeugt eine Folge von Zahlen.

str(), int(), float(), bool(): Konvertiert Werte in die Typen String, Integer, Float oder Boolean.

max(), min(): Gibt den maximalen oder minimalen Wert einer Sequenz oder eines Satzes von Argumenten zurück.

sum(): Gibt die Summe aller Elemente einer Sequenz zurück.

Dies sind nur einige Beispiele für die vielen eingebauten Funktionen, die in Python zur Verfügung stehen. Durch die Verwendung dieser Funktionen kannst Du eine Vielzahl von Operationen effizient und effektiv durchführen und so Zeit und Mühe bei Deinen Programmieraufgaben sparen. In der Python-Dokumentation findest Du eine umfassende Liste der eingebauten Funktionen und ihre detaillierte Verwendung.

Was ist Rekursion?

Rekursion ist eine Programmiertechnik, bei der eine Funktion sich selbst aufruft, um ein Problem zu lösen. Python unterstützt rekursive Funktionen, die zur Lösung von Problemen verwendet werden können, die eine Iteration erfordern. Hier finden Sie einen Abschnitt über Rekursion in Python:

Die Rekursion ist eine leistungsstarke Programmiertechnik, die es einer Funktion ermöglicht, sich selbst aufzurufen. In Python kann eine Funktion so definiert werden, dass sie rekursiv ist, indem sie sich innerhalb des Funktionskörpers selbst aufruft. Wenn eine Funktion sich selbst aufruft, erzeugt sie eine neue Instanz ihrer selbst, die über einen eigenen Satz von Variablen verfügt und ihren eigenen Code unabhängig von der aufrufenden Instanz ausführen kann.

Der Prozess der Rekursion kann in zwei Teile unterteilt werden: den Basisfall und den rekursiven Fall. Der Basisfall ist die Bedingung, unter der die Funktion aufhört, sich selbst aufzurufen und ein Ergebnis zurückgibt. Der rekursive Fall ist die Bedingung, unter der die Funktion sich selbst aufruft, um ein Teilproblem zu lösen.

Rekursive Funktionen werden häufig verwendet, um Probleme zu lösen, die eine Iteration erfordern, wie z. B. das Suchen, Sortieren und Durchlaufen von Datenstrukturen. Die Fakultät kann zum Beispiel wie folgt rekursiv definiert werden:

In diesem Beispiel ist der Basisfall n == 0, und der rekursive Fall ist n * factorial(n-1). Die Funktion ruft sich selbst mit n-1 als Argument auf, bis der Basisfall erreicht ist.

Die Rekursion kann eine elegante Lösung für bestimmte Probleme sein, hat aber auch ihre Grenzen. Rekursive Funktionen können langsamer sein und mehr Speicher verbrauchen als iterative Lösungen, und sie können auch schwieriger zu debuggen sein. Es ist wichtig, die Rekursion nur dann zu verwenden, wenn sie die beste Lösung für ein Problem darstellt, und die damit verbundenen Einschränkungen und Kompromisse zu kennen.

Zusammenfassend lässt sich sagen, dass die Rekursion eine leistungsstarke Programmiertechnik ist, die es einer Funktion ermöglicht, sich selbst aufzurufen, um ein Problem zu lösen. Python unterstützt rekursive Funktionen, und sie können zur Lösung von Problemen verwendet werden, die eine Iteration erfordern. Allerdings kann die Rekursion langsamer und speicherintensiver sein als iterative Lösungen, und es ist wichtig, sie nur dann zu verwenden, wenn sie die beste Lösung für ein Problem darstellt.

Was sind Funktionen höherer Ordnung?

Wenn Du bis zu diesem Punkt des Artikels gekommen bist, können wir uns nun mit fortgeschritteneren Themen befassen, nämlich mit Funktionen höherer Ordnung, also Funktionen, die andere Funktionen als Eingabe annehmen. Dieses Konzept, Funktionen als Objekte erster Klasse zu behandeln, ermöglicht leistungsfähige und flexible Programmierparadigmen. Hier sind einige Beispiele für Funktionen höherer Ordnung in Python:

map(): Wendet eine bestimmte Funktion auf jedes Element einer Iterable an und gibt einen Iterator der Ergebnisse zurück.

In diesem Beispiel erhält die Funktion map() die Funktion square() als erstes Argument und die Zahlenliste als zweites Argument. Sie wendet die Funktion square() auf jedes Element der Zahlenliste an, wodurch eine neue Liste mit quadrierten Zahlen entsteht.

filter(): Filtert Elemente aus einer Iterablen auf der Grundlage einer gegebenen Funktion heraus, die einen booleschen Wert zurückgibt.

Hier nimmt die Funktion filter() die Funktion is_even() als erstes Argument und die Zahlenliste als zweites Argument. Sie wendet die Funktion is_even() auf jedes Element der Zahlenliste an und filtert die Elemente heraus, für die die Funktion den Wert False zurückgibt, wodurch eine neue Liste gerader Zahlen entsteht.

reduce(): Führt eine kumulative Berechnung mit einer gegebenen Funktion auf einer Iterablen durch und gibt einen einzigen Wert zurück.

In diesem Beispiel nimmt die Funktion reduce() die Funktion multiply() als erstes Argument und die Zahlenliste als zweites Argument. Sie wendet die Funktion multiply() nacheinander auf die Elemente der Zahlenliste an, was das kumulative Produkt aller Elemente ergibt.

Funktionen höherer Ordnung bieten eine leistungsfähige Möglichkeit, Code zu abstrahieren und zu modularisieren, indem das Verhalten in Funktionen gekapselt und als Argumente übergeben wird. Durch den Einsatz von Funktionen höherer Ordnung können Sie prägnanteren, wiederverwendbaren und aussagekräftigeren Code in Python schreiben.

Was sind die Lambda-Funktionen?

Python-Lambda-Funktionen sind eine prägnante Methode zur Erstellung kleiner, anonymer Funktionen, die in Verbindung mit anderem Code verwendet werden können und ein weiteres Beispiel für Funktionen höherer Ordnung sind. Sie werden mit dem Schlüsselwort lambda definiert, gefolgt von einer Liste von Argumenten und einem Ausdruck, der definiert, was die Funktion zurückgeben soll.

Hier ist ein Beispiel für eine lambda-Funktion, die zwei Argumente annimmt und deren Summe zurückgibt:

Diese Lambda-Funktion kann wie jede andere Funktion aufgerufen werden, zum Beispiel:

In diesem Fall würde der Variablen result der Wert 7 zugewiesen werden.

Lambda-Funktionen können besonders nützlich sein, wenn Du mit Funktionen höherer Ordnung arbeitest, die andere Funktionen als Argumente annehmen, wie z. B. die integrierten Funktionen map, filter und reduce.

So können wir zum Beispiel eine Lambda-Funktion mit map verwenden, um jede Zahl in einer Liste zu quadrieren:

In diesem Fall würde der Variablen Quadrat eine neue Liste [1, 4, 9, 16, 25] zugewiesen werden.

Lambda-Funktionen können auch in einer Vielzahl anderer Situationen verwendet werden, in denen eine kleine, temporäre Funktion benötigt wird. Du solltest sie jedoch mit Bedacht eingesetzt werden, da zu komplexe oder verschachtelte Lambda-Funktionen schwer zu lesen und zu verstehen sein können.

Was sind Dekoratoren in Python?

Dekoratoren in Python sind ein mächtiges Werkzeug, um das Verhalten von Funktionen oder Klassen zu verändern. Ein Dekorator ist eine Funktion, die eine andere Funktion als Eingabe annimmt und eine neue Funktion zurückgibt, die in der Regel die ursprüngliche Funktion um einige zusätzliche Funktionen erweitert.

In Python wird ein Dekorator mit dem Symbol “@” auf eine Funktion angewendet. Danach folgt der Name der Dekorfunktion, der oberhalb der Funktionsdefinition steht. Hier ist ein Beispiel für eine einfache Dekoratorfunktion:

In diesem Beispiel wird zuerst die Funktion my_decorator definiert. Sie nimmt eine Funktion als Eingabe und gibt eine neue Funktion, Wrapper, zurück, die der ursprünglichen Funktion einige zusätzliche Funktionen hinzufügt.

Die @my_decorator-Syntax oberhalb der say_hello-Funktion weist Python an, die my_decorator-Funktion auf die say_hello-Funktion anzuwenden.

Dekoratoren können für viele Dinge verwendet werden, z. B. für die Protokollierung, die Zeitsteuerung von Funktionen und die Zwischenspeicherung von Ergebnissen. Sie können auch mit Klassen verwendet werden, um das Verhalten von Methoden zu ändern.

Python-Dekoratoren sind eine leistungsstarke Funktion, die Ihnen helfen kann, sauberen, lesbaren Code zu schreiben, indem sie Belange trennen und es einfach machen, Ihren Funktionen und Klassen zusätzliche Funktionalität hinzuzufügen.

Das solltest Du mitnehmen

Funktionen sind ein wesentlicher Bestandteil der Python-Programmierung und ermöglichen die Wiederverwendbarkeit und Modularität des Codes.
Um eine Funktion in Python zu definieren, wird das Schlüsselwort “def” verwendet, gefolgt von einem Funktionsnamen und einer Reihe von Klammern, die die Argumente enthalten.
Lambda-Funktionen, die auch als anonyme Funktionen bezeichnet werden, sind eine prägnante Methode zur Definition einfacher Funktionen in Python.
Dekoratoren in Python sind Funktionen, die die Funktionalität anderer Funktionen verändern oder erweitern, ohne deren Code zu verändern.
Rekursion ist eine Technik, bei der eine Funktion sich selbst aufruft und so die Lösung eines Problems in Form von einfacheren Versionen ihrer selbst ermöglicht.
Funktionen höherer Ordnung in Python können andere Funktionen als Argumente annehmen oder als Werte zurückgeben und stellen damit ein leistungsstarkes Werkzeug für die funktionale Programmierung dar.
Wenn Sie die verschiedenen Merkmale und Anwendungen von Funktionen in Python verstehen, können Sie effizienteren, modularen und wiederverwendbaren Code schreiben.