4.6 Python-Funktionen für Netzwerkskripte einfach erklärt

Python-Funktionen gehören zu den wichtigsten Bausteinen sauberer Netzwerkskripte. Für Network Engineers sind sie besonders wertvoll, weil sie dabei helfen, wiederkehrende Aufgaben in klare, wiederverwendbare und gut lesbare Blöcke zu zerlegen. Genau das ist in der Netzwerkautomation entscheidend. Ein Skript soll nicht nur einmal funktionieren, sondern später auch erweitert, angepasst, geprüft und von anderen verstanden werden können. Funktionen lösen dieses Problem, indem sie Logik kapseln: Statt denselben Code für Hostnamen, Interface-Status, VLAN-Prüfungen oder Dateiausgaben mehrfach zu schreiben, wird die Aufgabe in einer Funktion beschrieben und danach gezielt aufgerufen. So entsteht aus einem unübersichtlichen Skript schrittweise ein strukturiertes Werkzeug für den Alltag. Wer Python-Funktionen für Netzwerkskripte versteht, lernt deshalb nicht nur ein Programmierthema, sondern eine Kerntechnik, um aus kleinen Tests belastbare Automatisierung zu entwickeln.

Warum Funktionen in der Netzwerkautomation so wichtig sind

Viele erste Python-Skripte beginnen als kurze, lineare Programme. Ein paar Variablen werden definiert, eine Schleife läuft über eine Hostliste, Bedingungen prüfen Zustände, und am Ende erscheint eine Ausgabe auf dem Bildschirm. Für kleine Übungen ist das völlig ausreichend. In der Praxis wächst ein Skript aber oft schnell. Es soll mehrere Geräte verarbeiten, aus Dateien lesen, Reports schreiben, Statuswerte filtern oder später sogar APIs ansprechen. Spätestens dann wird klar, dass ungegliederter Code schwer lesbar und schwer wartbar wird.

Genau hier kommen Funktionen ins Spiel. Sie schaffen Struktur. Eine Funktion übernimmt genau eine Aufgabe, etwa das Laden einer Hostliste, das Prüfen eines Interface-Status oder das Schreiben eines Reports. Dadurch wird das Skript in logisch getrennte Teile aufgeteilt. Für Network Engineers ist das besonders hilfreich, weil viele Infrastrukturaufgaben stark wiederholbar sind. Gute Funktionen machen aus Wiederholung ein sauberes Muster.

Typische Vorteile von Funktionen

• Wiederkehrende Logik muss nicht mehrfach geschrieben werden
• Code wird lesbarer und übersichtlicher
• Änderungen lassen sich an einer zentralen Stelle vornehmen
• Fehler lassen sich leichter eingrenzen
• Ein Skript wird besser testbar und erweiterbar

Was eine Funktion in Python eigentlich ist

Eine Funktion ist ein benannter Codeblock, der eine bestimmte Aufgabe ausführt. Statt alle Schritte eines Programms direkt untereinander zu schreiben, wird Logik in einer Funktion zusammengefasst. Diese Funktion kann dann mehrfach aufgerufen werden, oft mit unterschiedlichen Eingabewerten.

Für die Netzwerkautomation ist das ideal. Ein Skript soll zum Beispiel nicht nur einen festen Hostnamen ausgeben, sondern viele unterschiedliche Geräte verarbeiten. Oder es soll nicht nur einmal eine Datei schreiben, sondern diese Funktion an mehreren Stellen nutzen. Mit Funktionen wird aus einem einmaligen Ablauf ein wiederverwendbarer Baustein.

Einfaches erstes Beispiel

def begruessung():
    print("Willkommen in der Netzwerkautomation")

begruessung()

In diesem Beispiel wird mit def eine Funktion definiert. Der eigentliche Code läuft erst, wenn die Funktion aufgerufen wird. Dieses Prinzip wirkt einfach, ist aber für größere Netzwerkskripte enorm wichtig.

Warum kleine Funktionen oft besser sind als große

Ein häufiger Anfängerfehler ist, zu viel Logik in eine einzige Funktion zu packen. Dann übernimmt eine Funktion plötzlich Dateizugriff, Datenverarbeitung, Statusprüfung und Ausgabe gleichzeitig. Solche Funktionen werden schnell unübersichtlich. Wartbarer Code entsteht meist durch kleinere Funktionen mit klarer Zuständigkeit.

Für Network Engineers ist das besonders sinnvoll, weil Netzwerkskripte oft aus klar trennbaren Schritten bestehen. Zuerst werden Daten geladen, dann geprüft, dann gefiltert, dann gespeichert. Wenn jeder dieser Schritte in einer eigenen Funktion liegt, bleibt das Skript deutlich verständlicher.

Gute Eigenschaften kleiner Funktionen

• Sie haben eine klar erkennbare Aufgabe
• Sie sind leicht wiederverwendbar
• Sie lassen sich einfacher testen
• Sie machen das Hauptskript besser lesbar

Parameter: Funktionen flexibel machen

Eine Funktion wird besonders nützlich, wenn sie nicht nur mit festen Werten arbeitet, sondern Eingaben annehmen kann. Dafür gibt es Parameter. Ein Parameter ist ein Platzhalter innerhalb der Funktionsdefinition, der beim Aufruf mit einem konkreten Wert gefüllt wird. Genau dadurch wird eine Funktion flexibel und wiederverwendbar.

In der Netzwerkautomation ist das essenziell. Eine Funktion soll nicht nur einen einzigen Hostnamen kennen, sondern beliebige Geräte verarbeiten können. Genauso soll sie nicht nur eine bestimmte VLAN-ID ausgeben, sondern mit unterschiedlichen IDs arbeiten.

Einfaches Beispiel mit Parameter

def zeige_hostname(hostname):
    print("Hostname:", hostname)

zeige_hostname("SW1")
zeige_hostname("R1")

Hier bleibt die Logik gleich, aber der Eingabewert ändert sich. Genau das macht Funktionen in Netzwerkskripten so praktisch.

Typische Parameter in Netzwerkskripten

• Hostname
• Management-IP
• Interface-Name
• VLAN-ID
• Statuswert
• Dateiname

Mehrere Parameter sinnvoll nutzen

Oft reicht ein einzelner Parameter nicht aus. Gerade in der Netzwerktechnik gehören mehrere Werte logisch zusammen. Ein Gerät hat meist einen Hostnamen und eine IP-Adresse. Ein Interface besitzt einen Namen und einen Status. Eine VLAN-Ausgabe braucht eine ID und oft einen Namen. Python-Funktionen können deshalb mehrere Parameter aufnehmen.

Beispiel mit mehreren Parametern

def zeige_geraet(hostname, mgmt_ip, rolle):
    print("Hostname:", hostname)
    print("Management-IP:", mgmt_ip)
    print("Rolle:", rolle)

zeige_geraet("SW1", "192.168.10.10", "access-switch")

So lassen sich zusammengehörige Informationen klar an eine Funktion übergeben. Das ist in der Praxis deutlich sauberer als viele globale Variablen im Skript zu verteilen.

Rückgabewerte mit return verstehen

Viele Funktionen sollen nicht nur etwas ausgeben, sondern ein Ergebnis an den restlichen Code zurückgeben. Genau dafür gibt es return. Ein Rückgabewert ist besonders wichtig, wenn die Funktion eine Information berechnet, filtert oder erzeugt und dieses Ergebnis später weiterverwendet werden soll.

In der Netzwerkautomation ist das sehr nützlich. Eine Funktion könnte etwa prüfen, ob ein Interface aktiv ist, und dann True oder False zurückgeben. Oder sie könnte aus Eingabewerten einen Gerätenamen erzeugen und den fertigen String zurückliefern.

Beispiel mit return

def erstelle_geraetename(rolle, nummer):
    return rolle + "-" + nummer

name = erstelle_geraetename("SW", "01")
print(name)

Die Funktion baut hier einen Text zusammen und gibt ihn zurück. Erst danach wird er in einer Variablen gespeichert und ausgegeben.

Der Unterschied zwischen print und return

Gerade am Anfang ist die Unterscheidung zwischen print und return sehr wichtig. print zeigt etwas an. return liefert etwas zurück. Das klingt ähnlich, ist im Skriptalltag aber ein großer Unterschied. Eine Funktion mit print zeigt einen Wert nur auf dem Bildschirm. Eine Funktion mit return macht ihn für weitere Verarbeitung verfügbar.

Für Network Engineers ist return meistens der professionellere Weg, sobald aus kleinen Beispielen echte Automatisierungslogik wird.

Vergleich in einem kleinen Beispiel

def status_text():
    return "up"

status = status_text()
print(status)

Hier liefert die Funktion den Text zurück. Dadurch kann der Wert gespeichert, geprüft oder weitergegeben werden.

Funktionen für typische Netzwerkaufgaben bauen

Der beste Weg, Funktionen zu verstehen, ist ihre direkte Anwendung auf Netzwerkaufgaben. Statt allgemeine Mathebeispiele zu verwenden, sollten Network Engineers möglichst früh mit Hostnamen, Interfaces, VLANs oder Statuswerten arbeiten. Das erhöht den Praxisbezug und macht die Logik deutlich verständlicher.

Beispiel: Interface-Status prüfen

def pruefe_interface_status(status):
    if status == "up":
        return "Interface ist aktiv"
    else:
        return "Interface ist nicht aktiv"

ergebnis = pruefe_interface_status("down")
print(ergebnis)

Diese Funktion kapselt eine kleine, aber realistische Netzwerkentscheidung. Genau solche Bausteine sind der Anfang späterer Health-Checks.

Beispiel: VLAN-Information formatieren

def formatiere_vlan(vlan_id, vlan_name):
    return f"VLAN {vlan_id}: {vlan_name}"

print(formatiere_vlan(10, "Clients"))
print(formatiere_vlan(20, "Server"))

Auch das ist ein sehr typisches Muster: Werte werden nicht nur gespeichert, sondern für Reports oder Ausgaben sinnvoll formatiert.

Funktionen und Listen kombinieren

Besonders nützlich werden Funktionen, wenn sie mit Listen kombiniert werden. Genau dann entsteht aus einem einfachen Baustein eine echte Automatisierungslogik für mehrere Objekte. Ein Skript kann etwa über viele Geräte laufen und für jedes Gerät dieselbe Funktion aufrufen.

Beispiel mit Geräteliste

def zeige_switch(hostname):
    print("Pruefe Switch:", hostname)

switches = ["SW1", "SW2", "SW3"]

for switch in switches:
    zeige_switch(switch)

Hier trennt die Funktion die eigentliche Aufgabe von der Schleifenlogik. Das macht den Code sauberer und leichter erweiterbar.

Warum diese Kombination wichtig ist

• Funktionen übernehmen die Einzelaufgabe
• Schleifen übernehmen die Wiederholung
• Der Code bleibt klar in Verantwortung und Ablauf getrennt

Funktionen mit Dictionaries und strukturierten Gerätedaten

In realistischen Netzwerkskripten werden oft nicht nur einzelne Strings übergeben, sondern Dictionaries mit mehreren Eigenschaften. Eine Funktion kann dann direkt mit einem Gerät als Datenobjekt arbeiten. Das ist im Alltag besonders praktisch, weil viele Inventardaten oder API-Antworten ähnlich aufgebaut sind.

Beispiel mit Dictionary

def zeige_geraeteinfo(geraet):
    print("Hostname:", geraet["hostname"])
    print("Management-IP:", geraet["mgmt_ip"])
    print("Rolle:", geraet["rolle"])
    print("---")

geraet1 = {
    "hostname": "SW1",
    "mgmt_ip": "192.168.10.10",
    "rolle": "access-switch"
}

zeige_geraeteinfo(geraet1)

Dieses Muster ist für die Netzwerkautomation besonders stark, weil es sehr nah an echten JSON- oder Inventarstrukturen arbeitet.

Mehrere Geräte in Kombination

def zeige_geraeteinfo(geraet):
    print("Hostname:", geraet["hostname"])
    print("Management-IP:", geraet["mgmt_ip"])
    print("Rolle:", geraet["rolle"])

geraete = [
    {"hostname": "SW1", "mgmt_ip": "192.168.10.10", "rolle": "access"},
    {"hostname": "R1", "mgmt_ip": "192.168.20.1", "rolle": "router"}
]

for geraet in geraete:
    zeige_geraeteinfo(geraet)

So entsteht schnell ein sauberes Muster für Inventarisierung oder API-Auswertung.

Dateioperationen in Funktionen kapseln

Ein weiterer sehr nützlicher Schritt besteht darin, Dateioperationen in Funktionen auszulagern. Gerade in der Netzwerkautomation werden Hostlisten, JSON-Dateien oder Reports häufig gelesen oder geschrieben. Wenn diese Logik in Funktionen liegt, bleibt das Hauptskript deutlich übersichtlicher.

Beispiel: Hostliste laden

def lade_hosts(dateiname):
    with open(dateiname, "r") as datei:
        return [zeile.strip() for zeile in datei]

hosts = lade_hosts("hosts.txt")

for host in hosts:
    print("Host:", host)

Hier übernimmt die Funktion genau eine Aufgabe: Hosts aus einer Datei lesen und als Liste zurückgeben. Das ist ein sehr typisches Muster in praktischen Netzwerkskripten.

Beispiel: Report schreiben

def schreibe_report(dateiname, eintrag):
    with open(dateiname, "a") as datei:
        datei.write(eintrag + "n")

schreibe_report("report.txt", "SW1 ist erreichbar")
schreibe_report("report.txt", "SW2 ist nicht erreichbar")

Auch das zeigt sehr gut, wie Funktionen wiederkehrende Logik aus dem Hauptskript entfernen.

Fehlerbehandlung in Funktionen einbauen

Saubere Funktionen behandeln nicht nur den Erfolgsfall, sondern möglichst auch typische Probleme. Gerade bei Dateizugriffen, JSON-Daten oder Eingaben ist das im Netzwerkumfeld sinnvoll. Eine Funktion kann dann nicht nur Daten laden, sondern auch kontrolliert auf Fehler reagieren.

Beispiel mit Fehlerbehandlung

def lade_hosts(dateiname):
    try:
        with open(dateiname, "r") as datei:
            return [zeile.strip() for zeile in datei]
    except FileNotFoundError:
        print("Datei nicht gefunden:", dateiname)
        return []

hosts = lade_hosts("hosts.txt")
print(hosts)

Die Funktion bleibt dadurch robuster. Wenn die Datei fehlt, bricht das Skript nicht unkontrolliert ab, sondern liefert eine leere Liste zurück.

Warum Funktionen den Hauptcode besser lesbar machen

Ein zentraler Vorteil von Funktionen zeigt sich im sogenannten Hauptablauf des Skripts. Ohne Funktionen steht dort oft eine lange Folge aus Dateizugriff, Bedingungen, Schleifen, Ausgaben und Fehlerbehandlung. Mit Funktionen kann der Hauptteil dagegen fast wie eine fachliche Ablaufbeschreibung gelesen werden.

Unstrukturiert gedacht

• Datei öffnen
• Hosts lesen
• Jeden Host anzeigen
• Ergebnisse speichern

Sauber mit Funktionen

hosts = lade_hosts("hosts.txt")

for host in hosts:
    zeige_hostname(host)
    schreibe_report("report.txt", f"{host} verarbeitet")

Dieser Stil ist deutlich verständlicher, weil der Hauptablauf fast wie eine Fachbeschreibung der Aufgabe wirkt.

Typische Fehler beim Arbeiten mit Funktionen

Gerade am Anfang gibt es einige typische Fehler, die Network Engineers kennen sollten. Häufig werden Funktionen zwar definiert, aber nie aufgerufen. Oder es werden Parameter erwartet, aber beim Aufruf nicht übergeben. Ein weiterer klassischer Fehler ist, dass eine Funktion mit print arbeitet, obwohl eigentlich ein Rückgabewert mit return gebraucht wird.

Häufige Anfängerfehler

• Funktion wird definiert, aber nicht aufgerufen
• Falsche Anzahl von Parametern beim Aufruf
• print statt return verwenden
• Eine Funktion übernimmt zu viele Aufgaben gleichzeitig
• Unklare Funktionsnamen erschweren das Verständnis

Beispiel für einen typischen Denkfehler

def gib_status_aus():
    print("up")

status = gib_status_aus()
print(status)

Hier wird nur etwas ausgegeben, aber nichts zurückgegeben. Deshalb enthält status keinen nützlichen Textwert. Genau solche Unterschiede sind für praktische Netzwerkskripte wichtig.

Wichtige Funktionsmuster für erste Netzwerkskripte

Für den Einstieg in die Netzwerkautomation helfen einige wiederkehrende Funktionsmuster besonders stark. Sie tauchen in sehr vielen Skripten auf und sind deshalb gute Übungsobjekte.

Besonders sinnvolle erste Funktionsarten

• Werte formatieren, etwa Hostnamen oder VLAN-Ausgaben
• Dateien lesen, etwa Hostlisten oder JSON-Daten
• Statuswerte prüfen, etwa Interface oder Gerätezustände
• Reports oder Logs schreiben
• Daten aus Dictionaries oder Listen ausgeben

Beispiel für eine kleine Kombination

def pruefe_status(status):
    if status == "online":
        return "Gerät ist erreichbar"
    return "Gerät ist nicht erreichbar"

def zeige_geraet(geraet):
    meldung = pruefe_status(geraet["status"])
    print(geraet["hostname"], "-", meldung)

geraet = {
    "hostname": "SW1",
    "status": "online"
}

zeige_geraet(geraet)

Dieses kleine Beispiel zeigt bereits sehr gut, wie Funktionen zusammenarbeiten können.

Typische CLI- und Praxisbezüge für solche Funktionen

Auch wenn diese Beispiele noch nicht direkt SSH- oder API-Bibliotheken verwenden, orientieren sie sich klar an praktischen Netzwerkaufgaben. Die Daten, die eine Funktion verarbeitet, stammen später oft aus Dateien, JSON-Antworten oder aus geparsten CLI-Ausgaben. Genau deshalb sollten Funktionen von Anfang an fachlich gedacht werden.

Typische Befehle, deren Ergebnisse später durch Funktionen verarbeitet werden

show ip interface brief
show vlan brief
show interfaces status
show access-lists
show running-config
python3 main.py
cat hosts.txt

Python-Funktionen für Netzwerkskripte einfach zu erklären heißt deshalb vor allem, ihre Rolle im Alltag sichtbar zu machen: Sie sind die Bausteine, mit denen aus kleinen Tests saubere, wartbare und wiederverwendbare Automatisierungslogik entsteht. Für Network Engineers gehören sie damit nicht nur zu den Programmiergrundlagen, sondern direkt zum praktischen Werkzeugkasten moderner Netzwerkautomation.

Konfiguriere Cisco Router & Switches und liefere ein Packet-Tracer-Lab/GNS3

Ich biete professionelle Unterstützung im Bereich Netzwerkkonfiguration und Network Automation für private Anforderungen, Studienprojekte, Lernlabore, kleine Unternehmen sowie technische Projekte. Ich unterstütze Sie bei der Konfiguration von Routern und Switches, der Erstellung praxisnaher Topologien in Cisco Packet Tracer, dem Aufbau und Troubleshooting von GNS3- und EVE-NG-Labs sowie bei der Automatisierung von Netzwerkaufgaben mit Netmiko, Paramiko, NAPALM und Ansible. Kontaktieren Sie mich jetzt – klicken Sie hier.

Meine Leistungen umfassen:

• Professionelle Konfiguration von Routern und Switches

• Einrichtung von VLANs, Trunks, Routing, DHCP, NAT, ACLs und weiteren Netzwerkfunktionen

• Erstellung von Topologien und Simulationen in Cisco Packet Tracer

• Aufbau, Analyse und Fehlerbehebung von Netzwerk-Labs in GNS3 und EVE-NG

• Automatisierung von Netzwerkkonfigurationen mit Python, Netmiko, Paramiko, NAPALM und Ansible

• Erstellung von Skripten für wiederkehrende Netzwerkaufgaben

• Dokumentation der Konfigurationen und Bereitstellung nachvollziehbarer Lösungswege

• Konfigurations-Backups, Optimierung bestehender Setups und technisches Troubleshooting

Benötigen Sie Unterstützung bei Ihrem Netzwerkprojekt, Ihrer Simulation oder Ihrer Network-Automation-Lösung? Kontaktieren Sie mich jetzt – klicken Sie hier.