Rückgabewerte und Geltungsbereiche von Funktionen in Python verstehen

Einleitung

In diesem Lab vertiefen Sie Ihr Verständnis von Funktionen in Python, indem Sie deren Rückgabewerte und das Konzept des Variablen-Scopes (Gültigkeitsbereichs) untersuchen. Sie beginnen mit der Untersuchung von Funktionen, die keinen expliziten Rückgabewert haben, und beobachten, wie sie Aktionen ausführen, ohne ein Ergebnis zu produzieren, das anderswo verwendet werden kann.

Anschließend lernen Sie, wie Sie Funktionen mit Rückgabewerten versehen, damit diese Ausgaben erzeugen können, die in Ihren Programmen erfasst und genutzt werden können. Das Lab führt Sie dann durch die Unterscheidung zwischen lokalen und globalen Variablen, erklärt deren jeweilige Gültigkeitsbereiche und wie diese die Zugänglichkeit von Variablen innerhalb und außerhalb von Funktionen beeinflussen. Sie lernen auch, wie Sie globale Variablen innerhalb von Funktionen mit dem Schlüsselwort global modifizieren und das Konzept von nonlocal-Variablen in verschachtelten Funktionen erkunden.

Funktionen ohne Rückgabewerte erkunden

In diesem Schritt erkunden wir Funktionen ohne explizite Rückgabewerte in Python. Wie wir im vorherigen Lab gelernt haben, sind Funktionen wiederverwendbare Codeblöcke, die eine bestimmte Aufgabe ausführen. Während einige Funktionen ein Ergebnis erzeugen, das an anderer Stelle im Programm verwendet werden kann (d. h. sie haben einen Rückgabewert), führen andere einfach eine Aktion aus, wie z. B. die Ausgabe auf der Konsole.

Beginnen wir mit der Erstellung eines einfachen Python-Skripts, das eine Funktion ohne Rückgabewert definiert und aufruft.

Öffnen Sie das integrierte Terminal in der WebIDE, indem Sie auf Terminal -> New Terminal klicken. Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden.

Erstellen Sie nun eine neue Datei namens no_return_function.py im Verzeichnis ~/project mithilfe des Dateiexplorers der WebIDE oder indem Sie den folgenden Befehl im Terminal ausführen:

touch ~/project/no_return_function.py

Öffnen Sie die Datei no_return_function.py im Editor der WebIDE und fügen Sie den folgenden Code hinzu:

def greet():
    print("Hello, welcome to the world of functions!")

## Call the function
greet()

Speichern Sie die Datei.

Führen Sie das Skript nun über das Terminal mit dem Befehl python aus:

python ~/project/no_return_function.py

Sie sollten die folgende Ausgabe sehen:

Hello, welcome to the world of functions!

In diesem Beispiel führt die Funktion greet() die print()-Anweisung aus, die die Nachricht auf der Konsole anzeigt. Die Funktion selbst erzeugt jedoch keinen Wert, der einer Variablen zugewiesen oder in einem Ausdruck verwendet werden kann.

Um dies weiter zu veranschaulichen, versuchen wir, das Ergebnis des Aufrufs von greet() einer Variablen zuzuweisen und dann den Wert der Variablen auszugeben.

Ändern Sie die Datei ~/project/no_return_function.py, indem Sie die folgenden Zeilen nach dem Funktionsaufruf hinzufügen:

def greet():
    print("Hello, welcome to the world of functions!")

## Call the function
result = greet()

## Print the result
print(f"The result of calling greet() is: {result}")

Speichern Sie die Datei und führen Sie sie erneut aus:

python ~/project/no_return_function.py

Die Ausgabe wird sein:

Hello, welcome to the world of functions!
The result of calling greet() is: None

Wie Sie sehen können, ist der Wert von result None, wenn wir das Ergebnis des Aufrufs von greet() der Variablen result zuweisen. In Python geben Funktionen, die das Schlüsselwort return nicht explizit verwenden (oder return ohne Wert verwenden), implizit None zurück. None ist eine spezielle Konstante in Python, die das Fehlen eines Wertes darstellt.

Dies zeigt, dass Funktionen ohne Rückgabewert hauptsächlich Aktionen oder Nebeneffekte (wie die Ausgabe auf der Konsole) ausführen, anstatt einen Wert zu erzeugen, der an anderer Stelle im Programm verwendet werden soll.

Rückgabewerte zu Funktionen hinzufügen

Im vorherigen Schritt haben wir gesehen, dass Funktionen ohne eine explizite return-Anweisung implizit None zurückgeben. In diesem Schritt lernen wir, wie wir Funktionen mithilfe des Schlüsselworts return bestimmte Werte zurückgeben lassen. Durch die Rückgabe von Werten können Funktionen Ergebnisse erzeugen, die in anderen Teilen Ihres Programms verwendet werden können, was sie wesentlich vielseitiger macht.

Die return-Anweisung wird verwendet, um eine Funktion zu beenden und einen Wert an den Aufrufer zurückzusenden. Wenn eine return-Anweisung angetroffen wird, stoppt die Funktion die Ausführung und der angegebene Wert wird zurückgegeben.

Erstellen wir ein neues Python-Skript, um die Verwendung des return-Schlüsselworts zu demonstrieren.

Erstellen Sie eine neue Datei namens return_function.py im Verzeichnis ~/project.

touch ~/project/return_function.py

Öffnen Sie ~/project/return_function.py im Editor der WebIDE und fügen Sie den folgenden Code hinzu:

def add_numbers(a, b):
    """This function adds two numbers and returns the sum."""
    sum_result = a + b
    return sum_result

## Call the function and store the returned value
total = add_numbers(5, 3)

## Print the returned value
print(f"The sum is: {total}")

## Use the returned value in another operation
another_total = add_numbers(10, 20) * 2
print(f"Another calculated value: {another_total}")

Speichern Sie die Datei.

Führen Sie das Skript nun über das Terminal aus:

python ~/project/return_function.py

Sie sollten die folgende Ausgabe sehen:

The sum is: 8
Another calculated value: 60

In diesem Beispiel nimmt die Funktion add_numbers() zwei Argumente, a und b, berechnet deren Summe und verwendet dann return sum_result, um die berechnete Summe dorthin zurückzusenden, wo die Funktion aufgerufen wurde.

Wenn wir total = add_numbers(5, 3) aufrufen, gibt die Funktion den Wert 8 zurück, der der Variablen total zugewiesen wird. Wir können dann den Wert von total ausgeben.

Ebenso gibt die Funktion bei another_total = add_numbers(10, 20) * 2 den Wert 30 zurück, der dann mit 2 multipliziert wird, und das Ergebnis 60 wird another_total zugewiesen.

Eine Funktion kann in Python jeden Objekttyp zurückgeben, einschließlich Zahlen, Zeichenketten, Listen, Wörterbüchern oder sogar anderen Funktionen.

Sie können auch mehrere Werte aus einer Funktion zurückgeben, indem Sie ein Tupel zurückgeben.

Ändern Sie ~/project/return_function.py, um eine Funktion hinzuzufügen, die mehrere Werte zurückgibt:

def get_user_info():
    """This function returns user information as a tuple."""
    name = "labex"
    age = 25
    city = "Virtual City"
    return name, age, city

## Call the function and unpack the returned tuple
user_name, user_age, user_city = get_user_info()

## Print the unpacked values
print(f"Name: {user_name}, Age: {user_age}, City: {user_city}")

Speichern Sie die Datei und führen Sie sie aus:

python ~/project/return_function.py

Die Ausgabe enthält nun die neuen Zeilen:

The sum is: 8
Another calculated value: 60
Name: labex, Age: 25, City: Virtual City

Hier gibt get_user_info() ein Tupel zurück, das den Namen, das Alter und die Stadt enthält. Wir können dieses Tupel dann beim Aufruf der Funktion in separate Variablen (user_name, user_age, user_city) entpacken.

Das Verständnis der Verwendung von return ist entscheidend für das Schreiben von Funktionen, die Ergebnisse für andere Teile Ihres Programms berechnen und bereitstellen können.

Lokale und globale Variablen unterscheiden

In diesem Schritt werden wir das Konzept des Geltungsbereichs (Scope) von Variablen in Python untersuchen, insbesondere die Unterscheidung zwischen lokalen und globalen Variablen. Der Geltungsbereich einer Variablen bezieht sich auf den Bereich eines Programms, in dem eine Variable zugänglich ist. Das Verständnis des Geltungsbereichs ist entscheidend, um Namenskonflikte zu vermeiden und die Lebensdauer von Variablen zu verwalten.

In Python können Variablen unterschiedliche Geltungsbereiche haben:

• Lokaler Geltungsbereich (Local Scope): Variablen, die innerhalb einer Funktion definiert werden, haben einen lokalen Geltungsbereich. Sie sind nur innerhalb dieser Funktion zugänglich.
• Globaler Geltungsbereich (Global Scope): Variablen, die außerhalb von Funktionen definiert werden, haben einen globalen Geltungsbereich. Sie sind von überall im Programm zugänglich, auch innerhalb von Funktionen.

Erstellen wir ein Python-Skript, um den Unterschied zwischen lokalen und globalen Variablen zu veranschaulichen.

Erstellen Sie eine neue Datei namens variable_scope.py im Verzeichnis ~/project.

touch ~/project/variable_scope.py

Öffnen Sie ~/project/variable_scope.py im Editor der WebIDE und fügen Sie den folgenden Code hinzu:

## Global variable
global_variable = "I am a global variable"

def my_function():
    ## Local variable
    local_variable = "I am a local variable"
    print(f"Inside the function:")
    print(f"  Accessing global_variable: {global_variable}")
    print(f"  Accessing local_variable: {local_variable}")

## Call the function
my_function()

## Try to access variables outside the function
print(f"\nOutside the function:")
print(f"  Accessing global_variable: {global_variable}")

## Attempting to access local_variable here will cause an error
## print(f"  Accessing local_variable: {local_variable}")

Speichern Sie die Datei.

Führen Sie das Skript nun über das Terminal aus:

python ~/project/variable_scope.py

Sie sollten die folgende Ausgabe sehen:

Inside the function:
  Accessing global_variable: I am a global variable
  Accessing local_variable: I am a local variable

Outside the function:
  Accessing global_variable: I am a global variable

In diesem Beispiel:

• global_variable wird außerhalb der Funktion definiert, daher hat sie einen globalen Geltungsbereich. Sie kann sowohl innerhalb als auch außerhalb von my_function() aufgerufen werden.
• local_variable wird innerhalb von my_function() definiert, daher hat sie einen lokalen Geltungsbereich. Sie kann nur innerhalb von my_function() aufgerufen werden.

Wenn Sie die Zeile print(f" Accessing local_variable: {local_variable}") außerhalb der Funktion auskommentieren und versuchen, das Skript auszuführen, erhalten Sie einen NameError, da local_variable im globalen Geltungsbereich nicht definiert ist.

Dies zeigt, dass lokale Variablen auf die Funktion beschränkt sind, in der sie definiert sind, während globale Variablen im gesamten Programm zugänglich sind.

Es ist wichtig zu beachten, dass, wenn Sie eine Variable innerhalb einer Funktion mit demselben Namen wie eine globale Variable definieren, die Variable innerhalb der Funktion als lokale Variable behandelt wird und die globale Variable innerhalb des Geltungsbereichs dieser Funktion "überschattet" (shadows).

Lassen Sie uns das Skript ändern, um diesen Überschattungseffekt zu zeigen.

Aktualisieren Sie die Datei ~/project/variable_scope.py mit dem folgenden Code:

## Global variable
my_variable = "I am the global version"

def another_function():
    ## Local variable with the same name as the global variable
    my_variable = "I am the local version"
    print(f"Inside another_function(): {my_variable}")

## Call the function
another_function()

## Access the global variable outside the function
print(f"Outside another_function(): {my_variable}")

Speichern Sie die Datei und führen Sie sie aus:

python ~/project/variable_scope.py

Die Ausgabe wird sein:

Inside the function:
  Accessing global_variable: I am a global variable
  Accessing local_variable: I am a local variable
Inside another_function(): I am the local version
Outside another_function(): I am the global version

Wie Sie sehen können, bezieht sich my_variable innerhalb von another_function() auf die lokale Variable. Außerhalb der Funktion bezieht sich my_variable auf die globale Variable. Die lokale Variable innerhalb der Funktion hat keinen Einfluss auf die globale Variable mit demselben Namen.

Das Verständnis der Unterscheidung zwischen lokalen und globalen Variablen ist grundlegend für das Schreiben korrekter und vorhersagbarer Python-Programme.

Globale Variablen mit dem Schlüsselwort global ändern

Im vorherigen Schritt haben wir lokale und globale Variablen behandelt und wie eine lokale Variable eine globale Variable mit demselben Namen überschatten kann. Standardmäßig behandelt Python eine Variable innerhalb einer Funktion als neue lokale Variable, wenn Sie ihr einen Wert zuweisen, auch wenn eine globale Variable mit demselben Namen existiert.

Es gibt jedoch Situationen, in denen Sie eine globale Variable innerhalb einer Funktion ändern müssen. Um dies zu tun, müssen Sie Python explizit mitteilen, dass Sie mit der globalen Variablen arbeiten möchten und keine neue lokale erstellen. Hier kommt das Schlüsselwort global ins Spiel.

Das Schlüsselwort global wird innerhalb einer Funktion verwendet, um zu deklarieren, dass sich eine Variable auf eine globale Variable bezieht. Sobald deklariert, ändern alle Zuweisungen zu dieser Variablen innerhalb der Funktion die globale Variable.

Erstellen wir ein Python-Skript, um die Verwendung des Schlüsselworts global zur Änderung einer globalen Variablen zu demonstrieren.

Erstellen Sie eine neue Datei namens modify_global.py im Verzeichnis ~/project.

touch ~/project/modify_global.py

Öffnen Sie ~/project/modify_global.py im Editor der WebIDE und fügen Sie den folgenden Code hinzu:

## Global variable
counter = 0

def increment_counter():
    ## Declare that we are using the global counter variable
    global counter
    counter += 1
    print(f"Inside function: counter is {counter}")

## Print the initial value of the global variable
print(f"Before calling function: counter is {counter}")

## Call the function to modify the global variable
increment_counter()

## Print the value of the global variable after the function call
print(f"After calling function: counter is {counter}")

Speichern Sie die Datei.

Führen Sie das Skript nun über das Terminal aus:

python ~/project/modify_global.py

Sie sollten die folgende Ausgabe sehen:

Before calling function: counter is 0
Inside function: counter is 1
After calling function: counter is 1

In diesem Beispiel:

• Wir definieren eine globale Variable counter mit dem Anfangswert 0.
• Innerhalb der Funktion increment_counter() verwenden wir global counter. Dies teilt Python mit, dass wir uns bei der Referenzierung von counter innerhalb dieser Funktion auf die globale Variable beziehen und nicht auf eine neue lokale Variable.
• Die Zeile counter += 1 modifiziert dann die globale Variable counter.
• Wir geben den Wert von counter vor und nach dem Aufruf der Funktion aus, um zu zeigen, dass die globale Variable tatsächlich geändert wurde.

Wenn wir die Zeile global counter weggelassen hätten, hätte Python counter innerhalb der Funktion als neue lokale Variable behandelt, und die globale Variable counter wäre unverändert geblieben.

Sehen wir uns an, was passiert, wenn wir das Schlüsselwort global entfernen.

Ändern Sie ~/project/modify_global.py, indem Sie die Zeile global counter entfernen:

## Global variable
counter = 0

def increment_counter_local():
    ## This will create a local counter variable
    counter = 100
    print(f"Inside function (local): counter is {counter}")

## Print the initial value of the global variable
print(f"Before calling function (local test): counter is {counter}")

## Call the function
increment_counter_local()

## Print the value of the global variable after the function call
print(f"After calling function (local test): counter is {counter}")

Speichern Sie die Datei und führen Sie sie aus:

python ~/project/modify_global.py

Die Ausgabe enthält nun die Ergebnisse des zweiten Funktionsaufrufs:

Before calling function: counter is 0
Inside function: counter is 1
After calling function: counter is 1
Before calling function (local test): counter is 1
Inside function (local): counter is 100
After calling function (local test): counter is 1

Beachten Sie, dass nach dem Aufruf von increment_counter_local() die globale Variable counter den Wert 1 behält. Die Zuweisung counter = 100 innerhalb von increment_counter_local() hat eine neue lokale Variable namens counter innerhalb des Geltungsbereichs dieser Funktion erstellt und die globale Variable counter unberührt gelassen.

Dies unterstreicht die Bedeutung der Verwendung des Schlüsselworts global, wenn Sie eine globale Variable innerhalb einer Funktion ändern möchten.

Nicht-lokale Variablen in verschachtelten Funktionen verstehen

In den vorherigen Schritten haben wir lokale und globale Variablen besprochen. Python hat auch das Konzept der "nicht-lokalen" (nonlocal) Variablen, die in verschachtelten Funktionen verwendet werden. Eine verschachtelte Funktion ist eine Funktion, die innerhalb einer anderen Funktion definiert ist.

Variablen, die in der äußeren Funktion, aber nicht in der inneren Funktion definiert sind, werden in Bezug auf die innere Funktion als nicht-lokale Variablen bezeichnet. Wenn Sie versuchen, einer Variablen in einer inneren Funktion einen Wert zuzuweisen, der im Geltungsbereich der äußeren Funktion definiert ist, erstellt Python standardmäßig eine neue lokale Variable in der inneren Funktion, ähnlich wie es mit globalen Variablen ohne das Schlüsselwort global umgeht.

Um eine Variable aus einem äußeren (aber nicht globalen) Geltungsbereich innerhalb einer inneren Funktion zu ändern, verwenden Sie das Schlüsselwort nonlocal.

Erstellen wir ein Python-Skript, um die Verwendung des Schlüsselworts nonlocal in verschachtelten Funktionen zu demonstrieren.

Erstellen Sie eine neue Datei namens nonlocal_variable.py im Verzeichnis ~/project.

touch ~/project/nonlocal_variable.py

Öffnen Sie ~/project/nonlocal_variable.py im Editor der WebIDE und fügen Sie den folgenden Code hinzu:

def outer_function():
    outer_variable = "I am in the outer function"

    def inner_function():
        ## Declare that we are using the nonlocal outer_variable
        nonlocal outer_variable
        outer_variable = "I have been modified by the inner function"
        print(f"Inside inner_function(): {outer_variable}")

    print(f"Before calling inner_function(): {outer_variable}")
    inner_function()
    print(f"After calling inner_function(): {outer_variable}")

## Call the outer function
outer_function()

Speichern Sie die Datei.

Führen Sie das Skript nun über das Terminal aus:

python ~/project/nonlocal_variable.py

Sie sollten die folgende Ausgabe sehen:

Before calling inner_function(): I am in the outer function
Inside inner_function(): I have been modified by the inner function
After calling inner_function(): I have been modified by the inner function

In diesem Beispiel:

• outer_function() definiert eine Variable outer_variable.
• inner_function() ist innerhalb von outer_function() definiert.
• Innerhalb von inner_function() verwenden wir nonlocal outer_variable. Dies teilt Python mit, dass sich outer_variable auf die Variable im nächstgelegenen umschließenden Geltungsbereich bezieht, der nicht der globale Geltungsbereich ist (in diesem Fall der Geltungsbereich von outer_function).
• Die Zuweisung outer_variable = "I have been modified by the inner function" ändert dann die in outer_function() definierte Variable outer_variable.
• Wir geben den Wert von outer_variable vor und nach dem Aufruf von inner_function() aus, um zu zeigen, dass sie von der inneren Funktion geändert wurde.

Wenn wir die Zeile nonlocal outer_variable weggelassen hätten, hätte die Zuweisung innerhalb von inner_function() eine neue lokale Variable namens outer_variable im Geltungsbereich von inner_function() erstellt, und die Variable outer_variable in outer_function() wäre unverändert geblieben.

Sehen wir uns dieses Verhalten an, indem wir das Schlüsselwort nonlocal entfernen.

Ändern Sie ~/project/nonlocal_variable.py, indem Sie die Zeile nonlocal outer_variable innerhalb von inner_function entfernen:

def outer_function_local_test():
    outer_variable = "I am in the outer function (local test)"

    def inner_function_local_test():
        ## This will create a local outer_variable
        outer_variable = "I am a local variable in inner_function"
        print(f"Inside inner_function_local_test(): {outer_variable}")

    print(f"Before calling inner_function_local_test(): {outer_variable}")
    inner_function_local_test()
    print(f"After calling inner_function_local_test(): {outer_variable}")

## Call the outer function for the local test
outer_function_local_test()

Speichern Sie die Datei und führen Sie sie aus:

python ~/project/nonlocal_variable.py

Die Ausgabe enthält nun die Ergebnisse des zweiten Funktionsaufrufs:

Before calling inner_function(): I am in the outer function
Inside inner_function(): I have been modified by the inner function
After calling inner_function(): I have been modified by the inner function
Before calling inner_function_local_test(): I am in the outer function (local test)
Inside inner_function_local_test(): I am a local variable in inner_function
After calling inner_function_local_test(): I am in the outer function (local test)

Wie Sie sehen können, bleibt in der zweiten Testausführung die Variable outer_variable in outer_function_local_test() nach dem Aufruf von inner_function_local_test() unverändert. Die Zuweisung innerhalb der inneren Funktion hat eine neue lokale Variable erstellt.

Das Schlüsselwort nonlocal ist unerlässlich, wenn Sie Variablen im Geltungsbereich einer umschließenden Funktion innerhalb einer verschachtelten Funktion ändern müssen.

Zusammenfassung

In diesem Lab haben wir Funktionen ohne explizite Rückgabewerte untersucht und verstanden, dass sie Aktionen ausführen, aber kein Ergebnis für die Zuweisung liefern. Anschließend haben wir gelernt, wie man Funktionen mithilfe des Schlüsselworts return Rückgabewerte hinzufügt, wodurch Funktionen Daten ausgeben können, die an anderer Stelle im Programm verwendet werden können. Wir haben zwischen lokalen und globalen Variablen unterschieden, ihre jeweiligen Geltungsbereiche erkannt und wie Variablen, die innerhalb einer Funktion definiert sind, lokal für diese Funktion sind. Schließlich haben wir gelernt, wie man globale Variablen innerhalb einer Funktion mit dem Schlüsselwort global modifiziert und das Konzept der nonlocal-Variablen in verschachtelten Funktionen verstanden, um Variablen im umschließenden Geltungsbereich zu ändern.