Funktionen in Python
Dieser Artikel erklärt Funktionen in Python.
YouTube Video
Funktionen in Python
Funktionen in Python sind eine wesentliche Funktion zum Definieren wiederverwendbarer Codeblöcke, die es Ihnen ermöglichen, Ihr Programm zu organisieren und zu vereinfachen, indem Sie sie bei Bedarf aufrufen. Die Verwendung von Funktionen kann die Lesbarkeit des Codes verbessern und dem DRY-Prinzip folgen (Don't Repeat Yourself, vermeiden Sie es, denselben Code mehrmals zu schreiben).
Funktionen definieren
Funktionen werden mit dem Schlüsselwort def
definiert. Die grundlegende Syntax lautet wie folgt:.
1def function_name(arg1, arg2, ..., argN):
2 """docstring (A brief description of the function)"""
3 processing
4 return return_value
Beispielsweise schreiben Sie folgendes, um eine Funktion zu definieren, die zwei Zahlen addiert:.
1def add(x, y):
2 """A function that adds two numbers and returns the result"""
3 return x + y
Funktionen aufrufen
Eine definierte Funktion kann wie folgt aufgerufen und verwendet werden:.
1result = add(3, 4)
2print(result) # Output: 7
Bestandteile einer Funktion
-
Funktionsname: Der Name der Funktion, mit dem sie aufgerufen wird.
-
Argumente (Parameter): Variablennamen, die die beim Aufruf übergebenen Daten aufnehmen. Sie können null oder mehr Argumente definieren.
-
Dokumentationszeichenkette (Docstring): Eine Zeichenkette, die verwendet wird, um den Zweck und die Verwendung einer Funktion zu beschreiben. Optional.
-
Funktionskörper: Ein eingerückter Block, in dem die von der Funktion ausgeführten Anweisungen geschrieben werden.
-
Rückgabewert: Der Wert, der dem Aufrufer mit der
return
-Anweisung zurückgegeben wird. Wennreturn
weggelassen wird, wird standardmäßigNone
zurückgegeben.
Arten von Argumenten
In Python gibt es verschiedene Arten von Argumenten.
- Positionsargumente: Die Standardmethode zum Übergeben von Argumenten an Funktionen.
- Standardargumente: Argumente mit Standardwerten, die beim Aufruf weggelassen werden können.
1def greet(name, message="Hello"):
2 print(f"{message}, {name}")
3
4greet("Alice") # "Hello, Alice"
5greet("Bob", "Good morning") # "Good morning, Bob"
- Arguments variabler Länge:
*args
zum Empfangen mehrerer Positionsargumente als Tupel und**kwargs
zum Empfangen als Wörterbuch.
1def func(*args, **kwargs):
2 print("args:", args)
3 print("kwargs:", kwargs)
4
5func(1, 2, 3, a=4, b=5)
6# Output:
7# args: (1, 2, 3)
8# kwargs: {'a': 4, 'b': 5}
Durch die korrekte Verwendung von Funktionen können Sie Python-Programme effektiver und effizienter schreiben.
Lambda-Funktionen in Python
In Python werden lambda
-Funktionen verwendet, um anonyme, prägnante Funktionen zu definieren. Anders als Funktionen, die mit dem normalen def
-Schlüsselwort definiert werden, ermöglicht lambda
das Erstellen kurzer, einzeiliger Funktionen. Hier werden wir die lambda
-Funktionen in Python ausführlich erläutern.
Grundlagen der lambda
-Funktionen
lambda
-Funktionen, auch anonyme Funktionen genannt, werden verwendet, um temporäre Funktionen ohne Namen zu definieren, wie der Name schon sagt. Die grundlegende Syntax lautet wie folgt:.
1lambda arguments: expression
arguments
: Geben Sie die Argumente der Funktion an. Mehrere Argumente können durch Kommas getrennt angegeben werden.expression
: Dies ist ein Ausdruck, der auf Grundlage der Argumente ausgewertet wird. Das Ergebnis des Ausdrucks wird zum Rückgabewert der Funktion.
Beispielsweise definiert und führt der folgende Code eine lambda
-Funktion aus, die zwei Zahlen addiert.
1add = lambda x, y: x + y
2print(add(5, 3)) # Output: 8
In diesem Beispiel ist lambda x, y: x + y
eine lambda
-Funktion, die zwei Argumente, x
und y
, annimmt und deren Summe zurückgibt.
Anwendungsmöglichkeiten von lambda
-Funktionen
lambda
-Funktionen sind nützlich in Situationen, in denen Sie spontan eine einfache Funktion definieren müssen. Sie sind besonders häufig in den folgenden Fällen anzutreffen:.
-
Wenn sie als Argumente an Funktionen übergeben werden
- Es ist nützlich in höheren Funktionen (Funktionen, die andere Funktionen als Argumente aufnehmen), wenn kurze, temporäre Funktionen übergeben werden.
-
Beim Angeben von Kriterien (Keys) zum Sortieren von Listen
- Sie sind praktisch, um Sortierkriterien (Keys) in Funktionen wie
sort()
odersorted()
anzugeben.
- Sie sind praktisch, um Sortierkriterien (Keys) in Funktionen wie
Beispiel für die Verwendung in höherwertigen Funktionen
Typische Beispiele für höherwertige Funktionen sind map()
, filter()
und reduce()
. Diese Funktionen verwenden andere Funktionen als Argumente und wenden sie auf Sequenzen wie Listen an.
1numbers = [1, 2, 3, 4, 5]
2squared = list(map(lambda x: x ** 2, numbers))
3print(squared) # Output: [1, 4, 9, 16, 25]
In diesem Beispiel wird eine lambda
-Funktion an die map()
-Funktion übergeben, um jede Zahl in einer Liste zu quadrieren.
Beispiele für die Verwendung von Listen-Sortierung
Die lambda
-Funktion kann manchmal verwendet werden, um einen benutzerdefinierten Schlüssel bei der Sortierung einer Liste anzugeben. Zum Beispiel sortiert der folgende Code eine Liste von Tupeln basierend auf dem zweiten Element.
1pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
2pairs.sort(key=lambda pair: pair[1])
3print(pairs)
4# Output: [(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]
In diesem Beispiel wird eine lambda
-Funktion verwendet, um die Tupel basierend auf ihrem zweiten Element (ein String) zu sortieren.
filter()
und lambda
Die filter()
-Funktion wird verwendet, um Elemente in einer Liste (oder einem anderen iterierbaren Objekt) basierend auf einer angegebenen Bedingung zu filtern.
1numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
2even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
3print(even_numbers) # Output: [2, 4, 6, 8]
In diesem Beispiel werden gerade Zahlen in einer Liste gefiltert, um eine neue Liste zu erstellen.
lambda
und reduce()
Die reduce()
-Funktion wird verwendet, um eine Liste auf einen einzelnen Wert zu reduzieren. Dies kann einfach mit einer lambda
-Funktion implementiert werden.
1from functools import reduce
2
3numbers = [1, 2, 3, 4, 5]
4product = reduce(lambda x, y: x * y, numbers)
5print(product) # Output: 120
In diesem Beispiel werden alle Elemente in der Liste miteinander multipliziert, um ein Ergebnis zu erhalten.
Vermeiden Sie die Verwendung komplexer lambda
-Funktionen.
Der Vorteil von lambda
-Funktionen liegt in ihrer Kürze, aber sie werden schwerer zu lesen, wenn sie für die Implementierung komplexer Logik verwendet werden. Daher ist es angebracht, sie für einfache Operationen zu verwenden, die in einer einzigen Zeile ausgedrückt werden können. Für komplexe Operationen ist es lesbarer und wartbarer, eine Funktion mit def
zu definieren.
Beispielsweise sollten Sie die Verwendung komplexer lambda
-Funktionen wie der unten gezeigten vermeiden.
1# Complex and hard-to-read lambda function
2complex_func = lambda x, y: (x * 2 + y) if x > y else (x + y * 2)
In diesem Fall ist es besser, eine Funktion zu verwenden, die mit def
definiert ist, wie unten gezeigt.
1def complex_func(x, y):
2 if x > y:
3 return x * 2 + y
4 else:
5 return x + y * 2
Fazit
Die lambda
-Funktionen in Python sind ein praktisches Werkzeug zur Definition temporärer, kurzer Funktionen. Sie werden oft in höheren Funktionen oder Listenoperationen verwendet, um spezifische Bedingungen prägnant zu definieren. Jedoch sollten lambda
-Funktionen auf einfache Aufgaben beschränkt werden, wobei def
-Funktionen für komplexe Logik bevorzugt werden.
Sie können den obigen Artikel mit Visual Studio Code auf unserem YouTube-Kanal verfolgen. Bitte schauen Sie sich auch den YouTube-Kanal an.