Funktionen in Python definieren und verwenden

Einleitung

In diesem Labor lernen Sie, wie Sie Funktionen in Python definieren und verwenden. Funktionen sind unerlässlich für die Organisation von Code und die Förderung der Wiederverwendbarkeit. Sie beginnen mit dem Verständnis des Konzepts von Funktionen und erkunden die integrierten Funktionen von Python, lernen, wie Sie diese mit Parametern aufrufen und ihre Ausgaben beobachten.

Nach der Erkundung der integrierten 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, und festigen so Ihr Verständnis der Funktionserstellung und -verwendung in Python.

Funktionskonzepte und integrierte Funktionen verstehen

In diesem Schritt werden wir das Konzept von Funktionen in der Programmierung untersuchen und uns mit den integrierten Funktionen von Python befassen. Funktionen sind grundlegende Bausteine, die es uns ermöglichen, zusammengehörigen Code zu gruppieren und wiederzuverwenden.

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

Python bietet viele integrierte Funktionen, die sofort einsatzbereit sind. Einige davon sind uns bereits in früheren Labs begegnet, wie z. B. print(), input(), int(), list(), sorted() und sum().

Lassen Sie uns einige dieser integrierten Funktionen in einem Python-Skript verwenden.

Öffnen Sie das integrierte Terminal in der WebIDE und navigieren Sie zum Verzeichnis ~/project, falls Sie sich nicht bereits dort befinden.

Erstellen Sie eine neue Datei namens builtin_functions.py im Verzeichnis ~/project mithilfe des Dateiexplorers der WebIDE oder der Befehlszeile.

Öffnen Sie builtin_functions.py im Editor der WebIDE und fügen Sie den folgenden Code hinzu:

## Using built-in functions
print("Hello World")
print(int(25.36))
print(list('hello'))
print(sorted('story'))
print(sum([1, 2, 3]))

Speichern Sie die Datei.

Führen Sie nun das Skript über das Terminal mit dem Befehl python aus:

python ~/project/builtin_functions.py

Sie sollten die Ausgabe der verschiedenen integrierten Funktionen auf der Konsole sehen.

Hello World
25
['h', 'e', 'l', 'l', 'o']
['r', 's', 't', 'o', 'y']
6

Dies zeigt, wie wir integrierte Funktionen aufrufen und ihre Ergebnisse sehen können. Einige Funktionen wie print() erzeugen direkt eine Ausgabe, während andere wie int() oder sum() einen Wert zurückgeben, der dann verwendet oder ausgegeben werden kann.

Um eine Liste aller integrierten Funktionen in Python anzuzeigen, können Sie den Befehl dir(__builtins__) in einer interaktiven Python-Sitzung verwenden. Da wir uns jedoch auf die Verwendung von Skripten konzentrieren, überspringen wir die interaktive Sitzung vorerst.

Sie können auch Hilfe zur Verwendung einer bestimmten integrierten Funktion erhalten, indem Sie die Funktion help() in einer interaktiven Sitzung verwenden. Zum Beispiel würde help(abs) Ihnen zeigen, wie die Funktion abs() verwendet wird.

Im nächsten Schritt lernen wir mehr über das Aufrufen von Funktionen mit Parametern.

Integrierte Funktionen mit Parametern aufrufen

In diesem Schritt konzentrieren wir uns darauf, wie integrierte Funktionen aufgerufen werden und verstehen das Konzept von Parametern und Rückgabewerten.

Wenn wir eine Funktion aufrufen, übergeben wir ihr oft Daten. Diese Daten werden als Parameter (oder Argumente) bezeichnet. Die Funktion verarbeitet dann diese Parameter und kann ein Ergebnis erzeugen, das als Rückgabewert bezeichnet wird.

Lassen Sie uns einige der integrierten Funktionen, die wir im vorherigen Schritt gesehen haben, noch einmal betrachten und ihre Parameter und Rückgabewerte untersuchen.

Öffnen Sie die Datei builtin_functions.py im Verzeichnis ~/project mit dem Editor der WebIDE.

Wir haben bereits einige Beispiele in dieser Datei. Fügen wir ein paar weitere hinzu, um Parameter und Rückgabewerte klarer zu veranschaulichen.

Fügen Sie die folgenden Zeilen am Ende der Datei builtin_functions.py hinzu:

## Using abs() function
print(abs(-10))

## Using max() function
print(max(1, 5, 2))

## Using min() function
print(min(1, 5, 2))

## Using round() function
print(round(3.14159, 2))

## Storing return values in variables
sum_result = sum([10, 20, 30])
print(sum_result)

sorted_list = sorted(['banana', 'apple', 'cherry'])
print(sorted_list)

Speichern Sie die Datei.

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

python ~/project/builtin_functions.py

Beobachten Sie die Ausgabe:

Hello World
25
['h', 'e', 'l', 'l', 'o']
['r', 's', 't', 'o', 'y']
6
10
5
1
3.14
60
['apple', 'banana', 'cherry']

In dieser Ausgabe:

• abs(-10) nimmt -10 als Parameter und gibt seinen Absolutwert 10 zurück.
• max(1, 5, 2) nimmt mehrere Zahlen als Parameter und gibt die größte Zahl 5 zurück.
• min(1, 5, 2) nimmt mehrere Zahlen als Parameter und gibt die kleinste Zahl 1 zurück.
• round(3.14159, 2) nimmt eine Zahl und die Anzahl der Dezimalstellen als Parameter und gibt die gerundete Zahl 3.14 zurück.
• sum([10, 20, 30]) nimmt eine Liste von Zahlen als Parameter und gibt deren Summe 60 zurück. Wir haben diesen Rückgabewert in der Variablen sum_result gespeichert.
• sorted(['banana', 'apple', 'cherry']) nimmt eine Liste von Zeichenketten als Parameter und gibt eine neue sortierte Liste ['apple', 'banana', 'cherry'] zurück. Wir haben diesen Rückgabewert in der Variablen sorted_list gespeichert.

Das Verständnis, wie Parameter an Funktionen übergeben und wie deren Rückgabewerte verwendet werden, ist entscheidend für das Schreiben komplexerer Programme. Wir können Funktionen auch innerhalb anderer Funktionen aufrufen, wie wir es im vorherigen Schritt mit print(sum([1, 2, 3])) gesehen haben.

Im nächsten Schritt lernen wir, wie wir unsere eigenen Funktionen definieren.

Eine einfache Funktion definieren

In diesem Schritt lernen wir, wie wir unsere eigenen Funktionen in Python definieren. Während integrierte Funktionen sehr nützlich sind, müssen wir oft benutzerdefinierte Funktionen erstellen, um spezifische Aufgaben auszuführen, die nicht von den integrierten Funktionen abgedeckt werden.

Das Definieren einer Funktion in Python erfolgt mit dem Schlüsselwort def. Hier ist die grundlegende Struktur:

def function_name(parameters):
    """Docstring (optional): Erklärt, was die Funktion tut."""
    ## Function body: Code, den die Funktion ausführt
    statement1
    statement2
    ## ...
    return value ## Optional: gibt einen Wert zurück

Lassen Sie uns die Komponenten aufschlüsseln:

• def: Dieses Schlüsselwort signalisiert den Beginn einer Funktionsdefinition.
• function_name: Dies ist der Name, den Sie Ihrer Funktion geben. Er sollte denselben Namensregeln wie Variablen folgen (beginnt mit einem Buchstaben oder Unterstrich, enthält Buchstaben, Zahlen oder Unterstriche). Wählen Sie einen Namen, der beschreibt, was die Funktion tut.
• (parameters): Dies sind die Eingabewerte, die die Funktion akzeptiert. Sie können null oder mehr Parameter haben, die durch Kommas getrennt sind.
• :: Ein Doppelpunkt markiert das Ende des Funktionsheaders.
• Einrückung: Der Codeblock, der den Funktionskörper bildet, muss eingerückt sein. So weiß Python, welche Zeilen zur Funktion gehören.
• """Docstring""": Ein optionaler String-Literal direkt nach dem Funktionsheader. Es ist eine gute Praxis, einen Docstring einzufügen, um den Zweck, die Argumente und den Rückgabewert der Funktion zu erklären.
• return value: Die return-Anweisung wird verwendet, um eine Funktion zu beenden und einen Wert an den Aufrufer zurückzugeben. Wenn Sie keine return-Anweisung einfügen, gibt die Funktion standardmäßig None zurück.

Lassen Sie uns eine einfache Funktion definieren, die eine Begrüßung ausgibt.

Erstellen Sie eine neue Datei namens my_functions.py im Verzeichnis ~/project mit dem Editor der WebIDE.

Fügen Sie den folgenden Code zu my_functions.py hinzu:

## Define a simple function
def greet():
    """This function prints a simple greeting."""
    print("Hello from my function!")

Speichern Sie die Datei.

Wir haben nun eine Funktion namens greet definiert. Das Definieren einer Funktion führt sie jedoch nicht aus. Um den Code innerhalb der Funktion auszuführen, müssen wir sie aufrufen. Dies werden wir im nächsten Schritt tun.

Vorerst stellen wir nur sicher, dass die Datei erstellt wurde und die Funktionsdefinition enthält.

Eine benutzerdefinierte Funktion aufrufen

Im vorherigen Schritt haben wir eine einfache Funktion namens greet in der Datei my_functions.py definiert. Nun lernen wir, wie wir diese Funktion aufrufen, um den darin enthaltenen Code auszuführen.

Das Aufrufen einer benutzerdefinierten Funktion ähnelt dem Aufrufen einer integrierten Funktion. Sie verwenden einfach den Funktionsnamen gefolgt von Klammern ().

Öffnen Sie die Datei my_functions.py im Verzeichnis ~/project mit dem Editor der WebIDE.

Fügen Sie die folgende Zeile nach der Funktionsdefinition hinzu:

## Define a simple function
def greet():
    """This function prints a simple greeting."""
    print("Hello from my function!")

## Call the greet function
greet()

Speichern Sie die Datei.

Führen Sie nun das Skript im Terminal aus:

python ~/project/my_functions.py

Sie sollten die Ausgabe der print()-Anweisung innerhalb unserer greet()-Funktion sehen:

Hello from my function!

Dies bestätigt, dass unsere benutzerdefinierte Funktion erfolgreich aufgerufen und ausgeführt wurde.

Es ist wichtig zu bedenken, dass Sie in Python eine Funktion definieren müssen, bevor Sie sie aufrufen können. Wenn Sie versuchen, eine Funktion vor ihrer Definition im Skript aufzurufen, erhalten Sie einen NameError, da Python nicht weiß, worauf sich greet bezieht.

Versuchen wir, die Funktion mehrmals aufzurufen. Fügen Sie einen weiteren Aufruf von greet() in my_functions.py hinzu:

## Define a simple function
def greet():
    """This function prints a simple greeting."""
    print("Hello from my function!")

## Call the greet function
greet()
greet() ## Call it again

Speichern Sie die Datei und führen Sie sie erneut aus:

python ~/project/my_functions.py

Die Ausgabe zeigt die Begrüßung zweimal an:

Hello from my function!
Hello from my function!

Dies demonstriert die Wiederverwendbarkeit von Funktionen. Wir können dieselbe Funktion mehrmals aufrufen, ohne den darin enthaltenen Code wiederholen zu müssen.

In den folgenden Labs werden wir fortgeschrittenere Konzepte im Zusammenhang mit Funktionen untersuchen, wie z. B. das Übergeben von Parametern an unsere eigenen Funktionen und das Zurückgeben von Werten.

Zusammenfassung

In diesem Lab haben wir zunächst das grundlegende Konzept von Funktionen in der Programmierung verstanden und die sofort verfügbaren integrierten Funktionen von Python erkundet. Wir haben gelernt, dass Funktionen wiederverwendbare Codeblöcke sind, die spezifische Aufgaben ausführen und so Modularität und Code-Wiederverwendung fördern. Anschließend haben wir das Aufrufen mehrerer gängiger integrierter Funktionen wie print(), int(), list(), sorted() und sum() in einem Python-Skript geübt und dabei ihre Ausgaben beobachtet und verstanden, wie sie Eingabeparameter verarbeiten und Werte zurückgeben.

Die nachfolgenden Schritte bauen auf dieser Grundlage auf, indem sie zeigen, wie integrierte Funktionen mit Parametern aufgerufen werden, und gehen dann zur Definition und zum Aufruf unserer eigenen benutzerdefinierten Funktionen über, um unser Verständnis der Funktionsnutzung in Python weiter zu festigen.