Wie man prüft, ob eine Funktion in Python einen bestimmten Wert zurückgibt

Einführung

In diesem Lab lernen Sie, wie Sie prüfen können, ob eine Python-Funktion einen bestimmten Wert zurückgibt. Das Lab konzentriert sich auf das Verständnis von Funktionsrückgaben mithilfe der return-Anweisung und die Überprüfung der Ausgabe.

Sie beginnen damit, ein Python-Skript zu erstellen, das eine Funktion enthält, die die Summe zweier Zahlen berechnet und das Ergebnis zurückgibt. Anschließend führen Sie das Skript aus und beobachten die Ausgabe. Abschließend ändern Sie das Skript so, dass es basierend auf einer Bedingung verschiedene Werte zurückgibt und überprüfen den zurückgegebenen Wert.

Funktionsrückgaben verstehen

In diesem Schritt lernen Sie etwas über Funktionsrückgaben in Python. Funktionen sind wiederverwendbare Codeblöcke, die bestimmte Aufgaben ausführen. Oft möchten Sie, dass eine Funktion Ihnen nach Abschluss ihrer Arbeit ein Ergebnis zurückgibt. Dies wird mit der return-Anweisung erreicht.

Beginnen wir damit, ein einfaches Python-Skript zu erstellen, das eine Funktion mit einem Rückgabewert definiert.

Öffnen Sie den VS Code-Editor in der LabEx-Umgebung.
Erstellen Sie eine neue Datei mit dem Namen calculate_sum.py im Verzeichnis ~/project.
```
~/project/calculate_sum.py
```
Fügen Sie den folgenden Code zur Datei calculate_sum.py hinzu:
```
def calculate_sum(x, y):
    """
    This function calculates the sum of two numbers.
    """
    sum_result = x + y
    return sum_result

## Example usage:
num1 = 10
num2 = 5
result = calculate_sum(num1, num2)
print("The sum of", num1, "and", num2, "is", result)
```
In diesem Code:
- Wir definieren eine Funktion namens calculate_sum, die zwei Argumente x und y akzeptiert.
- Innerhalb der Funktion berechnen wir die Summe von x und y und speichern sie in einer Variablen namens sum_result.
- Die Anweisung return sum_result sendet den Wert von sum_result an den Aufrufer der Funktion zurück.
- Anschließend rufen wir die Funktion mit num1 = 10 und num2 = 5 auf und speichern den zurückgegebenen Wert in der Variablen result.
- Schließlich verwenden wir die print()-Funktion, um das Ergebnis anzuzeigen.
Führen Sie nun das Skript mit dem folgenden Befehl im Terminal aus:
```
python ~/project/calculate_sum.py
```
Sie sollten die folgende Ausgabe sehen:
```
The sum of 10 and 5 is 15
```
Diese Ausgabe bestätigt, dass die Funktion die Summe korrekt berechnet und den Wert zurückgegeben hat, der dann auf der Konsole ausgegeben wurde.

Ändern wir das Skript so, dass es basierend auf einer Bedingung einen anderen Wert zurückgibt. Bearbeiten Sie die Datei calculate_sum.py und fügen Sie Folgendes hinzu:

def calculate_sum(x, y):
    """
    This function calculates the sum of two numbers.
    If the sum is greater than 10, it returns double the sum.
    """
    sum_result = x + y
    if sum_result > 10:
        return sum_result * 2
    else:
        return sum_result

## Example usage:
num1 = 10
num2 = 5
result = calculate_sum(num1, num2)
print("The sum of", num1, "and", num2, "is", result)

num3 = 2
num4 = 3
result2 = calculate_sum(num3, num4)
print("The sum of", num3, "and", num4, "is", result2)

Hier haben wir eine bedingte Anweisung (if sum_result > 10:) hinzugefügt, um zu prüfen, ob die Summe größer als 10 ist. Wenn dies der Fall ist, gibt die Funktion die doppelte Summe zurück; andernfalls gibt sie die ursprüngliche Summe zurück.

Führen Sie das Skript erneut aus:
```
python ~/project/calculate_sum.py
```
Sie sollten nun die folgende Ausgabe sehen:
```
The sum of 10 and 5 is 30
The sum of 2 and 3 is 5
```
Der erste Aufruf von calculate_sum gibt 30 zurück, weil die Summe (15) größer als 10 ist und somit verdoppelt wird. Der zweite Aufruf gibt 5 zurück, weil die Summe (5) nicht größer als 10 ist.

Funktion aufrufen und Ausgabe erfassen

In diesem Schritt lernen Sie, wie Sie in Python eine Funktion aufrufen und ihre Ausgabe erfassen. Das Erfassen der Ausgabe einer Funktion ermöglicht es Ihnen, den zurückgegebenen Wert in weiteren Berechnungen oder Operationen innerhalb Ihres Skripts zu verwenden.

Wir verwenden weiterhin die Datei calculate_sum.py aus dem vorherigen Schritt. Wenn Sie den vorherigen Schritt nicht abgeschlossen haben, erstellen Sie bitte die Datei mit folgendem Inhalt:

def calculate_sum(x, y):
    """
    This function calculates the sum of two numbers.
    If the sum is greater than 10, it returns double the sum.
    """
    sum_result = x + y
    if sum_result > 10:
        return sum_result * 2
    else:
        return sum_result

## Example usage:
num1 = 10
num2 = 5
result = calculate_sum(num1, num2)
print("The sum of", num1, "and", num2, "is", result)

num3 = 2
num4 = 3
result2 = calculate_sum(num3, num4)
print("The sum of", num3, "and", num4, "is", result2)

Jetzt ändern wir das Skript, um die Ausgabe der calculate_sum-Funktion zu erfassen und damit zusätzliche Operationen durchzuführen.

Öffnen Sie die Datei calculate_sum.py im VS Code-Editor.

Ändern Sie das Skript wie folgt:

def calculate_sum(x, y):
    """
    This function calculates the sum of two numbers.
    If the sum is greater than 10, it returns double the sum.
    """
    sum_result = x + y
    if sum_result > 10:
        return sum_result * 2
    else:
        return sum_result

## Example usage:
num1 = 10
num2 = 5
result = calculate_sum(num1, num2)
print("The sum of", num1, "and", num2, "is", result)

## Capture the output and perform an additional operation
final_result = result + 20
print("The final result after adding 20 is:", final_result)

num3 = 2
num4 = 3
result2 = calculate_sum(num3, num4)
print("The sum of", num3, "and", num4, "is", result2)

## Capture the output and perform an additional operation
final_result2 = result2 * 2
print("The final result after multiplying by 2 is:", final_result2)

In diesem geänderten Skript:

Wir rufen die calculate_sum-Funktion mit num1 und num2 auf und speichern den zurückgegebenen Wert in der Variablen result.
Wir addieren dann 20 zu result und speichern das Ergebnis in final_result.
Schließlich geben wir den Wert von final_result aus.
Wir rufen auch die calculate_sum-Funktion mit num3 und num4 auf und speichern den zurückgegebenen Wert in der Variablen result2.
Wir multiplizieren dann result2 mit 2 und speichern das Ergebnis in final_result2.
Schließlich geben wir den Wert von final_result2 aus.

Führen Sie das Skript mit dem folgenden Befehl aus:
```
python ~/project/calculate_sum.py
```
Sie sollten die folgende Ausgabe sehen:
```
The sum of 10 and 5 is 30
The final result after adding 20 is: 50
The sum of 2 and 3 is 5
The final result after multiplying by 2 is: 10
```
Diese Ausgabe zeigt, dass Sie erfolgreich eine Funktion aufrufen, ihren zurückgegebenen Wert erfassen und diesen Wert in nachfolgenden Operationen innerhalb Ihres Skripts verwenden können.

Ausgabe mit erwartetem Wert vergleichen

In diesem Schritt lernen Sie, wie Sie die Ausgabe einer Funktion mit einem erwarteten Wert vergleichen. Dies ist ein entscheidender Teil des Testens und der Gewährleistung, dass Ihre Funktionen korrekt funktionieren. Indem Sie die tatsächliche Ausgabe mit der erwarteten Ausgabe vergleichen, können Sie Fehler in Ihrem Code identifizieren und beheben.

Wir verwenden weiterhin die Datei calculate_sum.py aus den vorherigen Schritten. Wenn Sie die vorherigen Schritte nicht abgeschlossen haben, erstellen Sie bitte die Datei mit folgendem Inhalt:

def calculate_sum(x, y):
    """
    This function calculates the sum of two numbers.
    If the sum is greater than 10, it returns double the sum.
    """
    sum_result = x + y
    if sum_result > 10:
        return sum_result * 2
    else:
        return sum_result

## Example usage:
num1 = 10
num2 = 5
result = calculate_sum(num1, num2)
print("The sum of", num1, "and", num2, "is", result)

## Capture the output and perform an additional operation
final_result = result + 20
print("The final result after adding 20 is:", final_result)

num3 = 2
num4 = 3
result2 = calculate_sum(num3, num4)
print("The sum of", num3, "and", num4, "is", result2)

## Capture the output and perform an additional operation
final_result2 = result2 * 2
print("The final result after multiplying by 2 is:", final_result2)

Jetzt fügen wir eine Funktion hinzu, um die Ausgabe mit einem erwarteten Wert zu vergleichen und eine Nachricht auszugeben, die angibt, ob der Test bestanden oder fehlgeschlagen ist.

Öffnen Sie die Datei calculate_sum.py im VS Code-Editor.

Ändern Sie das Skript wie folgt:

def calculate_sum(x, y):
    """
    This function calculates the sum of two numbers.
    If the sum is greater than 10, it returns double the sum.
    """
    sum_result = x + y
    if sum_result > 10:
        return sum_result * 2
    else:
        return sum_result

def compare_output(actual_output, expected_output):
    """
    This function compares the actual output with the expected output.
    """
    if actual_output == expected_output:
        print("Test passed!")
    else:
        print("Test failed. Expected:", expected_output, "Actual:", actual_output)

## Example usage:
num1 = 10
num2 = 5
result = calculate_sum(num1, num2)
print("The sum of", num1, "and", num2, "is", result)

## Capture the output and perform an additional operation
final_result = result + 20
print("The final result after adding 20 is:", final_result)

## Compare the output with the expected value
expected_final_result = 50
compare_output(final_result, expected_final_result)

num3 = 2
num4 = 3
result2 = calculate_sum(num3, num4)
print("The sum of", num3, "and", num4, "is", result2)

## Capture the output and perform an additional operation
final_result2 = result2 * 2
print("The final result after multiplying by 2 is:", final_result2)

## Compare the output with the expected value
expected_final_result2 = 10
compare_output(final_result2, expected_final_result2)

In diesem geänderten Skript:

Wir definieren eine Funktion namens compare_output, die zwei Argumente akzeptiert: actual_output und expected_output.
Innerhalb der Funktion vergleichen wir die actual_output mit der expected_output.
Wenn sie gleich sind, geben wir "Test passed!" aus.
Wenn sie nicht gleich sind, geben wir "Test failed." zusammen mit den erwarteten und tatsächlichen Werten aus.
Wir rufen dann die compare_output-Funktion mit final_result und expected_final_result auf, um die Ausgabe der ersten Berechnung mit dem erwarteten Wert von 50 zu vergleichen.
Wir rufen auch die compare_output-Funktion mit final_result2 und expected_final_result2 auf, um die Ausgabe der zweiten Berechnung mit dem erwarteten Wert von 10 zu vergleichen.

Führen Sie das Skript mit dem folgenden Befehl aus:
```
python ~/project/calculate_sum.py
```
Sie sollten die folgende Ausgabe sehen:
```
The sum of 10 and 5 is 30
The final result after adding 20 is: 50
Test passed!
The sum of 2 and 3 is 5
The final result after multiplying by 2 is: 10
Test passed!
```
Diese Ausgabe zeigt, dass Sie die Ausgabe einer Funktion erfolgreich mit einem erwarteten Wert vergleichen und feststellen können, ob der Test bestanden oder fehlgeschlagen ist.

Zusammenfassung

In diesem Labo (Laborübung) konzentriert sich der erste Schritt auf das Verständnis von Funktionsrückgaben in Python. Dabei wird ein Skript namens calculate_sum.py erstellt, das eine Funktion calculate_sum(x, y) definiert. Diese Funktion berechnet die Summe zweier eingegebener Zahlen und gibt das Ergebnis mithilfe der return-Anweisung zurück. Anschließend ruft das Skript diese Funktion mit Beispielwerten auf und gibt die zurückgegebene Summe in der Konsole aus. Dies zeigt, wie eine Funktion einen Wert zurückgeben kann, der erfasst und an anderer Stelle im Code verwendet werden kann.

Das ursprüngliche Skript wird dann so modifiziert, dass es basierend auf einer Bedingung unterschiedliche Werte zurückgibt. Dies verdeutlicht weiter die Flexibilität von Funktionsrückgaben. Dieser Schritt stärkt das Konzept von Funktionen als wiederverwendbaren Codeblöcken, die je nach Eingabe und internen Logik bestimmte Ausgaben liefern können.