Funktionsdefinition und -parameter

Was sind Funktionen und warum sind sie nützlich?

Funktionen als Helfer im Code

Stell dir vor, du arbeitest in einer großen Küche. Für viele Gerichte brauchst du eine lecker gewürzte Tomatensoße. Anstatt jedes Mal von Grund auf Tomaten zu schneiden, Zwiebeln anzudünsten und abzuschmecken, hast du ein Standardrezept (eine Funktion) für "Tomatensoße zubereiten". Immer wenn du die Soße brauchst, greifst du auf dieses Rezept zurück. In der Programmierung ist eine Funktion ein benannter, wiederverwendbarer Block von Code, der eine spezifische Aufgabe erledigt. Du definierst die Aufgabe einmal und kannst sie dann beliebig oft an verschiedenen Stellen in deinem Programm "aufrufen", ohne den Code jedes Mal neu schreiben zu müssen. Das spart Tipparbeit, macht den Code übersichtlicher und erleichtert Änderungen – du musst das "Soßenrezept" nur an einer Stelle verbessern.

Das Prinzip der einzigen Verantwortung (SRP)

Ein wichtiges Designprinzip ist das Single Responsibility Principle (SRP). Es besagt, dass jede Funktion genau eine klar definierte Aufgabe haben und somit nur einen einzigen Grund haben sollte, sich zu ändern. Stell dir eine Funktion vor, die Personeninformationen aus einer Datenbank liest, diese validiert UND sie dann auf dem Bildschirm anzeigt. Diese Funktion hat drei Verantwortlichkeiten. Wenn sich die Art der Datenbankanbindung ändert, musst du die Funktion anpassen. Wenn sich die Validierungsregeln ändern, musst du sie anpassen. Wenn sich das Anzeigeformat ändert, musst du sie ebenfalls anpassen. Besser wäre es, drei separate Funktionen zu erstellen. Funktionen, die dem SRP folgen, sind:

• Leichter zu verstehen: Ihre Aufgabe ist klar und fokussiert.
• Einfacher zu testen: Du kannst jede kleine Aufgabe isoliert testen.
• Weniger fehleranfällig: Änderungen in einem Bereich beeinflussen nicht unerwartet andere Bereiche.
• Besser wiederverwendbar: Eine Funktion, die nur eine Sache gut macht, kann eher in anderen Kontexten wiederverwendet werden.

Wie erstellt und verwendet man Funktionen?

Die Anatomie einer Funktionsdefinition

Um eine Funktion zu erstellen, musst du sie definieren. Die Definition legt fest, wie die Funktion heißt, welche Informationen sie als Eingabe erwartet (Parameter) und welche Anweisungen sie ausführt. In Python sieht die grundlegende Syntax einer Funktionsdefinition so aus:

# 'def' als Schlüsselwort zum Start der Definition, beendet mit ':'
# 'funktions_name' als aussagekräftiger Name
# '(..., ...)' Liste der Parameter, kann auch leer sein '()'
def funktions_name(parameter1, parameter2):
    # Eingerückter Block mit den Anweisungen der Funktion
    ergebnis = parameter1 * parameter2 
    print("Berechnung durchgeführt.")

    # Optional: Rückgabe eines Wertes
    return ergebnis 

Daten übergeben: Parameter und Argumente

Oft soll eine Funktion nicht immer dasselbe tun, sondern mit unterschiedlichen Werten arbeiten. Dafür gibt es Parameter und Argumente.

• Parameter: Platzhalter in der Funktionsdefinition (name, stadt in def gruss(name, stadt):). Sie definieren, welche Art von Daten die Funktion erwartet.
• Argumente: Die konkreten Werte, die beim Aufruf der Funktion übergeben werden (gruss("Max", "Berlin") – hier sind "Max" und "Berlin" die Argumente).

# Definition der Funktion mit den formalen Parametern 'name' und 'stadt'
def persoenliche_begruessung(name, stadt):
    print(f"Hallo {name} aus {stadt}!")
    print("Schön, dich hier zu haben.")

# Aufruf der Funktion mit den tatsächlichen Argumenten "Anna" und "Berlin"
persoenliche_begruessung("Anna", "Berlin")

Wo sind Variablen gültig? Der Gültigkeitsbereich (Scope)

Variablen, die innerhalb einer Funktion definiert werden (inklusive Parameter), sind lokal. Sie existieren nur, solange die Funktion läuft und sind von außen nicht zugänglich. Globale Variablen werden außerhalb aller Funktionen definiert und können (grundsätzlich) von überall gelesen werden. Ihr übermäßiger Gebrauch sollte jedoch vermieden werden, da er Programme schwerer verständlich und wartbar machen kann.

globale_var = 100 # Globale Variable

def meine_funktion(param): # param ist lokal
    lokale_var = param + 10 # lokale_var ist lokal
    print(f"Innen: Lokal = {lokale_var}, Global = {globale_var}")

meine_funktion(5)
# print(lokale_var) # Fehler: lokale_var hier nicht bekannt
print(f"Außen: Global = {globale_var}")

Lernziele

• den Unterschied zwischen formalen Parametern (in der Funktionsdefinition) und tatsächlichen Argumenten (beim Funktionsaufruf) differenzieren, indem anhand von Codebeispielen die jeweilige Rolle und der Zeitpunkt ihres Auftretens (Definition vs. Aufruf) erläutert und die Notwendigkeit der Übereinstimmung (Anzahl, ggf. Typ) von Argumenten mit Parametern begründet wird.
• den Gültigkeitsbereich von Parametern und lokalen Variablen erklären, indem die Unterschiede zwischen lokalen und globalen Variablen sowie die Auswirkungen auf den Programmablauf anhand von Codebeispielen in einer modernen Programmiersprache (z.B. Python, JavaScript) erläutert werden.
• die Definition einer Funktion erklären, indem die grundlegende Syntax und Struktur einer Funktionsdefinition in einer modernen Programmiersprache (z.B. Python, JavaScript) erläutert und anhand eines einfachen Beispiels veranschaulicht wird.
• die Bedeutung von Funktionen als fundamentale Bausteine strukturierter Programmierung erklären, indem die Prinzipien der strukturierten Programmierung (Zerlegung, Abstraktion) auf die Verwendung von Funktionen bezogen werden.
• die Anwendung des Single-Responsibility-Prinzips (SRP) auf Funktionen zur Verbesserung von Wartbarkeit und Testbarkeit interpretieren, indem dargelegt wird, wie die Beschränkung einer Funktion auf eine einzige, klar definierte Aufgabe zu kohäsiverem, weniger fehleranfälligem und leichter testbarem Code führt.