Skip to content

Module, Pakete und Projektstruktur

Python-Code auf mehrere Dateien verteilen und kleine bis mittlere Projekte übersichtlich organisieren.

Viele Automatisierungsskripte beginnen als einzelne Datei. Mit der Zeit wachsen jedoch die Anforderungen und es wird sinnvoll, Code auf mehrere Dateien aufzuteilen.

Python bietet dafür Module und Pakete. Sie helfen dabei, Funktionen, Konfigurationen und Hilfsroutinen logisch zu strukturieren und wiederzuverwenden.

Für Administratoren steht dabei weniger die Entwicklung großer Softwareprojekte im Vordergrund, sondern eine übersichtliche Organisation von Skripten und Werkzeugen.

In diesem Kapitel lernen Sie die wichtigsten Grundlagen kennen, um Python-Projekte sinnvoll zu strukturieren.

Module und Importe

Was sind Module in Python?

Ein Modul ist in Python eine einzelne Datei mit der Endung .py, die Python-Code enthält – also Funktionen, Variablen oder Klassen. Durch Module können Sie Ihren Code übersichtlich in mehrere Dateien aufteilen, was gerade bei Automatisierungsprojekten mit vielen Aufgaben sehr hilfreich ist.

Im Vergleich zu Shell-Skripten, die oft monolithisch sind, ermöglicht Python mit Modulen eine klare Strukturierung und Wiederverwendbarkeit.

Ein einfaches Modul erstellen

Erstellen Sie eine Datei namens backup_utils.py mit einer Funktion zum Erstellen von Backups:

import shutil
import datetime
import os

def create_backup(src: str, dest_dir: str) -> str:
    """Erstellt ein Backup der Datei src im Zielverzeichnis dest_dir."""
    if not os.path.isfile(src):
        raise FileNotFoundError(f"Quelldatei nicht gefunden: {src}")

    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
    filename = os.path.basename(src)
    backup_name = f"{filename}.{timestamp}.bak"
    backup_path = os.path.join(dest_dir, backup_name)

    shutil.copy2(src, backup_path)
    return backup_path

Diese Funktion können Sie nun in anderen Skripten verwenden.

Module importieren

In einem anderen Skript, z.B. run_backup.py, importieren Sie das Modul und rufen die Funktion auf:

import os
import backup_utils

source_file = "/var/log/syslog"
destination = "/tmp/backups"

os.makedirs(destination, exist_ok=True)

backup_path = backup_utils.create_backup(source_file, destination)
print(f"Backup erstellt: {backup_path}")

Hier importieren Sie das gesamte Modul backup_utils und greifen mit backup_utils.create_backup() auf die Funktion zu.

Alternative Importformen

Sie können auch nur einzelne Funktionen importieren:

from backup_utils import create_backup

backup_path = create_backup("/var/log/syslog", "/tmp/backups")

Oder alle Funktionen (nicht empfohlen, da unübersichtlich):

from backup_utils import *

Wichtig: Suchpfad für Module

Python sucht Module im aktuellen Verzeichnis und in den Verzeichnissen, die in der Umgebungsvariable PYTHONPATH oder in sys.path definiert sind. Für einfache Automatisierungsprojekte genügt es meist, dass Skripte und Module im selben Ordner liegen.

Häufige Fehler beim Import

  • Datei nicht gefunden: Achten Sie darauf, dass das Modul im selben Verzeichnis liegt oder im Suchpfad enthalten ist.
  • Namenskonflikte: Vermeiden Sie Modulnamen, die mit Standardbibliotheken oder anderen wichtigen Paketen kollidieren.

Zusammenfassung

  • Ein Modul ist eine einzelne .py-Datei mit wiederverwendbarem Code.
  • Verwenden Sie import modulname oder from modulname import funktion zum Einbinden.
  • Module helfen, Automatisierungsskripte übersichtlich und wartbar zu gestalten.
  • Achten Sie auf den Suchpfad und vermeiden Sie Namenskonflikte.

Mit diesem Wissen können Sie Ihre Python-Skripte sinnvoll strukturieren und Funktionen zwischen Dateien teilen – ein wichtiger Schritt zu professioneller Automatisierung.

Einfache Projektstrukturen

Warum eine klare Projektstruktur wichtig ist

In der Systemadministration und Automatisierung wächst ein Skript schnell über die Grenzen einer einzelnen Datei hinaus. Eine saubere Projektstruktur erleichtert das Wiederfinden von Code, die Wiederverwendung von Funktionen und die Zusammenarbeit mit Kollegen. Anders als bei kurzen Shell-Skripten lohnt es sich hier, den Code in Module und Unterordner zu organisieren.

Typische Verzeichnisstruktur für kleine Automatisierungsprojekte

Ein einfaches Projekt für Administrationsaufgaben könnte so aussehen:

my_automation_project/
├── README.md           # Projektbeschreibung und Nutzungshinweise
├── requirements.txt    # Liste externer Python-Pakete
├── scripts/            # Hauptskripte, die direkt ausgeführt werden
│   └── backup.py       # Beispiel: Backup-Skript
├── lib/                # Hilfsmodule mit Funktionen und Klassen
│   ├── __init__.py     # macht lib zu einem Python-Paket
│   └── file_utils.py   # Funktionen für Dateioperationen
└── config/             # Konfigurationsdateien (z.B. JSON, YAML)
    └── settings.json

- **scripts/** enthält die ausführbaren Skripte. Diese sind meist kurz und rufen Funktionen aus lib/ auf.
- **lib/** beherbergt wiederverwendbare Module, z.B. für Dateioperationen oder API-Requests.
- **config/** trennt Konfiguration vom Code, was Anpassungen ohne Codeänderung ermöglicht.

### Beispiel: Funktionen aus einem Hilfsmodul verwenden

In `lib/file_utils.py` könnten Sie eine Funktion zum Sichern von Dateien definieren:

```python
import shutil
import os

def backup_file(source: str, target_dir: str) -> None:
    """Sichert eine Datei in ein Zielverzeichnis."""
    if not os.path.isfile(source):
        raise FileNotFoundError(f"Datei nicht gefunden: {source}")
    os.makedirs(target_dir, exist_ok=True)
    shutil.copy2(source, target_dir)

Das Skript scripts/backup.py nutzt diese Funktion:

from lib import file_utils

source_path = '/var/log/syslog'
target_directory = '/backup/logs'

try:
    file_utils.backup_file(source_path, target_directory)
    print(f"Backup von {source_path} erfolgreich nach {target_directory}")
except Exception as e:
    print(f"Fehler beim Backup: {e}")

Vorteile gegenüber reinen Shell-Skripten

  • Bessere Strukturierung: Python-Module können gezielt importiert und getestet werden.
  • Wiederverwendbarkeit: Funktionen in lib/ sind unabhängig und können in mehreren Skripten genutzt werden.
  • Lesbarkeit: Klar getrennte Verantwortlichkeiten erleichtern das Verständnis.
  • Portabilität: Python-Code läuft auf verschiedenen Betriebssystemen, ohne Anpassungen an Shell-Syntax.

Best Practices für Projektstrukturen

  • Halten Sie Skripte in scripts/ schlank. Dort wird nur orchestriert, nicht komplexe Logik implementiert.
  • Verwenden Sie __init__.py in Unterordnern, um Pakete zu definieren und Importe zu erleichtern.
  • Legen Sie Konfigurationsdaten in eigenen Dateien ab, damit Anpassungen ohne Codeänderung möglich sind.
  • Dokumentieren Sie Ihr Projekt mit einer README, damit andere Nutzer schnell starten können.

Zusammenfassung

Eine einfache, aber durchdachte Projektstruktur ist der Schlüssel zu wartbarem und erweiterbarem Automatisierungscode. Sie trennt ausführbare Skripte von Hilfsfunktionen und Konfigurationen, was die Übersicht verbessert und die Wiederverwendung fördert. Gerade für Administratoren, die von Shell-Skripten kommen, bietet Python hier klare Vorteile: bessere Organisation, mehr Flexibilität und eine höhere Lesbarkeit.