3.4 Funktionen und Module für Einsteiger einfach erklärt

Funktionen und Module gehören zu den wichtigsten Grundlagen in der Programmierung und sind für Einsteiger in die Netzwerkautomatisierung besonders wertvoll. Sobald Skripte größer werden als nur wenige Zeilen, reichen einzelne Variablen, Bedingungen und Schleifen allein nicht mehr aus. Code muss dann übersichtlicher, wiederverwendbar und besser strukturierbar werden. Genau an diesem Punkt kommen Funktionen und Module ins Spiel. Funktionen helfen dabei, wiederkehrende Aufgaben in saubere, benannte Bausteine zu zerlegen. Module helfen dabei, zusammengehörigen Code zu organisieren und vorhandene Funktionen aus anderen Dateien oder Bibliotheken zu nutzen. Für Netzwerker ist das besonders wichtig, weil viele Automatisierungsaufgaben aus ähnlichen Mustern bestehen: Hostnamen prüfen, IP-Adressen verarbeiten, API-Aufrufe wiederholen, Gerätezustände auslesen oder Konfigurationsdaten vergleichen. Wer Funktionen und Module versteht, kann aus kleinen Experimenten schrittweise robuste, wartbare Netzwerkskripte entwickeln.

Warum Funktionen und Module in der Netzwerkautomatisierung so wichtig sind

Viele Einsteiger beginnen mit kleinen Python-Skripten, die direkt untereinander geschrieben werden. Das ist für die ersten Übungen völlig sinnvoll. Ein Skript speichert vielleicht eine IP-Adresse, prüft einen Status und gibt ein Ergebnis aus. Sobald aber mehrere Geräte, mehrere Prüfungen oder mehrere Schritte zusammenkommen, wird ein solcher Ansatz schnell unübersichtlich. Genau deshalb sind Funktionen und Module so wichtig.

In der Netzwerkautomatisierung treten viele Aufgaben immer wieder auf. Das kann das Prüfen, ob ein Interface den Status up hat, das Aufbauen einer URL für eine API, das Ausgeben strukturierter Informationen oder das Lesen von Gerätedaten sein. Wenn solche Aufgaben jedes Mal neu ausgeschrieben werden, steigt die Fehleranfälligkeit und der Code wird schwer verständlich. Funktionen und Module lösen genau dieses Problem, weil sie Struktur und Wiederverwendbarkeit schaffen.

Wichtige Vorteile für Netzwerker

• Wiederkehrende Aufgaben müssen nicht ständig neu geschrieben werden
• Code wird klarer und besser lesbar
• Skripte lassen sich leichter erweitern und testen
• Fehlerquellen werden reduziert, weil zentrale Logik nur an einer Stelle gepflegt wird
• Komplexere Automatisierungsprojekte bleiben beherrschbar

Was eine Funktion ist

Eine Funktion ist ein benannter Codeblock, der eine bestimmte Aufgabe ausführt. Statt denselben Ablauf mehrfach im Skript zu wiederholen, wird er in einer Funktion zusammengefasst und kann danach beliebig oft aufgerufen werden. Eine Funktion hat damit einen klaren Zweck: Sie bündelt Logik in einem wiederverwendbaren Baustein.

Für Einsteiger ist das besonders hilfreich, weil dadurch Programme übersichtlicher werden. Wer eine Funktion sinnvoll benennt, erkennt schon am Namen, wofür sie gedacht ist. In der Netzwerkautomatisierung könnte es zum Beispiel Funktionen geben, die einen Hostnamen ausgeben, eine Management-IP prüfen, einen API-Pfad zusammensetzen oder VLAN-Daten formatieren.

Ein sehr einfaches Beispiel

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

begruessung()

Hier wird mit def eine Funktion namens begruessung definiert. Erst durch den Aufruf begruessung() wird der enthaltene Code ausgeführt.

Warum Funktionen besseren Code erzeugen

Ein großer Vorteil von Funktionen ist, dass sie Programme besser strukturieren. Ein langes Skript ohne Funktionen wirkt schnell wie eine einzige Kette aus Befehlen. Mit Funktionen lässt sich der Ablauf dagegen in logisch getrennte Schritte unterteilen. Das ist gerade in technischen Umgebungen wichtig, weil Netzwerkskripte häufig mehrere Aufgaben nacheinander ausführen: Daten sammeln, filtern, vergleichen, ausgeben oder speichern.

Statt alles hintereinander in einer Datei unterzubringen, können diese Schritte durch Funktionen klar benannt werden. So erkennt man leichter, welcher Teil des Skripts wofür zuständig ist.

Typische Aufgaben, die sich gut als Funktionen eignen

• IP-Adresse prüfen
• Gerätenamen formatieren
• Interface-Status bewerten
• API-Antworten aufbereiten
• Listen oder Dictionaries ausgeben

Parameter: Funktionen flexibel machen

Funktionen werden besonders nützlich, wenn sie mit unterschiedlichen Werten arbeiten können. Genau dafür gibt es Parameter. Ein Parameter ist eine Variable, die der Funktion beim Aufruf übergeben wird. Dadurch muss die Logik nicht für jeden einzelnen Fall neu geschrieben werden.

In der Netzwerkautomatisierung ist das besonders wertvoll. Eine Funktion soll nicht nur mit einem festen Gerätenamen arbeiten, sondern mit beliebigen Geräten. Sie soll nicht nur eine einzige IP-Adresse ausgeben, sondern jede übergebene Adresse verarbeiten können.

Einfaches Beispiel mit Parameter

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

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

Hier nutzt dieselbe Funktion unterschiedliche Eingabewerte. Genau dadurch entsteht Wiederverwendbarkeit.

Typische Parameter im Netzwerkumfeld

• Hostname
• IP-Adresse
• VLAN-ID
• Interface-Name
• Statuswert

Rückgabewerte mit return einfach erklärt

Viele Funktionen sollen nicht nur etwas ausgeben, sondern ein Ergebnis an den restlichen Code zurückgeben. Dafür wird in Python return verwendet. Ein Rückgabewert ist besonders nützlich, wenn die Funktion etwas berechnet, formatiert oder bewertet und das Ergebnis später weiterverarbeitet werden soll.

Für Netzwerker ist das sehr praktisch. Eine Funktion könnte zum Beispiel einen Statustext erzeugen, eine URL zusammenbauen oder prüfen, ob ein Wert gültig ist. Das Ergebnis kann dann in einer Variablen gespeichert und später verwendet werden.

Einfaches Beispiel mit return

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

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

Die Funktion gibt hier keinen Text direkt aus, sondern liefert einen Wert zurück. Dieser Wert wird anschließend in name gespeichert.

Der Unterschied zwischen print und return

Gerade am Anfang ist es wichtig, den Unterschied zwischen print und return zu verstehen. print zeigt eine Information auf dem Bildschirm an. return gibt einen Wert an das restliche Programm zurück. Beides ist nützlich, erfüllt aber unterschiedliche Aufgaben.

Wenn du nur sehen willst, was passiert, ist print hilfreich. Wenn du ein Ergebnis in einer anderen Funktion oder in einer Variablen weiterverwenden willst, brauchst du meist return. In der Netzwerkautomatisierung ist return deshalb oft wichtiger, sobald Skripte mehr als reine Demo-Ausgaben liefern sollen.

Vergleich

• print zeigt Werte an
• return liefert Werte zur Weiterverarbeitung zurück

Beispiel

def port_status():
    return "up"

status = port_status()
print(status)

Hier gibt die Funktion den Status zurück. Erst danach wird er mit print ausgegeben.

Mehrere Parameter in Funktionen verwenden

In realen Skripten reicht oft ein einzelner Wert nicht aus. Eine Funktion kann deshalb auch mehrere Parameter gleichzeitig erhalten. Das ist im Netzwerkumfeld besonders nützlich, weil viele Aufgaben aus mehreren Informationen bestehen: Hostname und IP-Adresse, Interface und Status oder VLAN-ID und Beschreibung.

Beispiel mit mehreren Parametern

def zeige_interface(interface, status):
    print("Interface:", interface)
    print("Status:", status)

zeige_interface("Gi0/1", "up")

So lassen sich logisch zusammengehörige Werte gemeinsam verarbeiten. Das macht Funktionen deutlich vielseitiger.

Warum kleine Funktionen oft besser sind als große

Ein häufiger Anfängerfehler ist, dass Funktionen zu groß werden. Dann enthalten sie sehr viele Schritte gleichzeitig und verlieren den Vorteil der Klarheit. Gerade in der Netzwerkautomatisierung sind kleinere, klar benannte Funktionen meist sinnvoller. Eine Funktion sollte möglichst genau eine logisch erkennbare Aufgabe erfüllen.

Statt eine riesige Funktion zu schreiben, die Geräte liest, Daten filtert, Bedingungen prüft und Ergebnisse speichert, ist es meist besser, mehrere kleine Funktionen zu kombinieren. So bleibt der Code leichter verständlich und einfacher testbar.

Gute Eigenschaften kleiner Funktionen

• Klare, eindeutige Aufgabe
• Wenig Seiteneffekte
• Leicht wiederverwendbar
• Einfach zu lesen und zu testen

Was ein Modul ist

Ein Modul ist in Python im einfachsten Fall einfach eine Datei mit Python-Code, die Funktionen, Variablen oder andere Bestandteile enthält und in andere Skripte eingebunden werden kann. Module helfen dabei, Code nicht nur innerhalb eines einzelnen Skripts zu strukturieren, sondern auch über mehrere Dateien hinweg zu organisieren.

Für Einsteiger ist das wichtig, weil Netzwerkautomatisierung schnell über eine einzige Datei hinausgeht. Vielleicht möchtest du Funktionen für API-Abfragen in einer Datei sammeln und sie in mehreren Skripten wiederverwenden. Oder du willst Hilfsfunktionen für Hostnamen, IP-Validierung oder Ausgaben getrennt vom eigentlichen Hauptskript halten. Genau dafür sind Module ideal.

Die Grundidee eines Moduls

• Code wird in einer eigenen Datei gespeichert
• Diese Datei kann von anderen Skripten importiert werden
• Funktionen und Logik müssen nicht dupliziert werden

Ein einfaches eigenes Modul erstellen

Angenommen, du speicherst in einer Datei namens netzwerktools.py eine kleine Funktion:

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

Dann kannst du in einer anderen Datei diese Funktion importieren und verwenden:

import netzwerktools

netzwerktools.zeige_hostname("SW1")

Damit wird klar, wie Module die Wiederverwendung vereinfachen. Die Funktion wird nur einmal definiert, kann aber in beliebig vielen Skripten genutzt werden.

Importe einfach erklärt

Damit ein Modul genutzt werden kann, muss es importiert werden. Python stellt dafür verschiedene Möglichkeiten bereit. Die einfachste ist import modulname. Danach wird auf die Funktionen des Moduls mit Punktnotation zugegriffen. Alternativ kann auch gezielt eine einzelne Funktion importiert werden.

Typische Importformen

import netzwerktools

from netzwerktools import zeige_hostname

Die erste Variante ist oft klarer, weil sofort sichtbar bleibt, aus welchem Modul eine Funktion stammt. Die zweite Variante kann kürzer sein, wenn nur einzelne Funktionen benötigt werden.

Warum Module in der Netzwerkautomatisierung so nützlich sind

In der Netzwerkautomatisierung werden Skripte schnell umfangreicher. Es gibt vielleicht Funktionen für API-Abfragen, andere für Dateiverarbeitung, wieder andere für die Bewertung von Interface- oder VLAN-Daten. Wenn alles in einer einzigen Datei landet, sinkt die Übersicht. Module helfen dabei, den Code nach Aufgaben zu sortieren.

Ein praktisches Beispiel: Ein Modul könnte Funktionen für DNS- oder IP-Prüfungen enthalten, ein anderes Modul Funktionen für JSON-Verarbeitung und ein drittes den eigentlichen Ablauf eines Inventarisierungsskripts. Genau dadurch wird aus einem chaotischen Einzelprojekt eine sauber strukturierte Codebasis.

Typische Modul-Ideen im Netzwerkumfeld

• Hilfsfunktionen für Hostnamen und IP-Adressen
• API-Funktionen für Controller oder Plattformen
• Auswertung von Interface- und VLAN-Daten
• Formatierung und Ausgabe von Inventarlisten
• Basisfunktionen für Logging oder Fehlerbehandlung

Standardmodule in Python für Einsteiger

Python bringt bereits viele nützliche Module mit. Diese Standardmodule sind für Einsteiger besonders praktisch, weil sie direkt verfügbar sind und häufige Aufgaben erleichtern. Für Netzwerker sind vor allem Module interessant, die mit JSON, Zeit, Betriebssystemdateien oder formatierten Ausgaben zu tun haben.

Einige nützliche Standardmodule

• json für strukturierte JSON-Daten
• os für Dateisystem- und Umgebungsfunktionen
• datetime für Zeitstempel und Datumswerte

Einfaches Beispiel mit json

import json

daten = '{"hostname": "SW1", "mgmt_ip": "192.168.10.10"}'
geraet = json.loads(daten)

print(geraet["hostname"])

Gerade das json-Modul ist im Automatisierungsumfeld sehr wichtig, weil viele APIs Antworten genau in diesem Format liefern.

Funktionen und Module zusammen gedacht

Der eigentliche Mehrwert entsteht, wenn Funktionen und Module zusammen genutzt werden. Funktionen strukturieren einzelne Aufgaben. Module strukturieren größere Skriptprojekte. Genau diese Kombination macht aus kleinen Übungen nach und nach brauchbare Werkzeuge für echte Netzwerkautomatisierung.

Ein kleines Projekt könnte beispielsweise ein Modul für Hilfsfunktionen, ein Modul für API-Zugriffe und ein Hauptskript für den Ablauf enthalten. So lässt sich selbst Einsteiger-Code deutlich sauberer organisieren.

Ein mögliches kleines Strukturbeispiel

• netzwerktools.py für Hilfsfunktionen
• api_tools.py für API-spezifische Logik
• main.py für den eigentlichen Ablauf

Typische Fehler bei Funktionen und Modulen

Gerade am Anfang treten bei Funktionen und Modulen einige typische Fehler auf. Viele davon sind harmlos, führen aber schnell zu Verwirrung. Wer diese Stolperstellen kennt, kann deutlich entspannter lernen.

Häufige Fehler

• Funktion wird definiert, aber nie aufgerufen
• Parameter und Argumente werden verwechselt
• print wird genutzt, obwohl eigentlich return nötig wäre
• Modulname oder Dateiname passt nicht zum Import
• Zu große Funktionen machen den Code unübersichtlich

Beispiel für einen typischen Denkfehler

def zeige_ip(ip):
    print(ip)

wert = zeige_ip("192.168.10.10")
print(wert)

Hier liefert die Funktion keinen Rückgabewert, sondern gibt nur etwas aus. Deshalb enthält wert nicht die erwartete IP-Adresse, sondern keinen nutzbaren Rückgabewert. Genau solche Unterschiede sind wichtig zu verstehen.

Warum diese Grundlagen direkt auf echte Netzwerkskripte vorbereiten

Funktionen und Module wirken anfangs wie reine Strukturhilfen. In der Netzwerkautomatisierung sind sie jedoch weit mehr als das. Sie machen aus kleinen Experimenten schrittweise brauchbare Werkzeuge. Ein Skript, das mehrere Geräte abfragt, API-Daten verarbeitet oder nur problematische Interfaces meldet, wird fast automatisch auf Funktionen und Module angewiesen sein, sobald es etwas größer wird.

Wer diese Grundlagen beherrscht, kann Code nicht nur schreiben, sondern auch sauber organisieren, wiederverwenden und verständlich halten. Genau das ist im späteren Alltag entscheidend, weil Automatisierung nicht nur funktionieren, sondern auch gewartet, angepasst und nachvollzogen werden muss.

Typische Praxisbefehle, die später oft in solche Strukturen eingebunden werden

show ip interface brief
show vlan brief
show interfaces status
show access-lists
show running-config
python3
cat daten.json
curl https://api.example.local

Genau deshalb sind Funktionen und Module für Einsteiger nicht nur ein weiteres Programmierthema, sondern ein direkter Schritt hin zu sauberer, wiederverwendbarer und realistisch nutzbarer Netzwerkautomatisierung.

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.