Einführung
In Python ist eine Funktion ein Block von organisiertem, wiederverwendbarem Code, der verwendet wird, um eine einzelne, zusammenhängende Aktion auszuführen. Funktionen bieten eine bessere Modularität für Ihre Anwendung und ein hohes Maß an Code-Wiederverwendung.
In diesem Lab lernen Sie die Grundlagen der Erstellung und Verwendung von Funktionen in Python kennen. Sie üben das Definieren von Funktionen, die Argumente akzeptieren, die Verwendung von Schlüsselwortargumenten (Keyword Arguments) zur besseren Übersichtlichkeit, das Zurückgeben von Werten, das Verständnis des Unterschieds zwischen lokalen und globalen Variablenbereichen (Scopes) und das Erstellen prägnanter anonymer Funktionen mit lambda.
Funktionsargumente
In diesem Schritt lernen Sie, wie Sie eine Funktion definieren, die Argumente entgegennimmt. Eine Funktion kann Argumente entgegennehmen, bei denen es sich um Werte handelt, die Sie der Funktion übergeben, wenn Sie sie aufrufen.
Hinweis: Wenn Sie mit der Verwendung von WebIDE (ähnlich wie VS Code) nicht vertraut sind, lernen Sie dies bitte zuerst in diesem Lab.
Erstellen wir eine Funktion, die ein Argument namens name entgegennimmt und eine personalisierte Begrüßung ausgibt.
Öffnen Sie zuerst die Datei arguments.py im Dateiexplorer auf der linken Seite.
Kopieren Sie anschließend den folgenden Code und fügen Sie ihn in die Datei arguments.py ein. Dieser Code definiert eine Funktion say_hello, die ein Argument, name, entgegennimmt.
## Define a function that takes one argument
def say_hello(name):
print(f'Hello {name}')
## Call the function with a string argument
say_hello('Carlos')
say_hello('Wanda')
say_hello('Rose')
Führen Sie nun das Skript aus. Öffnen Sie ein Terminal in der WebIDE und führen Sie den folgenden Befehl aus:
python3 arguments.py
Sie sollten sehen, wie die Funktion mit verschiedenen Namen aufgerufen wird, was für jeden Namen eine eindeutige Begrüßung erzeugt.
Hello Carlos
Hello Wanda
Hello Rose
Dies demonstriert, wie Argumente Funktionen flexibel und wiederverwendbar machen.
Schlüsselwortargumente (Keyword Arguments)
In diesem Schritt lernen Sie, wie Sie Schlüsselwortargumente verwenden, um die Lesbarkeit des Codes zu verbessern. Wenn eine Funktion mehrere Parameter hat, können Sie angeben, welches Argument welchem Parameter entspricht, indem Sie den Namen des Parameters verwenden. Dies wird als Schlüsselwortargument (Keyword Argument) bezeichnet.
Wenn Sie Positionsargumente verwenden, ist die Reihenfolge, in der Sie diese übergeben, wichtig. Bei Schlüsselwortargumenten spielt die Reihenfolge keine Rolle, was Ihren Code expliziter und leichter verständlich macht.
Öffnen Sie die Datei keywords.py im Dateiexplorer. Kopieren Sie den folgenden Code und fügen Sie ihn ein.
## Function with multiple parameters
def say_hi(name, greeting):
print(f"{greeting} {name}")
## Positional arguments: order matters
print("Calling with positional arguments:")
say_hi('John', 'Hello')
## Keyword arguments: order doesn't matter, more readable
print("\nCalling with keyword arguments:")
say_hi(name='Anna', greeting='Hi')
Führen Sie nun das Skript im Terminal aus:
python3 keywords.py
Sie sehen die Ausgabe beider Funktionsaufrufe. Beachten Sie, wie Schlüsselwortargumente es Ihnen ermöglichen, Werte in beliebiger Reihenfolge zu übergeben.
Calling with positional arguments:
Hello John
Calling with keyword arguments:
Hi Anna
Rückgabewerte (Return Values)
In diesem Schritt erfahren Sie, wie Sie die return-Anweisung verwenden, um einer Funktion eine Ausgabe zu entlocken. Während print() einen Wert auf der Konsole anzeigt, sendet return einen Wert von der Funktion zurück. Dieser zurückgegebene Wert kann in einer Variablen gespeichert oder in anderen Ausdrücken verwendet werden.
Erstellen wir eine Funktion, die zwei Zahlen entgegennimmt, diese addiert und das Ergebnis zurückgibt.
Öffnen Sie die Datei returns.py und fügen Sie den folgenden Code hinzu. Die Funktion sum_two_numbers berechnet die Summe und verwendet das Schlüsselwort return, um das Ergebnis auszugeben.
## Function that returns a value using return statement
def sum_two_numbers(number_1, number_2):
return number_1 + number_2
## Call function and store the returned value
result = sum_two_numbers(7, 8)
print(result)
Führen Sie das Skript im Terminal aus:
python3 returns.py
Die Ausgabe wird der Wert sein, den die Funktion zurückgegeben hat, der in der Variablen result gespeichert und dann ausgegeben wurde.
15
Lokaler und Globaler Geltungsbereich (Local and Global Scope)
In diesem Schritt entdecken Sie den Unterschied zwischen lokalen und globalen Variablen-Gültigkeitsbereichen (Scopes). Der Gültigkeitsbereich einer Variablen bestimmt, wo in Ihrem Code darauf zugegriffen werden kann.
- Globaler Gültigkeitsbereich (Global Scope): Variablen, die außerhalb einer Funktion definiert sind, befinden sich im globalen Gültigkeitsbereich und können von überall im Code darauf zugegriffen werden, auch innerhalb von Funktionen.
- Lokaler Gültigkeitsbereich (Local Scope): Variablen, die innerhalb einer Funktion erstellt werden, befinden sich im lokalen Gültigkeitsbereich dieser Funktion. Sie existieren nur innerhalb dieser Funktion und können von außen nicht darauf zugegriffen werden.
Sehen wir uns zunächst an, was passiert, wenn Sie versuchen, von außerhalb des globalen Gültigkeitsbereichs auf eine lokale Variable zuzugreifen. Wenn Sie den folgenden Code ausführen würden, würde er einen NameError auslösen, da local_variable nicht im globalen Gültigkeitsbereich definiert ist.
## This code will cause an error
global_variable = 'I am available everywhere'
def some_function():
print(global_variable)
local_variable = "only available within this function"
print(local_variable)
## This will raise NameError because local_variable doesn't exist here
## print(local_variable)
Die global-Anweisung
Wenn Sie eine globale Variable innerhalb einer Funktion ändern müssen, müssen Sie Python explizit mit der global-Anweisung (global statement) darauf hinweisen.
Öffnen Sie die Datei scope.py und fügen Sie den folgenden Code hinzu. Hier verwendet die Funktion spam das Schlüsselwort global, um die globale Variable eggs zu modifizieren.
## Use 'global' keyword to modify global variable from inside function
def spam():
global eggs ## Declare that we're modifying the global variable
eggs = 'spam' ## This changes the global variable
eggs = 'global'
print(f"Before calling spam(), eggs is: {eggs}")
spam() ## Function modifies global variable
print(f"After calling spam(), eggs is: {eggs}")
Führen Sie nun das Skript aus:
python3 scope.py
Beobachten Sie die Ausgabe. Der Wert der globalen Variablen eggs wird durch den Funktionsaufruf dauerhaft geändert.
Before calling spam(), eggs is: global
After calling spam(), eggs is: spam
Lambda-Funktionen (Lambda Functions)
In diesem Schritt lernen Sie, wie Sie anonyme Einzeilen-Funktionen mit dem Schlüsselwort lambda erstellen. Eine Lambda-Funktion kann eine beliebige Anzahl von Argumenten haben, aber nur einen einzigen Ausdruck (expression). Sie sind nützlich, um kleine, temporäre Funktionen zu erstellen, ohne den Aufwand einer Standard-def-Funktionsdefinition.
Zum Beispiel eine reguläre Funktion, um zwei Zahlen zu addieren:
## Regular function definition
def add(x, y):
return x + y
Dies ist äquivalent zur folgenden lambda-Funktion:
## Lambda function: anonymous function defined in one line
add = lambda x, y: x + y
Lambdas können auch als lexikalische Closures (lexical closures) fungieren, was bedeutet, dass sie sich an einen Wert aus dem umschließenden Gültigkeitsbereich (enclosing scope) "erinnern" können, in dem sie erstellt wurden. Erstellen wir eine Funktion, die ein Lambda zurückgibt.
Öffnen Sie die Datei lambdas.py und fügen Sie den folgenden Code hinzu. Die Funktion make_adder nimmt eine Zahl n entgegen und gibt eine neue Lambda-Funktion zurück, die n zu jeder Zahl x addiert.
## Lambda closure: lambda function that captures a variable from the outer scope
def make_adder(n):
return lambda x: x + n ## Lambda captures 'n' from the outer function
## Create a function that adds 3
plus_3 = make_adder(3)
## Use the new function
result = plus_3(4) ## This will be 4 + 3
print(result)
Führen Sie das Skript in Ihrem Terminal aus:
python3 lambdas.py
Die Ausgabe zeigt das Ergebnis des Aufrufs der Lambda-Funktion, die von make_adder erstellt und zurückgegeben wurde.
7
Sie können auch andere Addierer erstellen, zum Beispiel plus_5 = make_adder(5), was eine Funktion erstellen würde, die 5 zu ihrem Argument addiert.
Zusammenfassung
In diesem Lab haben Sie die Kernkonzepte von Funktionen in Python erkundet. Sie haben gelernt, wie man Funktionen definiert und ihnen Informationen mithilfe von Argumenten übergibt. Sie haben geübt, sowohl Positionsargumente (positional arguments) als auch Schlüsselwortargumente (keyword arguments) zu verwenden, um Ihre Funktionsaufrufe klarer zu gestalten. Sie haben auch gelernt, wie man Funktionen mit der return-Anweisung Ergebnisse erzeugen lässt, wie man die Zugänglichkeit von Variablen mithilfe von lokalen und globalen Gültigkeitsbereichen (scopes) verwaltet und wie man das global-Schlüsselwort verwendet, um Variablen außerhalb einer Funktion zu modifizieren. Schließlich wurden Sie in die Leistungsfähigkeit und Prägnanz anonymer lambda-Funktionen eingeführt, um einfache Einzeilen-Funktionen und Closures zu erstellen.
