8 Module und Packages

8.1 Einführung in Module und Packages

• Definition von Modulen und Packages
• Vorteile der Modularisierung

Module und Packages sind zentrale Konzepte in Python, die es ermöglichen, Code besser zu organisieren, wiederverwendbar zu gestalten und die Lesbarkeit zu erhöhen.

• Definition von Modulen und Packages:

  • Module: Ein Modul ist eine einzelne Python-Datei, die Python-Code enthält, wie z.B. Funktionen, Klassen und Variablen. Module können in anderen Python-Dateien importiert werden, um auf deren Funktionalitäten zuzugreifen.
  • Packages: Ein Package ist eine Sammlung von Modulen, die in einem gemeinsamen Verzeichnis organisiert sind. Dieses Verzeichnis enthält normalerweise eine __init__.py-Datei, die es Python ermöglicht, das Verzeichnis als Package zu behandeln. Packages erlauben es, eine hierarchische Struktur in der Code-Organisation zu schaffen, um noch größere und komplexere Projekte zu verwalten.

• Vorteile der Modularisierung:

  1. Wiederverwendbarkeit: Indem man Funktionen und Klassen in Modulen organisiert, kann man den Code einfacher in verschiedenen Teilen eines Projekts oder sogar in anderen Projekten wiederverwenden.
  2. Lesbarkeit: Modularisierung hilft dabei, den Code in kleinere, leichter verständliche Einheiten zu unterteilen. Dadurch wird der Code leichter lesbar und wartbar.
  3. Namespace-Isolierung: Module und Packages bieten eine Möglichkeit, den Namensraum zu isolieren, sodass der Code in verschiedenen Modulen nicht in Konflikt gerät. Das bedeutet, dass zwei Funktionen oder Klassen in verschiedenen Modulen den gleichen Namen haben können, ohne dass dies zu Problemen führt.
  4. Zusammenarbeit: Durch die Unterteilung des Codes in Module und Packages wird die Zusammenarbeit in Teams vereinfacht, da die Zuständigkeiten klarer definiert sind und verschiedene Teammitglieder an unterschiedlichen Modulen arbeiten können, ohne den gesamten Code durcheinander zu bringen.

8.2 Erstellen und Importieren von Modulen

• Erstellen eigener Module
• Importieren von Modulen mit ‘import’
• Verwendung von ‘from’ und ‘import’

Erstellen eigener Module: Um ein eigenes Modul zu erstellen, schreiben Sie einfach Python-Code (wie Funktionen, Klassen oder Variablen) in eine separate Datei mit der Dateiendung .py. Die Datei kann dann als Modul behandelt und in anderen Python-Skripten importiert werden. Zum Beispiel:

# my_module.py
def say_hello(name):
    return f"Hallo, {name}!"

Importieren von Modulen mit ‘import’: Um auf die Funktionen, Klassen oder Variablen in einem Modul zuzugreifen, müssen Sie das Modul in Ihrem Python-Code importieren. Verwenden Sie dazu das Schlüsselwort import, gefolgt vom Modulnamen:

# main.py
import my_module

greeting = my_module.say_hello("Anna")
print(greeting)  # Output: Hallo, Anna!

Verwendung von ‘from’ und ‘import’: Wenn Sie nur bestimmte Funktionen oder Klassen aus einem Modul importieren möchten, können Sie das Schlüsselwort from in Kombination mit import verwenden:

# main.py
from my_module import say_hello

greeting = say_hello("Anna")
print(greeting)  # Output: Hallo, Anna!

Diese Methode ermöglicht es Ihnen, die Funktionen oder Klassen direkt zu verwenden, ohne den Modulnamen als Präfix angeben zu müssen. Achten Sie jedoch darauf, keine Namenskonflikte mit bereits vorhandenen Funktionen oder Klassen in Ihrem Code zu erzeugen.

8.3 Namensräume und Scopes

• Globaler und lokaler Scope
• Namensraum von Modulen

Namensräume und Scopes sind wichtig um zu verstehen wie Variablen und Funktionen im Code verwaltet werden. Sie ermöglichen es, Variablen mit dem gleichen Namen in verschiedenen Kontexten zu verwenden, ohne Konflikte zu erzeugen.

Globaler und lokaler Scope: 1. Globaler Scope: Der globale Scope ist der Bereich eines Python-Skripts, in dem globale Variablen definiert sind. Globale Variablen sind Variablen, die außerhalb von Funktionen oder Klassen im Hauptkörper des Skripts definiert sind. Sie können im gesamten Skript und in den Funktionen und Klassen, die im Skript definiert sind, zugegriffen und geändert werden.

2. Lokaler Scope: Der lokale Scope ist der Bereich innerhalb einer Funktion oder einer Methode, in dem lokale Variablen definiert sind. Lokale Variablen sind Variablen, die innerhalb einer Funktion oder Methode definiert und nur innerhalb dieses Bereichs verwendet werden können. Sobald die Funktion oder Methode beendet ist, werden die lokalen Variablen gelöscht und können nicht mehr zugegriffen werden.

# Globale Variable
my_var = 10

def my_function():
    # Lokale Variable
    local_var = 5
    print("Innerhalb der Funktion:", my_var, local_var)

my_function()
print("Außerhalb der Funktion:", my_var)
# Output:
# Innerhalb der Funktion: 10 5
# Außerhalb der Funktion: 10

Namensraum von Modulen: Jedes Python-Modul hat seinen eigenen Namensraum, der die im Modul definierten Funktionen, Klassen und Variablen enthält. Wenn Sie ein Modul importieren, können Sie auf dessen Namensraum zugreifen, um die darin definierten Funktionen, Klassen und Variablen zu verwenden. Um auf Elemente im Namensraum eines Moduls zuzugreifen, verwenden Sie den Modulnamen als Präfix, gefolgt von einem Punkt und dem Namen des Elements:

# my_module.py
def my_function():
    return "Hallo Welt!"

# main.py
import my_module

result = my_module.my_function()
print(result)  # Output: Hallo Welt!

Sie können auch das from ... import ...-Statement verwenden, um direkt auf die gewünschten Funktionen, Klassen oder Variablen im Modulnamensraum zuzugreifen:

# main.py
from my_module import my_function

result = my_function()
print(result)  # Output: Hallo Welt!

8.4 Untersuchung von Modulen und Packages

• Die Funktion ‘dir()’
• Das Attribut ‘name’

Um mehr Informationen über die in einem Modul oder Package verfügbaren Funktionen, Klassen und Variablen zu erhalten, können Sie die Funktion dir() und das Attribut __name__ verwenden.

• Die Funktion ‘dir()’: Die eingebaute Funktion dir() gibt eine Liste von Namen zurück, die im angegebenen Modul oder Package definiert sind. Wenn kein Argument angegeben ist, gibt dir() die im aktuellen Namensraum definierten Namen zurück. Sie können dir() verwenden, um die verfügbaren Funktionen, Klassen und Variablen in einem importierten Modul oder Package zu erkunden:

import math

print(dir(math))
# Output: ['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', ...]

• In diesem Beispiel zeigt dir(math) alle Funktionen, Klassen und Variablen an, die im math-Modul definiert sind.

• Das Attribut ‘name’: Das Attribut __name__ gibt den Namen des aktuellen Moduls oder Packages zurück. In einem importierten Modul oder Package entspricht __name__ dem Namen des Moduls oder Packages:

# my_module.py
print(__name__)  # Output: my_module

Wenn das Python-Skript direkt ausgeführt wird (also nicht importiert), hat __name__ den Wert '__main__'. Dies kann verwendet werden, um Code nur auszuführen, wenn das Skript direkt ausgeführt wird, und nicht, wenn es als Modul importiert wird:

# my_module.py
def main():
    print("Das Modul wird direkt ausgeführt.")

if __name__ == '__main__':
    main()
else:
    print("Das Modul wird importiert.")

In diesem Beispiel wird die Funktion main() nur aufgerufen, wenn my_module.py direkt ausgeführt wird. Wenn es als Modul importiert wird, wird stattdessen die Nachricht “Das Modul wird importiert.” angezeigt.