Einführung
In diesem Lab werden wir untersuchen, wie man Funktionen mit Parametern in Python definiert und verwendet. Funktionen werden wesentlich leistungsfähiger, wenn sie Eingaben entgegennehmen können, was sie dynamisch und wiederverwendbar macht.
Wir werden verschiedene Arten von Funktionsparametern behandeln, darunter Positionsargumente, Standardwerte, Schlüsselwortargumente und Argumente variabler Länge. Anhand praktischer Beispiele lernen Sie, wie Sie flexible Funktionen erstellen, die eine Vielzahl von Eingaben verarbeiten können.
Funktionen mit Positionsargumenten definieren
Parameter ermöglichen es uns, Daten an eine Funktion zu übergeben, wodurch ihr Verhalten an die erhaltene Eingabe angepasst werden kann. Beginnen wir mit dem häufigsten Typ: Positionsargumente (positional parameters). Die Argumente, die an eine Funktion übergeben werden, werden den Parametern basierend auf ihrer Reihenfolge zugewiesen.
Suchen Sie zunächst im Dateiexplorer auf der linken Seite der WebIDE die Datei positional_params.py und öffnen Sie diese.
Definieren wir nun eine Funktion namens hello, die einen Parameter, name, akzeptiert. Fügen Sie den folgenden Code in die Datei positional_params.py ein:
def hello(name):
print(f'Hello, {name}!')
hello('John')
hello('Alice')
In diesem Code ist name ein Parameter, der in der Funktionsdefinition als Platzhalter dient. Wenn wir die Funktion aufrufen, wie z.B. hello('John'), ist der Wert 'John' ein Argument, das dem Parameter name zugewiesen wird.
Um das Skript auszuführen, öffnen Sie ein neues Terminal in der WebIDE, indem Sie im oberen Menü auf Terminal -> New Terminal klicken. Führen Sie dann den folgenden Befehl aus:
python3 ~/project/positional_params.py
Sie werden die folgende Ausgabe sehen, die zeigt, dass die Funktion für verschiedene Argumente unterschiedliche Ergebnisse geliefert hat:
Hello, John!
Hello, Alice!
Wenn eine Funktion mit Positionsargumenten definiert ist, müssen Sie bei jedem Aufruf ein entsprechendes Argument für jeden Parameter bereitstellen. Wenn Sie dies vergessen, führt dies zu einem Fehler.
Standardparameterwerte verwenden
Es ist oft nützlich, einem Parameter einen Standardwert zuzuweisen. Wenn bei einem Funktionsaufruf kein Argument für diesen Parameter angegeben wird, wird der Standardwert verwendet. Dies macht den Parameter optional.
Sehen wir uns an, was passiert, wenn wir eine Funktion ohne ein erforderliches Argument aufrufen. Öffnen Sie die Datei default_params.py und fügen Sie den folgenden Code hinzu:
def hello(name):
print(f'Hello, {name}!')
hello()
Speichern Sie die Datei und führen Sie sie im Terminal aus:
python3 ~/project/default_params.py
Dies führt zu einem TypeError, da die Funktion hello ein Argument erwartet, aber keines erhalten hat.
Traceback (most recent call last):
File "/home/labex/project/default_params.py", line 4, in <module>
hello()
TypeError: hello() missing 1 required positional argument: 'name'
Um dies zu beheben, können wir dem Parameter name einen Standardwert zuweisen. Ändern Sie die Datei default_params.py, indem Sie ihren Inhalt durch den folgenden Code ersetzen:
def hello(name="World"):
print(f'Hello, {name}!')
hello()
hello("Jobs")
Führen Sie das Skript nun erneut aus:
python3 ~/project/default_params.py
Die Ausgabe wird sein:
Hello, World!
Hello, Jobs!
Der erste Aufruf verwendet den Standardwert "World", während der zweite Aufruf das übergebene Argument "Jobs" verwendet.
Wichtige Regel: In einer Funktionsdefinition müssen alle Parameter ohne Standardwerte vor allen Parametern mit Standardwerten stehen. Zum Beispiel ist def func(a, b="default") korrekt, aber def func(a="default", b) verursacht einen SyntaxError.
Argumente mithilfe von Schlüsselwörtern übergeben
Beim Aufruf einer Funktion können Sie die Parameter, für die Sie Argumente bereitstellen, explizit benennen. Diese werden als Schlüsselwortargumente (keyword arguments) bezeichnet. Ihr Hauptvorteil ist, dass die Reihenfolge keine Rolle spielt, was Ihren Code lesbarer machen kann.
Öffnen Sie die Datei keyword_args.py und fügen Sie den folgenden Code hinzu:
def person(name, age):
print(f"{name} is {age} years old.")
## Aufruf mit Schlüsselwortargumenten – die Reihenfolge spielt keine Rolle
person(name="Zhang San", age=25)
person(age=50, name="Li Si")
Speichern Sie die Datei und führen Sie sie im Terminal aus:
python3 ~/project/keyword_args.py
Sie werden sehen, dass beide Aufrufe unabhängig von der Reihenfolge der Argumente korrekt funktionieren:
Zhang San is 25 years old.
Li Si is 50 years old.
Sie können auch Positionsargumente und Schlüsselwortargumente in einem einzigen Funktionsaufruf mischen. Dabei müssen Sie jedoch eine Regel beachten: Alle Positionsargumente müssen vor allen Schlüsselwortargumenten stehen.
Ersetzen Sie nun den Inhalt von keyword_args.py durch den folgenden, um diese Regel in Aktion zu sehen:
def person(name, age):
print(f"{name} is {age} years old.")
## Dies ist eine gültige Mischung aus Positionsargumenten und Schlüsselwortargumenten
person("Wang Wu", age=26)
## Dies würde einen SyntaxError verursachen: positional argument follows keyword argument
## person(age=28, "Zhao Liu")
Führen Sie das Skript erneut aus. Der gültige Aufruf wird wie erwartet ausgeführt.
python3 ~/project/keyword_args.py
Erwartete Ausgabe:
Wang Wu is 26 years old.
Eine variable Anzahl von Argumenten verarbeiten
Python-Funktionen können so gestaltet werden, dass sie eine variable Anzahl von Argumenten akzeptieren. Dies ist nützlich, wenn Sie im Voraus nicht wissen, wie viele Argumente an Ihre Funktion übergeben werden.
Variable Positionsargumente (*args)
Indem Sie ein Sternchen * vor einen Parameternamen setzen, können Sie eine beliebige Anzahl von Positionsargumenten in einem Tupel sammeln. Der Name args ist eine Konvention, aber Sie können jeden gültigen Parameternamen verwenden.
Variable Schlüsselwortargumente (**kwargs)
Indem Sie zwei Sternchen ** vor einen Parameternamen setzen, können Sie eine beliebige Anzahl von Schlüsselwortargumenten in einem Dictionary (Wörterbuch) sammeln. Der Name kwargs ist ebenfalls eine Konvention.
Fassen wir diese Konzepte zusammen. Öffnen Sie die Datei variable_args.py und fügen Sie den folgenden Code hinzu:
## Verwendung von *args zur Summierung einer variablen Anzahl von Zahlen
def calculate_sum(*numbers):
print(f"Arguments received as a tuple: {numbers}")
total = sum(numbers)
print(f"Sum: {total}\n")
## Verwendung von **kwargs zur Erfassung zusätzlicher Profilinformationen
def person_profile(name, age, **other_info):
print(f"Name: {name}")
print(f"Age: {age}")
print(f"Other Info: {other_info}\n")
## Aufruf der Funktionen
calculate_sum(1, 2, 3)
calculate_sum(10, 20, 30, 40, 50)
person_profile('Wang Wu', 26, gender="Male", job="Writer")
person_profile('Zhao Liu', 28, city="Beijing", status="Active")
Führen Sie das Skript im Terminal aus:
python3 ~/project/variable_args.py
Die Ausgabe zeigt, dass numbers ein Tupel und other_info ein Dictionary ist:
Arguments received as a tuple: (1, 2, 3)
Sum: 6
Arguments received as a tuple: (10, 20, 30, 40, 50)
Sum: 150
Name: Wang Wu
Age: 26
Other Info: {'gender': 'Male', 'job': 'Writer'}
Name: Zhao Liu
Age: 28
Other Info: {'city': 'Beijing', 'status': 'Active'}
Spezielle Parametertypen untersuchen
Python ermöglicht es Ihnen zu erzwingen, wie Argumente an eine Funktion übergeben werden können, wodurch die Signatur Ihrer Funktion klarer und weniger mehrdeutig wird. Sie können Parameter als positionsgebunden (positional-only) oder nur durch Schlüsselwort (keyword-only) festlegen.
Positionsgebundene Parameter (/)
Um festzulegen, dass Parameter nur positionsgebunden übergeben werden können, platzieren Sie sie in der Funktionsdefinition vor einem Schrägstrich (/).
Nur-Schlüsselwort-Parameter (*)
Um festzulegen, dass Parameter nur über Schlüsselwörter übergeben werden können, platzieren Sie sie nach einem Sternchen (*). Wenn dem * kein Parametername folgt, bedeutet dies, dass alle nachfolgenden Parameter nur über Schlüsselwörter übergeben werden dürfen.
Sehen wir uns an, wie diese Typen kombiniert werden können. Öffnen Sie die Datei special_params.py und fügen Sie den folgenden Code hinzu. Dieses Beispiel definiert eine Funktion mit positionsgebundenen, Standard- und nur-Schlüsselwort-Parametern.
def school_info(name, /, standard_param, *, city):
print(f'Positional-Only (name): {name}')
print(f'Standard (standard_param): {standard_param}')
print(f'Keyword-Only (city): {city}')
print('---')
## In dieser Funktion gilt:
## - `name` muss positionsgebunden übergeben werden.
## - `standard_param` kann positionsgebunden oder per Schlüsselwort übergeben werden.
## - `city` muss per Schlüsselwort übergeben werden.
## Gültige Aufrufe
school_info("Peking University", "PKU", city="Beijing")
school_info("Tsinghua University", standard_param="THU", city="Beijing")
## Ungültige Aufrufbeispiele (auskommentiert, um Fehler zu vermeiden)
## school_info(name="Zhejiang University", "ZJU", city="Hangzhou") ## TypeError: name is positional-only
## school_info("Fudan University", "FDU", "Shanghai") ## TypeError: city is keyword-only
Führen Sie das Skript aus, um das Ergebnis der gültigen Aufrufe zu sehen:
python3 ~/project/special_params.py
Die Ausgabe wird sein:
Positional-Only (name): Peking University
Standard (standard_param): PKU
Keyword-Only (city): Beijing
---
Positional-Only (name): Tsinghua University
Standard (standard_param): THU
Keyword-Only (city): Beijing
---
Diese Syntax hilft dabei, robuste und selbstdokumentierende Funktionen zu erstellen, wodurch die Mehrdeutigkeit bei deren Aufruf reduziert wird.
Zusammenfassung
In diesem Lab haben Sie die Grundlagen der Verwendung von Parametern in Python-Funktionen kennengelernt. Wir haben behandelt, wie Funktionen mit Positionsargumenten definiert und aufgerufen werden, wie Parameter durch die Bereitstellung von Standardwerten optional gemacht werden können und wie Schlüsselwortargumente (Keyword Arguments) für besser lesbaren Code verwendet werden. Sie haben auch untersucht, wie man flexible Funktionen erstellt, die eine variable Anzahl von Positionsargumenten (*args) und Schlüsselwortargumenten (**kwargs) akzeptieren können. Schließlich haben wir uns spezielle Syntax (/ und *) angesehen, um zu erzwingen, wie Argumente übergeben werden müssen, was die Klarheit und Robustheit Ihrer Funktionen verbessert.
