Funktionsparameter

9.1 Parameter vs Argumente

Viele Anfänger verwechseln oft die Begriffe „Parameter“ und „Argumente“, aber es ist wichtig, deren Unterschied für das Verständnis der funktionalen Programmierung zu kennen.

Parameter sind Variablen, die im Funktionsdefinition aufgelistet werden. Sie sind die Namen, die eine Funktion verwendet, um auf die ihr übergebenen Werte zu verweisen. Funktionsparameter dienen als „Platzhalter“ für Werte, die im Funktionskörper verwendet werden. Wenn du eine Funktion definierst, beschreibst du deren Parameter.

def print_info(name, age):  # name und age sind Parameter
    print(f"Name: {name}, Age: {age}")        

Argumente sind die konkreten Werte oder Daten, die einer Funktion bei ihrem Aufruf übergeben werden. Argumente werden an die Stellen der Parameter eingesetzt, wenn die Funktion ausgeführt wird. Argumente können Konstanten, Variablen, Ausdrücke oder sogar Ergebnisse anderer Funktionen sein.

print_info("Alice", 30)  # "Alice" und 30 sind Argumente 

Arten von Argumenten

1. Positionsargumente: Werte werden in der Reihenfolge übergeben, in der die Parameter definiert sind.
2. Schlüsselwortargumente: Argumente, die der Funktion mithilfe des Parameternamens übergeben werden, sodass sie in beliebiger Reihenfolge nach den Positionsargumenten aufgelistet werden können.
3. Standardargumente: Funktionen können für Parameter Standardwerte festlegen.

Positionsargumente verwendest du bereits, während wir Schlüsselwortargumente und Standardargumente in den nächsten Vorlesungen besprechen werden.

Der Unterschied zwischen Parametern und Argumenten in Python hilft zu verstehen, wie Funktionen Daten erhalten und verarbeiten. Dieser Unterschied ist wichtig, um flexible Funktionen zu erstellen, die leicht an verschiedene Aufrufbedingungen angepasst werden können, wodurch dein Code modularer und wiederverwendbarer wird.

9.2 Standardwerte

Standardargumente in Python sind ein Mechanismus, der es Funktionen ermöglicht, vordefinierte Werte für einen oder mehrere Parameter festzulegen. Diese Funktionalität macht den Funktionsaufruf bequemer und flexibler, da es nicht erforderlich ist, bei jedem Funktionsaufruf explizit alle Argumente anzugeben.

Definition von Standardargumenten

Standardargumente werden in der Funktionsdefinition festgelegt, indem bei der Deklaration des Parameters ein Wert angegeben wird, der verwendet wird, wenn beim Funktionsaufruf kein Argument übergeben wird:

def print_info(name, company='Unknown'):
    print(f"Name: {name}, Company: {company}")

In diesem Beispiel hat company den Standardwert 'Unknown'.

• Erleichterung von Funktionsaufrufen: Funktionen mit vielen Parametern können mit Angabe nur der wichtigsten Argumente aufgerufen werden.
• Flexibilität: Funktionen können an verschiedene Anwendungsszenarien angepasst werden, ohne ihren Code zu ändern.
• Code-Lesbarkeit: Die explizite Angabe von Standardwerten macht den Code selbstdokumentierend.

Wichtige Nuancen

Unveränderlichkeit: Standardwerte für Argumente sollten unveränderliche Datentypen sein, wie Zahlen, Zeichenfolgen oder Tupel. Die Verwendung veränderlicher Typen (z.B. Listen oder Wörterbücher) kann unerwünschte Nebeneffekte haben, da Änderungen an diesen Objekten zwischen Funktionsaufrufen bestehen bleiben.

Reihenfolge der Argumente: Parameter mit Standardargumenten sollten nach Parametern ohne Standardargumente in der Funktionsdefinition folgen.

Noch ein Beispiel:

def create_user(username, is_admin=False):
    if is_admin:
        print(f"User {username} is an admin.")
    else:
        print(f"User {username} is a regular user.")
        
create_user("Alice")  # is_admin == False
create_user("Bob", is_admin=True)  # is_admin == True
create_user("Karl", True)  # is_admin == True

Oben sind 3 Möglichkeiten, die Funktion mit einem Standardargument aufzurufen: jede davon ist gültig.

9.3 Übergabe von Parametern nach Name

Die Übergabe von Parametern an eine Funktion nach Namen ermöglicht es, klarer anzugeben, welche Werte welchen Argumenten übergeben werden, verbessert die Lesbarkeit des Codes und verringert das Risiko von Fehlern aufgrund falscher Argumentreihenfolge.

Um einem Parameter einen Wert nach Namen zu übergeben, musst du beim Funktionsaufruf einem bestimmten Parameter einen Wert zuweisen:

funktion(parameter1 = wert, parameter2 = wert)

Diese Methode ist besonders nützlich beim Arbeiten mit Funktionen, die viele Parameter oder Parameter mit Standardwerten haben.

Vorteile der Parameterübergabe nach Name

• Klarheit und Lesbarkeit: Die Angabe des Parameternamens beim Aufruf macht den Code für andere Entwickler oder beim Zurückkehren zu eigenem alten Code leichter verständlich.
• Flexibilität: Parameter können in beliebiger Reihenfolge übergeben werden, was praktisch ist, wenn eine Funktion viele Parameter hat.
• Fehlervermeidung: Es ist nicht notwendig, sich die Reihenfolge der Funktionsparameter zu merken, was die Wahrscheinlichkeit von Fehlern bei der falschen Wertübergabe verringert.

Verwendungsbeispiele

def create_profile(name, age, job):
    print(f"Name: {name}")
    print(f"Age: {age}")
    print(f"Job: {job}")
        
create_profile(name = "John", age = 28, job = "Developer")

In diesem Beispiel werden die Parameter nicht in der Reihenfolge übergeben, aber jedem wird explizit ein Wert zugewiesen, was den Funktionsaufruf flexibler und verständlicher macht.

Beispiel 2:

Übrigens, du bist bereits früher auf die Übergabe von Parametern nach Namen gestoßen. In der Funktion print(), erinnerst du dich?

Merkmale und Einschränkungen

Parameter, die nach Namen übergeben werden, müssen nach Parametern ohne Namen folgen, wenn solche in der Funktionsdefinition existieren.

Ein Parametername darf beim Funktionsaufruf nicht mehr als einmal verwendet werden.

Die Übergabe von Parametern nach Namen ist eine mächtige Möglichkeit in Python, die den Code sicherer und verständlicher macht, insbesondere wenn Funktionen mit vielen Argumenten oder optionalen Werten verwendet werden.