Funktionen sind der Eckpfeiler modularen und wiederverwendbaren Python-Codes. Dieses Tutorial befasst sich eingehend mit den Feinheiten von Funktionsargumenten und vermittelt Ihnen das Wissen, um sauberere, effizientere und weniger fehleranfällige Programme zu schreiben.
Inhaltsverzeichnis
- Positionelle Argumente
- Keyword-Argumente
- Standardargumente
- Variable Anzahl von Argumenten (*args und **kwargs)
- Mutable vs. Immutable Argumente
Positionelle Argumente
Positionelle Argumente sind die einfachste Form. Sie werden einer Funktion in der Reihenfolge übergeben, in der sie definiert sind. Die Reihenfolge ist streng einzuhalten; eine nicht übereinstimmende Reihenfolge der Argumente beim Funktionsaufruf führt zu falschen Ergebnissen oder Fehlern.
def greet(name, greeting):
print(f"{greeting}, {name}!")
greet("Alice", "Hello") # Richtige Reihenfolge
greet("Hello", "Alice") # Falsche Reihenfolge - gibt "Alice, Hello!" aus
Keyword-Argumente
Keyword-Argumente ermöglichen es Ihnen, den Argumentnamen beim Aufruf einer Funktion anzugeben. Dies macht Ihren Code lesbarer und weniger fehleranfällig, insbesondere bei Funktionen mit vielen Parametern. Die Reihenfolge der Keyword-Argumente spielt keine Rolle.
def describe_pet(animal_type, pet_name, age=None):
print(f"nIch habe ein {animal_type}.")
print(f"Der Name meines {animal_type} ist {pet_name.title()}.")
if age:
print(f"Mein {animal_type} ist {age} Jahre alt.")
describe_pet(animal_type='hamster', pet_name='harry')
describe_pet(pet_name='willie', animal_type='hund', age=5)
Standardargumente
Standardargumente liefern einen Standardwert für Funktionsparameter. Wenn beim Funktionsaufruf kein Wert angegeben wird, wird der Standardwert verwendet. Standardargumente sollten in der Funktionsdefinition immer nach Nicht-Standardargumenten platziert werden.
def power(base, exponent=2):
return base ** exponent
print(power(3)) # Ausgabe: 9 (Exponent standardmäßig 2)
print(power(3, 3)) # Ausgabe: 27
Variable Anzahl von Argumenten (*args und **kwargs)
Die Syntax `*args` und `**kwargs` ermöglicht es Ihnen, eine variable Anzahl von positionsabhängigen und Keyword-Argumenten zu verarbeiten. `*args` sammelt positionsabhängige Argumente in einem Tupel, während `**kwargs` Keyword-Argumente in einem Dictionary sammelt.
def my_function(*args, **kwargs):
print("Positionsabhängige Argumente:", args)
print("Keyword-Argumente:", kwargs)
my_function(1, 2, 3, name="Alice", age=30)
Mutable vs. Immutable Argumente
Das Verständnis von Mutabilität ist entscheidend bei der Arbeit mit Funktionsargumenten. Unveränderliche Objekte (wie Zahlen, Strings, Tupel) können innerhalb einer Funktion nicht verändert werden; alle Änderungen erzeugen ein neues Objekt. Veränderliche Objekte (wie Listen, Dictionaries) können direkt verändert werden, wodurch das ursprüngliche Objekt außerhalb der Funktion beeinflusst wird. Dies kann zu unerwarteten Nebeneffekten führen, wenn es nicht sorgfältig behandelt wird.
def modify_list(my_list):
my_list.append(4) # Modifiziert die ursprüngliche Liste
my_list = [1, 2, 3]
modify_list(my_list)
print(my_list) # Ausgabe: [1, 2, 3, 4] (ursprüngliche Liste modifiziert)
def modify_string(my_string):
my_string += "!!!" # Erzeugt einen neuen String
my_string = "Hello"
modify_string(my_string)
print(my_string) # Ausgabe: Hello (ursprünglicher String unverändert)
Diese umfassende Anleitung bietet eine solide Grundlage für die Arbeit mit Funktionsargumenten in Python. Die Beherrschung dieser Konzepte wird die Qualität und Wartbarkeit Ihres Codes deutlich verbessern.