Einführung
In diesem Lab erkunden Sie zwei grundlegende Konzepte der Python-Programmierung: Funktionen und Module. Funktionen ermöglichen es Ihnen, Ihren Code in wiederverwendbare Blöcke zu unterteilen, 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 die Beherrschung dieser Konzepte werden Sie in der Lage sein, effizienteren und besser strukturierten Python-Code zu schreiben.
Funktionen definieren und verwenden
In diesem Schritt lernen Sie, wie man Funktionen in Python definiert und verwendet.
Öffnen Sie den Python-Interpreter, indem Sie den folgenden Befehl in Ihr Terminal eingeben:
python
Sie sollten nun die Python-Eingabeaufforderung (>>>) sehen, die anzeigt, dass Sie sich in der interaktiven Python-Shell befinden.
Beginnen wir mit der Definition einer einfachen Funktion, die eine Person begrüßt. Geben Sie zuerst die Funktionsdefinition im Python-Interpreter ein:
def greet(name):
return f"Hello, {name}!"
Nachdem Sie die eingerückte return-Zeile eingegeben haben, drücken Sie einmal die Eingabetaste auf einer leeren Zeile, um die Funktionsdefinition abzuschließen. Führen Sie dann die Funktion im selben Interpreter aus:
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 den Parametern in Klammern. Der Funktionskörper ist eingerückt.
Diese Funktion nimmt einen name-Parameter entgegen und gibt einen Begrüßungs-String zurück. Wir rufen die Funktion anschließend 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 können verwendet werden, um wiederverwendbaren Code zu kapseln und spezifische Aufgaben auszuführen. Sie sind die wichtigsten Bausteine von Python-Programmen.
Lassen Sie uns nun eine Funktion erstellen, die eine Berechnung durchführt. Definieren Sie zuerst die Funktion:
def calculate_area(length, width):
return length * width
Drücken Sie die Eingabetaste auf einer leeren Zeile, um die Definition abzuschließen, und rufen Sie dann die Funktion auf:
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 Länge und Breite.
Funktionen können auch Standardwerte für Parameter haben. Definieren Sie zuerst die Funktion:
def power(base, exponent=2):
return base ** exponent
Drücken Sie die Eingabetaste auf einer leeren Zeile und testen Sie dann beide Aufrufe:
print(power(3))
print(power(3, 3))
Sie sollten die folgende Ausgabe sehen:
9
27
Wenn hier kein Exponent angegeben wird, verwendet die Funktion 2 als Standardwert.
Funktionen können mithilfe von Tupeln mehrere Werte zurückgeben. Definieren Sie zuerst die Funktion:
def min_max(numbers):
return min(numbers), max(numbers)
Drücken Sie die Eingabetaste auf einer leeren Zeile und rufen Sie dann die Funktion auf:
minimum, maximum = min_max([1, 5, 3, 9, 2])
print(f"Minimum: {minimum}, Maximum: {maximum}")
Sie sollten die folgende Ausgabe sehen:
Minimum: 1, Maximum: 9
Diese Funktion gibt sowohl den kleinsten als auch den größten Wert aus einer Liste von Zahlen zurück.
Denken Sie daran, dass Einrückungen in Python entscheidend sind. Funktionskörper müssen konsistent eingerückt sein.
Den Gültigkeitsbereich (Scope) von Funktionen verstehen
In diesem Schritt lernen Sie den Gültigkeitsbereich 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 ## Globale Variable
def print_x():
print(f"Global x: {x}")
print_x()
def change_x():
x = 20 ## Lokale 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
Nun wurde das globale x modifiziert.
Funktionen können auch auf Variablen aus ihrem umschließenden Gültigkeitsbereich zugreifen:
def outer_function(x):
def inner_function():
print(f"x from outer function: {x}")
inner_function()
outer_function(40)
Sie sollten die folgende Ausgabe sehen:
x from outer function: 40
Die innere Funktion kann auf den x-Parameter der äußeren Funktion zugreifen.
Das Verständnis des Gültigkeitsbereichs von Funktionen ist entscheidend für das Schreiben von sauberem und fehlerfreiem Code. Es hilft, unbeabsichtigte Nebeneffekte zu vermeiden und macht Ihre Funktionen vorhersehbarer.
Module erstellen und verwenden
In diesem Schritt lernen Sie, wie man Python-Module erstellt und verwendet.
Beenden 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 grundlegende mathematische Operationen und eine Konstante PI.
Speichern Sie die Datei (die automatische Speicherung 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 im WebIDE-Editor und fügen Sie den folgenden Inhalt hinzu:
## use_math_module.py
import math_operations
result_add = math_operations.add(5, 3)
result_subtract = math_operations.subtract(10, 4)
result_multiply = math_operations.multiply(2, 6)
result_divide = math_operations.divide(15, 3)
print(f"Addition: {result_add}")
print(f"Subtraction: {result_subtract}")
print(f"Multiplication: {result_multiply}")
print(f"Division: {result_divide}")
print(f"Value of PI: {math_operations.PI}")
Dieses Skript importiert das Modul math_operations und verwendet dessen Funktionen und Konstante.
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 den kompilierten Code in einem __pycache__-Verzeichnis. Dieses Verzeichnis wird am selben Ort wie die Moduldatei erstellt und enthält kompilierte Bytecode-Dateien (.pyc oder .pyo).
Sie können dieses Verzeichnis getrost ignorieren, da Python die Kompilierung und das Caching von Modulen automatisch übernimmt.
Spezifische Funktionen aus Modulen importieren
In diesem Schritt lernen Sie, wie Sie spezifische 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 im WebIDE-Editor und fügen Sie den folgenden Inhalt hinzu:
## advanced_math.py
import math
def square_root(x):
return math.sqrt(x)
def power(base, exponent):
return math.pow(base, exponent)
def sin(angle):
return math.sin(math.radians(angle))
def cos(angle):
return math.cos(math.radians(angle))
Dieses Modul verwendet das integrierte math-Modul von Python, 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 im WebIDE-Editor 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 mit dem folgenden Befehl 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 das Importieren spezifischer Funktionen und die Verwendung von Aliasen können Sie Ihren Code lesbarer machen und Namenskonflikte zwischen verschiedenen Modulen vermeiden.
Ein Paket erstellen
In diesem letzten Schritt lernen Sie, wie man ein Paket erstellt. Dies 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 geometry-Verzeichnisses zwei Dateien: __init__.py und shapes.py:
touch ~/project/geometry/__init__.py
touch ~/project/geometry/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 im WebIDE-Editor und fügen Sie den folgenden Inhalt hinzu:
## geometry/shapes.py
import math
def circle_area(radius):
return math.pi * radius ** 2
def rectangle_area(length, width):
return length * width
def triangle_area(base, height):
return 0.5 * base * height
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 im WebIDE-Editor 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 mit dem folgenden Befehl 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 Verzeichnishierarchie organisiert, was die Verwaltung und den Import verwandter Funktionen in Ihren Projekten erleichtert.
Zusammenfassung
In diesem Lab haben Sie zwei grundlegende 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 aus Modulen importiert und zusammengehörige Module in Paketen organisiert.
Sie begannen mit der Erstellung einfacher Funktionen und gingen schrittweise zu komplexeren Konzepten wie dem Gültigkeitsbereich von Funktionen und globalen Variablen über. Anschließend lernten Sie, wie man Module erstellt, um zusammengehörige Funktionen und Variablen in separaten Dateien zu organisieren, was Ihren Code wartbarer und wiederverwendbarer macht.
Sie haben verschiedene Möglichkeiten 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 zwischen verschiedenen Modulen zu vermeiden.
Schließlich haben Sie gelernt, wie man ein Paket erstellt, um zusammengehörige Module in einer Verzeichnishierarchie zu organisieren. Dies ist besonders nützlich für größere Projekte, bei denen Sie mehrere zusammengehörige Module verwalten müssen.
Diese Konzepte von Funktionen und Modulen sind entscheidend für das Schreiben von gut organisiertem, effizientem und wiederverwendbarem Python-Code. Während Sie Ihre Reise mit Python fortsetzen, werden Sie feststellen, dass diese Fähigkeiten unerlässlich sind, um komplexere Programme zu erstellen und an größeren Projekten mitzuarbeiten. Denken Sie daran, diese Konzepte regelmäßig zu üben und das riesige Ökosystem an Python-Modulen und -Paketen zu erkunden, um Ihre Programmierfähigkeiten weiter zu verbessern.
