In diesem Lab werden Sie zwei grundlegende Konzepte der Python-Programmierung untersuchen: Funktionen und Module. Funktionen ermöglichen es Ihnen, Ihren Code in wiederverwendbare Blöcke zu strukturieren, wodurch Ihre Programme modularer und leichter verständlich werden. Module erlauben es Ihnen, zusammengehörige Funktionen und Variablen in separaten Dateien zu organisieren, was die Wiederverwendbarkeit und Wartbarkeit des Codes fördert. Durch das Beherrschen dieser Konzepte werden Sie in der Lage sein, effizienteren und besser organisierten Python-Code zu schreiben.
Definieren und Verwenden von Funktionen
In diesem Schritt lernen Sie, wie Sie Funktionen in Python definieren und aufrufen.
Öffnen Sie den Python-Interpreter, indem Sie den folgenden Befehl in Ihrem Terminal eingeben:
python
Sie sollten den Python-Prompt (>>>) sehen, der anzeigt, dass Sie sich nun in der interaktiven Python-Shell befinden.
Beginnen wir mit der Definition einer einfachen Funktion, die eine Person begrüßt. Geben Sie im Python-Interpreter Folgendes ein:
def greet(name):
return f"Hello, {name}!"
result = greet("Alice")
print(result)
Sie sollten die folgende Ausgabe sehen:
Hello, Alice!
Funktionen werden mit dem Schlüsselwort def definiert, gefolgt vom Funktionsnamen und Parametern in Klammern. Der Funktionskörper ist eingerückt.
Diese Funktion nimmt einen Parameter name entgegen und gibt einen Begrüßungs-String zurück. Wir rufen die Funktion dann mit dem Argument "Alice" auf und geben das Ergebnis aus.
Die return-Anweisung wird verwendet, um einen Wert aus der Funktion zurückzugeben. Wenn keine return-Anweisung vorhanden ist, gibt die Funktion None zurück.
Funktionen dienen dazu, wiederverwendbaren Code zu kapseln und spezifische Aufgaben auszuführen. Sie sind der Hauptbaustein von Python-Programmen.
Erstellen wir nun eine Funktion, die eine Berechnung durchführt:
def calculate_area(length, width):
return length * width
area = calculate_area(5, 3)
print(f"The area is: {area}")
Sie sollten die folgende Ausgabe sehen:
The area is: 15
Diese Funktion berechnet die Fläche eines Rechtecks basierend auf seiner Länge und Breite.
Funktionen können auch Standardwerte für Parameter haben:
def power(base, exponent=2):
return base ** exponent
print(power(3))
print(power(3, 3))
Sie sollten die folgende Ausgabe sehen:
9
27
Hier wird, falls kein Exponent angegeben wird, der Wert 2 als Standardwert verwendet.
Funktionen können mithilfe von Tuples mehrere Werte zurückgeben:
Diese Funktion gibt sowohl den Minimal- als auch den Maximalwert aus einer Liste von Zahlen zurück.
Denken Sie daran, dass die Einrückung in Python entscheidend ist. Funktionskörper müssen konsistent eingerückt sein.
Den Gültigkeitsbereich von Funktionen verstehen
In diesem Schritt lernen Sie den Gültigkeitsbereich (Scope) von Funktionen kennen und erfahren, wie sich Variablen innerhalb und außerhalb von Funktionen verhalten.
Lassen Sie uns im Python-Interpreter lokale und globale Variablen untersuchen:
x = 10 ## Global variable
def print_x():
print(f"Global x: {x}")
print_x()
def change_x():
x = 20 ## Local variable
print(f"Local x: {x}")
change_x()
print(f"Global x after change_x(): {x}")
Sie sollten die folgende Ausgabe sehen:
Global x: 10
Local x: 20
Global x after change_x(): 10
Beachten Sie, dass die Funktion change_x() eine neue lokale Variable x erstellt, die das globale x nicht beeinflusst.
Um eine globale Variable innerhalb einer Funktion zu ändern, verwenden Sie das Schlüsselwort global:
def modify_global_x():
global x
x = 30
print(f"Modified global x: {x}")
modify_global_x()
print(f"Global x after modify_global_x(): {x}")
Sie sollten die folgende Ausgabe sehen:
Modified global x: 30
Global x after modify_global_x(): 30
Jetzt wurde das globale x tatsächlich geändert.
Funktionen können auch auf Variablen aus ihrem umschließenden Gültigkeitsbereich zugreifen:
Die innere Funktion kann auf den Parameter x der äußeren Funktion zugreifen.
Das Verständnis des Gültigkeitsbereichs ist entscheidend für das Schreiben von sauberem und fehlerfreiem Code. Es hilft, unbeabsichtigte Nebenwirkungen zu vermeiden und macht Ihre Funktionen vorhersehbarer.
Erstellen und Verwenden von Modulen
In diesem Schritt lernen Sie, wie Sie Python-Module erstellen und verwenden.
Verlassen Sie den Python-Interpreter, indem Sie exit() eingeben oder Strg+D drücken.
Öffnen Sie die WebIDE in der LabEx VM-Umgebung.
Erstellen Sie eine neue Datei namens math_operations.py im Verzeichnis ~/project:
touch ~/project/math_operations.py
Öffnen Sie die neu erstellte Datei im WebIDE-Editor und fügen Sie den folgenden Inhalt hinzu:
## math_operations.py
def add(a, b):
return a + b
def subtract(a, b):
return a - b
def multiply(a, b):
return a * b
def divide(a, b):
if b != 0:
return a / b
else:
return "Error: Division by zero"
PI = 3.14159
Dieses Modul enthält vier mathematische Grundoperationen und eine Konstante PI.
Speichern Sie die Datei (Auto-Save ist in der WebIDE aktiviert).
Erstellen Sie nun eine weitere Datei namens use_math_module.py im selben Verzeichnis:
touch ~/project/use_math_module.py
Öffnen Sie use_math_module.py in der WebIDE und fügen Sie den folgenden Inhalt hinzu:
Dieses Skript importiert das Modul math_operations und verwendet dessen Funktionen und Konstanten.
Speichern Sie die Datei und führen Sie sie mit dem folgenden Befehl im Terminal aus:
python ~/project/use_math_module.py
Sie sollten eine Ausgabe ähnlich dieser sehen:
Addition: 8
Subtraction: 6
Multiplication: 12
Division: 5.0
Value of PI: 3.14159
Durch das Erstellen von Modulen können Sie zusammengehörige Funktionen und Variablen in separaten Dateien organisieren, was Ihren Code wartbarer und wiederverwendbarer macht.
Wenn Sie ein Modul importieren, kompiliert Python es in Bytecode und speichert diesen in einem Verzeichnis namens __pycache__. Dieses Verzeichnis wird am selben Ort wie die Moduldatei erstellt und enthält die kompilierten Bytecode-Dateien (.pyc oder .pyo).
Sie können dieses Verzeichnis getrost ignorieren, da Python die Kompilierung und das Caching von Modulen automatisch verwaltet.
Importieren spezifischer Funktionen aus Modulen
In diesem Schritt lernen Sie, wie Sie gezielt einzelne Funktionen aus Modulen importieren und Aliase verwenden, um Ihren Code prägnanter zu gestalten.
Erstellen Sie eine neue Datei namens advanced_math.py im Verzeichnis ~/project:
touch ~/project/advanced_math.py
Öffnen Sie advanced_math.py in der WebIDE und fügen Sie den folgenden Inhalt hinzu:
Dieses Modul nutzt Pythons integriertes math-Modul, um fortgeschrittenere mathematische Operationen bereitzustellen.
Erstellen Sie nun eine Datei namens use_advanced_math.py im selben Verzeichnis:
touch ~/project/use_advanced_math.py
Öffnen Sie use_advanced_math.py in der WebIDE und fügen Sie den folgenden Inhalt hinzu:
## use_advanced_math.py
from advanced_math import square_root, power
from advanced_math import sin as sine, cos as cosine
x = 16
y = 2
angle = 30
print(f"Square root of {x}: {square_root(x)}")
print(f"{x} to the power of {y}: {power(x, y)}")
print(f"Sine of {angle} degrees: {sine(angle)}")
print(f"Cosine of {angle} degrees: {cosine(angle)}")
Dieses Skript importiert spezifische Funktionen aus dem Modul advanced_math und verwendet Aliase für sin und cos.
Speichern Sie die Datei und führen Sie sie im Terminal aus:
python ~/project/use_advanced_math.py
Sie sollten eine Ausgabe ähnlich dieser sehen:
Square root of 16: 4.0
16 to the power of 2: 256.0
Sine of 30 degrees: 0.49999999999999994
Cosine of 30 degrees: 0.8660254037844387
Durch den Import spezifischer Funktionen und die Verwendung von Aliasen können Sie Ihren Code lesbarer machen und Namenskonflikte zwischen verschiedenen Modulen vermeiden.
Erstellen eines Pakets
In diesem letzten Schritt lernen Sie, wie Sie ein Paket (Package) erstellen. Ein Paket ist eine Möglichkeit, zusammengehörige Module in einer Verzeichnishierarchie zu organisieren.
Erstellen Sie ein neues Verzeichnis namens geometry im Verzeichnis ~/project:
mkdir ~/project/geometry
Erstellen Sie innerhalb des Verzeichnisses geometry zwei Dateien: __init__.py und shapes.py:
Die Datei __init__.py ist erforderlich, damit Python das Verzeichnis als Paket behandelt. Sie kann leer sein oder Initialisierungscode für das Paket enthalten.
Öffnen Sie shapes.py in der WebIDE und fügen Sie den folgenden Inhalt hinzu:
Erstellen Sie nun eine Datei namens use_geometry_package.py im Verzeichnis ~/project:
touch ~/project/use_geometry_package.py
Öffnen Sie use_geometry_package.py in der WebIDE und fügen Sie den folgenden Inhalt hinzu:
## use_geometry_package.py
from geometry.shapes import circle_area, rectangle_area, triangle_area
radius = 5
length = 4
width = 6
base = 3
height = 8
print(f"Area of circle with radius {radius}: {circle_area(radius):.2f}")
print(f"Area of rectangle with length {length} and width {width}: {rectangle_area(length, width)}")
print(f"Area of triangle with base {base} and height {height}: {triangle_area(base, height)}")
Speichern Sie die Datei und führen Sie sie im Terminal aus:
python ~/project/use_geometry_package.py
Sie sollten eine Ausgabe ähnlich dieser sehen:
Area of circle with radius 5: 78.54
Area of rectangle with length 4 and width 6: 24
Area of triangle with base 3 and height 8: 12.0
Durch das Erstellen eines Pakets haben Sie zusammengehörige Module in einer Verzeichnisstruktur organisiert, was die Verwaltung und den Import von Funktionen in Ihren Projekten erheblich erleichtert.
Zusammenfassung
In diesem Lab haben Sie zwei fundamentale Konzepte der Python-Programmierung erkundet: Funktionen und Module. Sie haben gelernt, wie man Funktionen definiert und verwendet, den Gültigkeitsbereich von Funktionen versteht, Module erstellt und nutzt, spezifische Funktionen importiert und zusammengehörige Module in Paketen organisiert.
Sie haben mit einfachen Funktionen begonnen und sich schrittweise zu komplexeren Konzepten wie dem Gültigkeitsbereich und globalen Variablen vorgearbeitet. Danach haben Sie gelernt, wie man Module erstellt, um Funktionen und Variablen in separaten Dateien zu strukturieren, was Ihren Code wartbarer und wiederverwendbarer macht.
Sie haben verschiedene Wege kennengelernt, Funktionen aus Modulen zu importieren, einschließlich des Imports spezifischer Funktionen und der Verwendung von Aliasen. Dieses Wissen ermöglicht es Ihnen, prägnanteren und lesbareren Code zu schreiben und gleichzeitig Namenskonflikte zu vermeiden.
Schließlich haben Sie gelernt, wie man ein Paket erstellt, um Module in einer Verzeichnishierarchie zu ordnen. Dies ist besonders nützlich für größere Projekte, bei denen viele zusammengehörige Module verwaltet werden müssen.
Diese Konzepte von Funktionen und Modulen sind entscheidend für das Schreiben von gut strukturiertem, effizientem und wiederverwendbarem Python-Code. Auf Ihrem weiteren Weg mit Python werden diese Fähigkeiten unerlässlich sein, um komplexere Programme zu entwickeln und an größeren Projekten mitzuarbeiten. Üben Sie diese Konzepte regelmäßig und erkunden Sie das riesige Ökosystem an Python-Modulen und -Paketen, um Ihre Programmierfähigkeiten stetig zu erweitern.
