Funktionen und Wiederverwendbarkeit¶

Eigene Funktionen erstellen, Code strukturieren und typische Automatisierungsaufgaben übersichtlich und wartbar gestalten.

Mit zunehmender Größe eines Skripts wird es wichtig, wiederkehrende Aufgaben nicht mehrfach zu implementieren. Funktionen ermöglichen es, zusammengehörige Arbeitsschritte in klar abgegrenzte Bausteine zu kapseln und an verschiedenen Stellen wiederzuverwenden.

In der Praxis werden Funktionen beispielsweise genutzt, um Dateien einzulesen, API-Anfragen auszuführen, Logdateien auszuwerten, Konfigurationswerte zu laden oder Systeminformationen zu sammeln.

Gut strukturierte Funktionen verbessern die Lesbarkeit, erleichtern Tests und reduzieren die Wahrscheinlichkeit von Fehlern. Sie bilden damit eine wichtige Grundlage für größere Automatisierungs- und Infrastrukturprojekte.

In diesem Kapitel lernen Sie, wie Funktionen definiert werden, Parameter und Rückgabewerte funktionieren und wie Python-Funktionen in der Praxis eingesetzt werden.

Eigene Funktionen erstellen¶

Funktionen definieren und aufrufen¶

Funktionen sind in Python die grundlegenden Bausteine, um wiederverwendbaren und gut strukturierten Code zu schreiben. Sie bündeln häufig benötigte Abläufe, wie etwa das Einlesen von Logdateien oder das Prüfen von Systemzuständen, in einem einzigen, benannten Block. Das erleichtert nicht nur die Wartung, sondern auch die Automatisierung typischer Administrationsaufgaben.

Eine Funktion definieren Sie in Python mit dem Schlüsselwort def, gefolgt vom Funktionsnamen und Klammern. Der Funktionskörper wird eingerückt geschrieben:

# Beispiel: Funktion zum Ausgeben eines Begrüßungstexts

def begruessung():
    print("Willkommen zum Systemmonitor!")

begruessung()  # Funktionsaufruf

Der Aufruf der Funktion erfolgt durch Angabe ihres Namens mit Klammern. Anders als in Bash-Skripten, wo Funktionen oft mit () definiert werden, ist in Python die Einrückung entscheidend für die Struktur.

Warum Funktionen in der Administration?¶

Stellen Sie sich vor, Sie müssen regelmäßig Logdateien auf bestimmte Fehlermuster prüfen. Statt denselben Code immer wieder zu kopieren, kapseln Sie diese Logik in einer Funktion. So können Sie die Funktion an verschiedenen Stellen aufrufen, was Fehler reduziert und Änderungen vereinfacht.

Beispiel: Logdatei nach Fehlern durchsuchen¶

# Funktion zum Durchsuchen einer Logdatei nach einem Suchbegriff

def suche_in_log(dateipfad, suchbegriff):
    with open(dateipfad, 'r', encoding='utf-8') as datei:
        for zeile in datei:
            if suchbegriff in zeile:
                print(zeile.strip())

# Beispielaufruf
suche_in_log('/var/log/syslog', 'ERROR')

Diese Funktion nimmt zwei Eingaben (Parameter) entgegen: den Pfad zur Logdatei und den Suchbegriff. Sie liest die Datei zeilenweise und gibt alle Zeilen aus, die den Suchbegriff enthalten.

Funktionen als Bausteine für komplexere Aufgaben¶

Funktionen können auch andere Funktionen aufrufen, um komplexe Abläufe zu strukturieren. Zum Beispiel könnten Sie eine Funktion schreiben, die mehrere Logdateien überprüft:

# Funktion, die mehrere Logdateien nach einem Fehler durchsucht

def pruefe_logs(logdateien, fehlercode):
    for datei in logdateien:
        print(f"Prüfe {datei} auf {fehlercode}...")
        suche_in_log(datei, fehlercode)

# Aufruf mit einer Liste von Dateien
logdateien = ['/var/log/syslog', '/var/log/auth.log']
pruefe_logs(logdateien, 'ERROR')

Best Practices¶

Wählen Sie sprechende Funktionsnamen, die den Zweck klar machen.
Vermeiden Sie zu lange Funktionen; eine Funktion sollte eine klar umrissene Aufgabe erfüllen.
Nutzen Sie Funktionen, um wiederkehrende Aufgaben zu kapseln und so Redundanz zu vermeiden.
Dokumentieren Sie Funktionen mit kurzen Kommentaren oder Docstrings, um die Wartbarkeit zu erhöhen.

Zusammenfassung¶

Funktionen sind unverzichtbar, um Ihren Python-Code für Administrationsaufgaben modular, lesbar und wartbar zu gestalten. Sie helfen, wiederkehrende Abläufe zu automatisieren und komplexe Aufgaben in überschaubare Einheiten zu zerlegen. Im nächsten Abschnitt lernen Sie, wie Sie Parameter und Rückgabewerte nutzen, um Funktionen flexibel und vielseitig einzusetzen.

Parameter und Rückgabewerte¶

Parameter: Daten an Funktionen übergeben¶

Funktionen werden erst dann wirklich nützlich, wenn sie flexibel mit unterschiedlichen Eingabewerten arbeiten können. Parameter ermöglichen es, Daten an eine Funktion zu übergeben, damit sie diese verarbeiten kann. In Python werden Parameter in der Funktionsdefinition in runden Klammern angegeben:

def lese_logdatei(pfad):
    """Liest eine Logdatei ein und gibt die Zeilen zurück."""
    with open(pfad, 'r', encoding='utf-8') as datei:
        return datei.readlines()

# Aufruf mit Parameter
zeilen = lese_logdatei('/var/log/syslog')
print(f'Logdatei enthält {len(zeilen)} Zeilen.')

Im Beispiel übergeben wir den Pfad zur Logdatei als Parameter. So kann die Funktion für beliebige Dateien wiederverwendet werden.

Rückgabewerte: Ergebnisse aus Funktionen erhalten¶

Funktionen können Werte zurückgeben, die das Ergebnis ihrer Verarbeitung darstellen. Das geschieht mit dem Schlüsselwort return. Das ermöglicht es, Funktionen als Bausteine zu verwenden, deren Ausgabe weiterverarbeitet werden kann.

def zaehle_fehlermeldungen(zeilen):
    """Zählt Zeilen, die das Wort 'ERROR' enthalten."""
    return sum(1 for zeile in zeilen if 'ERROR' in zeile)

fehleranzahl = zaehle_fehlermeldungen(zeilen)
print(f'Anzahl Fehler: {fehleranzahl}')

Hier liefert die Funktion eine Zahl zurück, die wir direkt ausgeben oder weiterverwenden können.

Mehrere Parameter für flexible Funktionen¶

Funktionen können mehrere Parameter haben, um verschiedene Eingaben zu erlauben. Beispiel: Ein Skript, das Logdateien filtert und optional nur Zeilen eines bestimmten Levels zurückgibt.

def filtere_logs(zeilen, level=None):
    """Filtert Logzeilen nach einem Level wie 'ERROR' oder 'WARNING'."""
    if level is None:
        return zeilen  # Keine Filterung
    return [zeile for zeile in zeilen if level in zeile]

warnungen = filtere_logs(zeilen, level='WARNING')
print(f'Gefundene Warnungen: {len(warnungen)}')

Standardwerte für Parameter¶

Oft ist es sinnvoll, Parameter mit Standardwerten zu versehen, damit sie nicht bei jedem Aufruf angegeben werden müssen. Das erhöht die Benutzerfreundlichkeit.

def sichere_datei(pfad, backup_erstellen=True):
    """Erstellt ein Backup der Datei, falls gewünscht."""
    import shutil
    if backup_erstellen:
        shutil.copy2(pfad, pfad + '.bak')
        print(f'Backup von {pfad} erstellt.')
    else:
        print('Kein Backup erstellt.')

sichere_datei('/etc/hosts')           # Backup wird erstellt
sichere_datei('/etc/hosts', False)    # Backup wird nicht erstellt

Keyword-Argumente für mehr Übersicht¶

Beim Aufruf können Parameter auch explizit mit Namen angegeben werden. Das erhöht die Lesbarkeit, besonders wenn eine Funktion viele Parameter hat.

sichere_datei(pfad='/etc/hosts', backup_erstellen=False)

Best Practices¶

Verwenden Sie sprechende Parameternamen, die den Zweck klar machen.
Nutzen Sie Standardwerte, um Funktionen flexibel und einfach aufzurufen.
Verwenden Sie return, um Ergebnisse klar und explizit zurückzugeben.
Nutzen Sie Keyword-Argumente beim Aufruf für bessere Lesbarkeit.

Zusammenfassung¶

Parameter und Rückgabewerte sind essenziell, um Funktionen modular und flexibel zu gestalten. Sie ermöglichen es, Funktionen als wiederverwendbare Bausteine zu schreiben, die mit unterschiedlichen Eingaben arbeiten und Ergebnisse liefern – eine wichtige Grundlage für effiziente Automatisierung und Administration mit Python.

Funktionen für Automatisierung und Administration¶

Funktionen zur Dateiverarbeitung¶

Dateien sind in der Administration allgegenwärtig – sei es für Logs, Konfigurationen oder Backups. Funktionen helfen, wiederkehrende Lese- und Schreiboperationen zu kapseln und Fehlerquellen zu reduzieren.

import os

def lese_logdatei(pfad: str) -> list[str]:
    """Liest eine Logdatei zeilenweise und gibt eine Liste der Zeilen zurück."""
    if not os.path.isfile(pfad):
        raise FileNotFoundError(f"Datei nicht gefunden: {pfad}")
    with open(pfad, 'r', encoding='utf-8') as datei:
        return datei.readlines()

# Beispielaufruf
log_zeilen = lese_logdatei('/var/log/syslog')
print(f"Anzahl Logzeilen: {len(log_zeilen)}")

API-Abfragen automatisieren¶

Viele Admin-Aufgaben erfordern das Abfragen von REST-APIs, z. B. bei Cloud-Diensten oder Monitoring-Tools. Funktionen strukturieren diese Abfragen und erlauben flexible Parameterübergabe.

import requests

def hole_status(api_url: str, token: str) -> dict:
    """Fragt eine API mit Authentifizierung ab und gibt die JSON-Antwort zurück."""
    headers = {'Authorization': f'Bearer {token}'}
    response = requests.get(api_url, headers=headers, timeout=10)
    response.raise_for_status()  # Fehler bei HTTP-Statuscodes
    return response.json()

# Beispiel
api_endpoint = 'https://api.example.com/status'
auth_token = 'dein_token'
status = hole_status(api_endpoint, auth_token)
print(f"Serverstatus: {status.get('state')}")

Hier wird der HTTP-Request in einer Funktion gekapselt. So lässt sich die API-Abfrage an verschiedenen Stellen im Skript wiederverwenden, ohne Code zu duplizieren.

Logdateien analysieren¶

Ein häufiger Anwendungsfall ist das Filtern und Auswerten von Logeinträgen. Funktionen ermöglichen modulare Analyse-Schritte.

def filtere_fehlermeldungen(log_zeilen: list[str]) -> list[str]:
    """Filtert alle Zeilen mit dem Wort 'ERROR' heraus."""
    return [zeile for zeile in log_zeilen if 'ERROR' in zeile]

# Beispiel
fehler = filtere_fehlermeldungen(log_zeilen)
print(f"Gefundene Fehler: {len(fehler)}")

Dadurch wird der Code übersichtlich und einzelne Schritte lassen sich separat testen oder anpassen.

Systemprüfungen strukturieren¶

Auch wiederkehrende Systemchecks, wie das Prüfen von freien Festplattenplatz oder laufenden Diensten, lassen sich in Funktionen bündeln.

import shutil

def pruefe_freien_speicher(pfad: str, mindest_frei_mb: int = 500) -> bool:
    """Überprüft, ob auf dem angegebenen Pfad mindestens mindest_frei_mb Megabyte frei sind."""
    frei_bytes = shutil.disk_usage(pfad).free
    frei_mb = frei_bytes / (1024 * 1024)
    return frei_mb >= mindest_frei_mb

# Beispiel
if not pruefe_freien_speicher('/', 1000):
    print("Warnung: Wenig freier Speicher auf Root-Partition.")

Solche Funktionen können in größeren Automatisierungsskripten als Bausteine dienen, um z. B. vor einem Backup den Speicherplatz zu prüfen.

Vorteile gegenüber Shell-Skripten¶

Bessere Fehlerbehandlung: Python-Funktionen können Ausnahmen auslösen und gezielt behandelt werden.
Struktur und Wiederverwendbarkeit: Funktionen kapseln Logik und reduzieren Code-Duplikate.
Lesbarkeit: Python-Code ist oft klarer und weniger fehleranfällig als komplexe Shell-Konstrukte.
Erweiterbarkeit: Python bietet zahlreiche Bibliotheken für Netzwerke, APIs und Dateiformate.

Zusammenfassung¶

Funktionen sind das Herzstück, um Automatisierungsaufgaben in Python übersichtlich, modular und wartbar zu gestalten. Sie helfen, typische Admin-Aufgaben wie Dateiverarbeitung, API-Abfragen, Loganalysen und Systemprüfungen sauber zu strukturieren und wiederverwendbar zu machen. So sparen Sie Zeit und vermeiden Fehler im täglichen Betrieb.