Funktionen in Python definieren und verwenden

Einführung

In diesem Lab lernen Sie, wie man Funktionen in Python definiert und verwendet. Funktionen sind wesentlich für die Organisation von Code und die Förderung der Wiederverwendbarkeit. Sie beginnen damit, das Konzept von Funktionen zu verstehen und Pythons eingebaute (built-in) Funktionen zu erkunden, wobei Sie lernen, wie man sie mit Parametern aufruft und ihre Ausgabe beobachtet.

Nach der Erkundung der eingebauten Funktionen lernen Sie, wie Sie Ihre eigenen einfachen Funktionen definieren. Abschließend üben Sie das Aufrufen dieser benutzerdefinierten Funktionen, um die von ihnen enthaltenen Codeblöcke auszuführen, wodurch Ihr Verständnis für die Erstellung und Verwendung von Funktionen in Python gefestigt wird.

Eingebaute Funktionen verstehen und verwenden

In diesem Schritt werden wir das Konzept von Funktionen erkunden und lernen, wie man die eingebauten (built-in) Funktionen von Python verwendet. Eine Funktion ist ein wiederverwendbarer Codeblock, der eine bestimmte Aktion ausführt. Python stellt viele eingebaute Funktionen zur Verfügung, die sofort einsatzbereit sind, wie z.B. print(), len() und sum().

Beginnen wir damit, ein Python-Skript zu schreiben, um einige dieser Funktionen in Aktion zu sehen.

Suchen Sie zuerst im WebIDE-Dateiexplorer auf der linken Seite nach der Datei builtin_functions.py. Diese Datei wurde für Sie im Verzeichnis ~/project vorab erstellt. Doppelklicken Sie auf die Datei, um sie im Editor zu öffnen.

Fügen Sie nun den folgenden Python-Code in die Datei builtin_functions.py ein. Dieser Code demonstriert, wie man mehrere eingebaute Funktionen aufruft.

## Using the print() function to display output
print("Hello, Python Functions!")

## Using the len() function to get the length of a string
message = "Hello World"
print(len(message))

## Using the sum() function to add numbers in a list
numbers = [1, 2, 3, 4, 5]
total = sum(numbers)
print(total)

Nachdem Sie den Code geschrieben haben, speichern Sie die Datei, indem Sie Strg+S drücken.

Um das Skript auszuführen, öffnen Sie das integrierte Terminal in der WebIDE (falls es noch nicht geöffnet ist, gehen Sie im oberen Menü zu Terminal > New Terminal). Führen Sie dann den folgenden Befehl aus:

python ~/project/builtin_functions.py

Sie werden die Ausgabe jedes print()-Aufrufs im Terminal sehen.

Hello, Python Functions!
11
15

Diese Ausgabe zeigt die Ergebnisse des Aufrufs der eingebauten Funktionen: print() zeigt Text an, len() gibt die Anzahl der Zeichen in einer Zeichenkette zurück, und sum() berechnet die Summe der Elemente in einer Liste.

Funktionen mit Parametern und Rückgabewerten verwenden

Funktionen benötigen oft Eingabedaten, mit denen sie arbeiten können. Diese Daten werden der Funktion als Parameter (auch Argumente genannt) übergeben. Nach der Verarbeitung kann eine Funktion ein Ergebnis zurücksenden, was als Rückgabewert (return value) bezeichnet wird.

Erweitern wir unser Skript builtin_functions.py, um Funktionen zu untersuchen, die Parameter entgegennehmen, und um zu sehen, wie wir ihre Rückgabewerte nutzen können.

Öffnen Sie die Datei builtin_functions.py erneut im WebIDE-Editor. Fügen Sie den folgenden Code am Ende der Datei hinzu:

## Using the max() function with multiple number parameters
largest_number = max(10, 25, 15)
print(largest_number)

## Using the round() function with two parameters
pi_approx = 3.14159
rounded_pi = round(pi_approx, 2) ## round to 2 decimal places
print(rounded_pi)

## Using the sorted() function with a list parameter
unsorted_list = ['cherry', 'apple', 'banana']
sorted_list = sorted(unsorted_list)
print(sorted_list)

Speichern Sie die Änderungen in der Datei (Strg+S).

Führen Sie nun das aktualisierte Skript im Terminal aus:

python ~/project/builtin_functions.py

Das Terminal zeigt die Ausgabe sowohl des ursprünglichen als auch des neuen Codes an.

Hello, Python Functions!
11
15
25
3.14
['apple', 'banana', 'cherry']

Lassen Sie uns die neue Ausgabe überprüfen:

• max(10, 25, 15) nimmt drei Zahlen als Parameter entgegen und gibt die größte zurück, 25.
• round(pi_approx, 2) nimmt eine Zahl und die Anzahl der Dezimalstellen als Parameter entgegen. Es gibt den gerundeten Wert, 3.14, zurück.
• sorted(unsorted_list) nimmt eine Liste als Parameter entgegen und gibt eine neue Liste zurück, deren Elemente in aufsteigender Reihenfolge sortiert sind.

In jedem Fall haben wir den Rückgabewert der Funktion in einer Variablen (largest_number, rounded_pi, sorted_list) gespeichert, bevor wir ihn ausgegeben haben. Dies ist eine übliche und nützliche Vorgehensweise.

Eine einfache Funktion definieren

Obwohl eingebaute Funktionen leistungsstark sind, müssen Sie oft eigene Funktionen erstellen, um benutzerdefinierte Aufgaben auszuführen. Dies wird als Funktionsdefinition bezeichnet.

In Python definieren Sie eine Funktion mithilfe des Schlüsselworts def. Die grundlegende Syntax lautet:

def function_name(parameters):
    """Docstring: Eine optionale Beschreibung der Funktion."""
    ## Auszuführender Code (Funktionskörper)
    ## ...
    return value  ## Optionale return-Anweisung

• def: Das Schlüsselwort, das eine Funktionsdefinition beginnt.
• function_name: Ein beschreibender Name für Ihre Funktion.
• (parameters): Eingabevariablen für die Funktion. Eine Funktion kann null oder mehr Parameter haben.
• :: Der Doppelpunkt markiert das Ende des Funktionskopfes (Function Header).
• Einrückung (Indentation): Die Codezeilen innerhalb der Funktion müssen eingerückt sein (normalerweise mit 4 Leerzeichen). So gruppiert Python Anweisungen.

Erstellen wir unsere erste Funktion. Suchen und öffnen Sie im WebIDE-Dateiexplorer die Datei my_functions.py.

Fügen Sie den folgenden Code zu my_functions.py hinzu, um eine Funktion zu definieren, die eine Begrüßung ausgibt:

## Define a simple function named 'greet'
def greet():
    """This function prints a simple greeting message."""
    print("Hello from a user-defined function!")

Speichern Sie die Datei.

An dieser Stelle haben Sie erfolgreich eine Funktion namens greet definiert. Wenn Sie dieses Skript jedoch ausführen, wird nichts passieren. Die Definition einer Funktion teilt Python nur mit, was die Funktion tut; sie führt den Code darin nicht tatsächlich aus. Um den Code der Funktion auszuführen, müssen Sie sie aufrufen, was wir im nächsten Schritt behandeln werden.

Eine benutzerdefinierte Funktion aufrufen

Nachdem eine Funktion definiert wurde, müssen Sie sie aufrufen (call), um ihren Code auszuführen. Das Aufrufen einer Funktion ist unkompliziert: Sie geben einfach ihren Namen gefolgt von Klammern () ein.

Rufen wir die Funktion greet auf, die wir im vorherigen Schritt definiert haben.

Öffnen Sie die Datei my_functions.py im WebIDE-Editor. Fügen Sie nach der Funktionsdefinition eine Codezeile hinzu, um die Funktion aufzurufen.

## Define a simple function named 'greet'
def greet():
    """This function prints a simple greeting message."""
    print("Hello from a user-defined function!")

## Call the greet function to execute its code
print("Calling the function now...")
greet()

Speichern Sie die Datei. Es ist wichtig, dass der Funktionsaufruf greet() nach dem Block def greet(): erscheint. Python liest Dateien von oben nach unten, daher müssen Sie eine Funktion definieren, bevor Sie sie aufrufen können.

Führen Sie nun das Skript im Terminal aus:

python ~/project/my_functions.py

Sie sehen die Ausgabe, die auf der Konsole ausgegeben wird:

Calling the function now...
Hello from a user-defined function!

Der große Vorteil von Funktionen ist die Wiederverwendbarkeit (Reusability). Sie können dieselbe Funktion mehrmals aufrufen, ohne ihren Code neu schreiben zu müssen. Rufen wir greet() erneut auf. Ändern Sie my_functions.py wie folgt:

## Define a simple function named 'greet'
def greet():
    """This function prints a simple greeting message."""
    print("Hello from a user-defined function!")

## Call the greet function multiple times
print("Calling the function...")
greet()
print("Calling it again...")
greet()

Speichern Sie die Datei und führen Sie sie noch einmal aus:

python ~/project/my_functions.py

Die Ausgabe zeigt nun, dass die Funktion zweimal ausgeführt wurde:

Calling the function...
Hello from a user-defined function!
Calling it again...
Hello from a user-defined function!

Dies demonstriert, wie Funktionen Ihnen helfen, saubereren, besser organisierten und wiederverwendbaren Code zu schreiben.

Zusammenfassung

In diesem Lab haben Sie die Grundlagen von Funktionen in Python gelernt. Sie begannen damit, Pythons eingebaute Funktionen (built-in functions) wie print(), len() und sum() zu erkunden und übten deren Aufruf in einem Skript. Anschließend vertieften Sie Ihr Verständnis der Funktionsweise, indem Sie Parameter übergeben und deren Rückgabewerte (return values) anhand von Beispielen wie max(), round() und sorted() verwendeten.

Schließlich lernten Sie die Syntax zur Definition eigener benutzerdefinierter Funktionen mithilfe des Schlüsselworts def und übten den Aufruf Ihrer benutzerdefinierten Funktion, um deren Code auszuführen. Dieses Lab hat eine solide Grundlage für die Erstellung von modularem und wiederverwendbarem Code geschaffen, was eine Schlüsselkompetenz für jeden Python-Programmierer ist.